Add fresh default sessions and terminal status handling

src/bin/dosh-server.rs

@@ -465,6 +465,7 @@ async fn handle_resume(
         output_seq,
         bytes: snapshot,
         snapshot: true,
+        closed: false,
     };
     let body = protocol::to_body(&frame)?;
     let out = protocol::encode_encrypted(
@@ -614,6 +615,10 @@ async fn broadcast_output(
     socket: &Arc<UdpSocket>,
     output: PtyOutput,
 ) -> Result<()> {
+    if output.exited {
+        return broadcast_session_exit(state, socket, output.session).await;
+    }
+
     let sends = {
         let mut locked = state.lock().expect("server state poisoned");
         let scrollback = locked.config.scrollback;
@@ -652,6 +657,7 @@ async fn broadcast_output(
                 output_seq,
                 bytes,
                 snapshot,
+                closed: false,
             };
             let body = protocol::to_body(&frame)?;
             let packet = protocol::encode_encrypted(
@@ -683,6 +689,48 @@ async fn broadcast_output(
     Ok(())
 }
 
+async fn broadcast_session_exit(
+    state: &Arc<Mutex<ServerState>>,
+    socket: &Arc<UdpSocket>,
+    session_name: String,
+) -> Result<()> {
+    let sends = {
+        let mut locked = state.lock().expect("server state poisoned");
+        let Some(mut session) = locked.sessions.remove(&session_name) else {
+            return Ok(());
+        };
+        session.output_seq += 1;
+        let output_seq = session.output_seq;
+        let mut sends = Vec::new();
+        for (client_id, mut client) in session.clients.drain() {
+            client.send_seq += 1;
+            let frame = Frame {
+                session: session_name.clone(),
+                output_seq,
+                bytes: b"\r\n[dosh session exited]\r\n".to_vec(),
+                snapshot: false,
+                closed: true,
+            };
+            let body = protocol::to_body(&frame)?;
+            let packet = protocol::encode_encrypted(
+                PacketKind::Frame,
+                client_id,
+                client.send_seq,
+                client.last_acked,
+                &client.session_key,
+                SERVER_TO_CLIENT,
+                &body,
+            )?;
+            sends.push((client.endpoint, packet));
+        }
+        sends
+    };
+    for (endpoint, packet) in sends {
+        socket.send_to(&packet, endpoint).await?;
+    }
+    Ok(())
+}
+
 async fn retransmit_pending(
     state: &Arc<Mutex<ServerState>>,
     socket: &Arc<UdpSocket>,