fix(share): address remaining copilot review findings

Author: jamesbrink

src-server/src/collab.rs

@@ -11,7 +11,7 @@ use claudette::room::{ParticipantInfo, Vote};
 use serde_json::json;
 
 use crate::handler::ConnectionCtx;
-use crate::ws::{ServerState, Writer, send_message};
+use crate::ws::{ServerState, Writer, try_send_message};
 
 /// Register a participant against a room, spawn their per-connection event
 /// forwarder, and return a snapshot of the room's current state so the
@@ -76,14 +76,16 @@ pub async fn handle_join_session(
         let writer = Arc::clone(writer);
         let mut rx = room.subscribe();
         let chat_session_id_for_forwarder = chat_session_id.to_string();
-        tokio::spawn(async move {
+        let forwarder = tokio::spawn(async move {
             loop {
                 match rx.recv().await {
                     Ok(evt) => {
-                        send_message(&writer, &evt.0).await;
+                        if try_send_message(&writer, &evt.0).await.is_err() {
+                            break;
+                        }
                     }
                     Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => {
-                        let _ = send_message(
+                        if try_send_message(
                             &writer,
                             &json!({
                                 "event": "resync-required",
@@ -92,12 +94,20 @@ pub async fn handle_join_session(
                                 },
                             }),
                         )
-                        .await;
+                        .await
+                        .is_err()
+                        {
+                            break;
+                        }
                     }
                     Err(tokio::sync::broadcast::error::RecvError::Closed) => break,
                 }
             }
         });
+        ctx.room_forwarders
+            .lock()
+            .await
+            .insert(chat_session_id.to_string(), forwarder);
     }
 
     // Snapshot for late joiners: full chat history + current participants +
@@ -129,6 +139,9 @@ pub async fn handle_leave_session(
     };
     let removed = ctx.joined_sessions.lock().await.remove(chat_session_id);
     if removed {
+        if let Some(handle) = ctx.room_forwarders.lock().await.remove(chat_session_id) {
+            handle.abort();
+        }
         room.remove_participant(&ctx.participant_id).await;
         room.publish(json!({
             "event": "participants-changed",
@@ -192,6 +205,16 @@ pub async fn handle_vote_plan_approval(
 /// resulting roster updates. Called from the WS connection-close path.
 pub async fn drop_all_joined_sessions(state: &Arc<ServerState>, ctx: &ConnectionCtx) {
     let session_ids: Vec<String> = ctx.joined_sessions.lock().await.drain().collect();
+    let forwarders: Vec<tokio::task::JoinHandle<()>> = ctx
+        .room_forwarders
+        .lock()
+        .await
+        .drain()
+        .map(|(_, h)| h)
+        .collect();
+    for handle in forwarders {
+        handle.abort();
+    }
     for session_id in session_ids {
         let Some(room) = state.rooms.get(&session_id).await else {
             continue;

src-server/src/handler.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
 use claudette::agent::{self, AgentEvent, AgentSettings, InnerStreamEvent, StreamEvent};
@@ -44,6 +44,7 @@ pub struct ConnectionCtx {
     pub display_name: String,
     pub is_host: bool,
     pub joined_sessions: Arc<Mutex<HashSet<String>>>,
+    pub room_forwarders: Arc<Mutex<HashMap<String, tokio::task::JoinHandle<()>>>>,
     /// The id of the share this connection authenticated against. Each RPC
     /// re-checks the share still exists in the live config; a missing
     /// share means the host revoked it and every subsequent request fails.
@@ -76,6 +77,7 @@ impl ConnectionCtx {
             display_name,
             is_host: false,
             joined_sessions: Arc::new(Mutex::new(HashSet::new())),
+            room_forwarders: Arc::new(Mutex::new(HashMap::new())),
             share_id,
             allowed_workspace_ids,
             collaborative,

src-server/src/ws.rs

@@ -190,10 +190,17 @@ pub type Writer = tokio::sync::Mutex<
     futures_util::stream::SplitSink<WebSocketStream<TlsStream<TcpStream>>, Message>,
 >;
 
-pub async fn send_message(writer: &Writer, value: &serde_json::Value) {
+pub async fn try_send_message(
+    writer: &Writer,
+    value: &serde_json::Value,
+) -> Result<(), tokio_tungstenite::tungstenite::Error> {
     let text = serde_json::to_string(value).unwrap_or_default();
     let mut w = writer.lock().await;
-    let _ = w.send(Message::Text(text.into())).await;
+    w.send(Message::Text(text.into())).await
+}
+
+pub async fn send_message(writer: &Writer, value: &serde_json::Value) {
+    let _ = try_send_message(writer, value).await;
 }
 
 /// Accept a TLS connection and upgrade it to WebSocket.

src-server/tests/workspace_archive_propagation.rs

@@ -50,6 +50,7 @@ fn make_workspace(id: &str, repo_id: &str, status: WorkspaceStatus) -> Workspace
         status,
         agent_status: AgentStatus::Idle,
         status_line: String::new(),
+        sort_order: 0,
         created_at: "2026-01-01 00:00:00".into(),
     }
 }

src-tauri/src/commands/share.rs

@@ -16,6 +16,8 @@ use tauri::{AppHandle, State};
 
 #[cfg(feature = "server")]
 use std::sync::Arc;
+#[cfg(feature = "server")]
+use tauri::Manager;
 
 use crate::state::AppState;
 
@@ -208,6 +210,7 @@ async fn ensure_share_server(app: &AppHandle, state: &AppState) -> Result<bool,
     let rooms = std::sync::Arc::clone(&state.rooms);
     let workspace_events = std::sync::Arc::clone(&state.workspace_events);
     let cfg_for_server = Arc::clone(&cfg_arc);
+    let app_for_server = app.clone();
     let opts = claudette_server::ServerOptions {
         existing_config: Some(cfg_for_server),
         ..Default::default()
@@ -218,15 +221,15 @@ async fn ensure_share_server(app: &AppHandle, state: &AppState) -> Result<bool,
         {
             eprintln!("[share] in-process server exited: {e}");
         }
+        let state = app_for_server.state::<AppState>();
+        *state.collab_server_running.write().await = false;
     });
 
     // The host event subscriber attaches via `RoomRegistry::set_on_create`,
     // installed once at app startup in `main.rs::setup`. Each new room
     // gets a host-side mirror task synchronously at creation time, before
     // any handler can publish into it (see the on_create hook docstring
     // in `src/room.rs` for why this ordering is load-bearing).
-    let _ = app;
-
     *running = true;
     Ok(true)
 }

src-tauri/src/state.rs

@@ -414,12 +414,13 @@ pub struct AppState {
     /// constructed unconditionally in `AppState::new` so publishers don't
     /// need to handle the absent case.
     pub workspace_events: Arc<WorkspaceEventBus>,
-    /// `true` once the in-process collaborative server has been started for
+    /// `true` while the in-process collaborative server is running for
     /// this app instance. Distinct from `local_server` (subprocess) — the
     /// in-process server shares `rooms` with `AppState` and is used only for
-    /// collab share. Remains `true` for the rest of the app lifetime; we
-    /// don't currently support tearing it down. Used to refuse to start the
-    /// subprocess server when an in-process server already owns the port.
+    /// collab share. Reset when the server task exits so a failed bind or
+    /// early shutdown can be retried without restarting the app. Used to
+    /// refuse to start the subprocess server when an in-process server
+    /// already owns the port.
     pub collab_server_running: tokio::sync::RwLock<bool>,
     /// Shared `ServerConfig` for the in-process share server. Lazily
     /// constructed on first `start_share` call and kept as a clone of the

src/ui/src/components/chat/ParticipantsRoster.tsx

@@ -1,4 +1,5 @@
 import { useState } from "react";
+import { useTranslation } from "react-i18next";
 import { Crown, MicOff, MoreHorizontal, UserMinus, Users } from "lucide-react";
 import { useAppStore } from "../../stores/useAppStore";
 import { kickParticipant, muteParticipant } from "../../services/tauri";
@@ -26,6 +27,7 @@ export function ParticipantsRoster({
   sessionId: string;
   selfParticipantId: string | null;
 }) {
+  const { t } = useTranslation("chat");
   const participants = useAppStore((s) => s.participants[sessionId]);
   const [openMenuFor, setOpenMenuFor] = useState<string | null>(null);
 
@@ -48,7 +50,7 @@ export function ParticipantsRoster({
         gap: 4,
         padding: "0 6px",
       }}
-      title={`${participants.length} connected`}
+      title={t("participants_connected", { count: participants.length })}
     >
       <Users size={12} style={{ opacity: 0.6 }} />
       {participants.map((p) => {
@@ -83,8 +85,10 @@ export function ParticipantsRoster({
                 onClick={() =>
                   setOpenMenuFor(openMenuFor === p.id ? null : p.id)
                 }
-                title="Moderate"
-                aria-label={`Moderate ${p.display_name}`}
+                title={t("participant_moderate_title")}
+                aria-label={t("participant_moderate_aria", {
+                  name: p.display_name,
+                })}
                 style={{
                   background: "transparent",
                   border: "none",
@@ -126,7 +130,7 @@ export function ParticipantsRoster({
                   }}
                 >
                   <MicOff size={12} />
-                  {p.muted ? "Unmute" : "Mute"}
+                  {p.muted ? t("participant_unmute") : t("participant_mute")}
                 </button>
                 <button
                   style={moderationItemStyle}
@@ -140,7 +144,7 @@ export function ParticipantsRoster({
                   }}
                 >
                   <UserMinus size={12} />
-                  Kick
+                  {t("participant_kick")}
                 </button>
               </div>
             )}

src/ui/src/components/chat/PlanApprovalCard.tsx

@@ -48,6 +48,7 @@ export function PlanApprovalCard({
     let content: string;
     if (remoteConnectionId) {
       content = (await sendRemoteCommand(remoteConnectionId, "read_plan_file", {
+        chat_session_id: approval.sessionId,
         path: approval.planFilePath,
       })) as string;
     } else {
@@ -217,6 +218,7 @@ export function PlanApprovalCard({
  * `"host"`, matching what the Rust resolver records.
  */
 function ConsensusProgress({ approval }: { approval: PlanApproval }) {
+  const { t } = useTranslation("chat");
   const vote = useAppStore((s) => s.consensusVotes[approval.sessionId]);
   // Compare voter ids against the local participant's id (the workspace's
   // self-pid), NOT the literal `"host"` — on a remote client the local
@@ -232,21 +234,26 @@ function ConsensusProgress({ approval }: { approval: PlanApproval }) {
   return (
     <div style={{ marginTop: 8, display: "flex", flexDirection: "column", gap: 4, fontSize: 12 }}>
       <div>
-        <strong>Consensus required:</strong> {totalVoted}/{totalRequired} voted
+        <strong>
+          {t("plan_approval_consensus_required", {
+            voted: totalVoted,
+            required: totalRequired,
+          })}
+        </strong>
       </div>
       {vote.requiredVoters.map((voter) => {
         const cast = vote.votes[voter.id];
         const status = cast
           ? cast.kind === "approve"
-            ? "approved"
-            : `denied: ${cast.reason}`
-          : "waiting";
+            ? t("plan_approval_vote_approved")
+            : t("plan_approval_vote_denied", { reason: cast.reason })
+          : t("plan_approval_vote_waiting");
         const isSelf = voter.id === selfParticipantId;
         return (
           <div key={voter.id}>
             <span>{voter.display_name}</span>
-            {isSelf ? " (you)" : ""}
-            {voter.is_host ? " · host" : ""}
+            {isSelf ? ` ${t("plan_approval_you_marker")}` : ""}
+            {voter.is_host ? ` · ${t("plan_approval_host_marker")}` : ""}
             {": "}
             <em>{status}</em>
           </div>

src/ui/src/locales/en/chat.json

@@ -85,6 +85,19 @@
   "plan_approval_or_feedback": "Or provide feedback below",
   "plan_approval_feedback_placeholder": "Request changes or ask for a revision…",
   "plan_approval_send": "Send",
+  "plan_approval_consensus_required": "Consensus required: {{voted}}/{{required}} voted",
+  "plan_approval_vote_approved": "approved",
+  "plan_approval_vote_denied": "denied: {{reason}}",
+  "plan_approval_vote_waiting": "waiting",
+  "plan_approval_you_marker": "(you)",
+  "plan_approval_host_marker": "host",
+  "participants_connected_one": "{{count}} connected",
+  "participants_connected_other": "{{count}} connected",
+  "participant_moderate_title": "Moderate",
+  "participant_moderate_aria": "Moderate {{name}}",
+  "participant_mute": "Mute",
+  "participant_unmute": "Unmute",
+  "participant_kick": "Kick",
 
   "session_new": "New session",
   "session_close": "Close session",

src/ui/src/locales/es/chat.json

@@ -22,6 +22,9 @@
   "composer_placeholder_queued": "Escribe para encolar un mensaje...",
   "composer_placeholder_shell": "Ejecuta un comando shell...",
   "shell_mode_label": "Shell",
+  "composer_locked_placeholder": "{{name}} está preguntando…",
+  "composer_locked_title": "Bloqueado: {{name}} está controlando el agente",
+  "user_label": "Usuario",
   "voice_input": "Entrada de voz",
   "voice_stop": "Detener entrada de voz",
   "voice_discard": "Descartar transcripción",
@@ -82,6 +85,19 @@
   "plan_approval_or_feedback": "O proporciona comentarios abajo",
   "plan_approval_feedback_placeholder": "Solicita cambios o pide una revisión…",
   "plan_approval_send": "Enviar",
+  "plan_approval_consensus_required": "Consenso requerido: {{voted}}/{{required}} votaron",
+  "plan_approval_vote_approved": "aprobó",
+  "plan_approval_vote_denied": "denegó: {{reason}}",
+  "plan_approval_vote_waiting": "esperando",
+  "plan_approval_you_marker": "(tú)",
+  "plan_approval_host_marker": "anfitrión",
+  "participants_connected_one": "{{count}} conectado",
+  "participants_connected_other": "{{count}} conectados",
+  "participant_moderate_title": "Moderar",
+  "participant_moderate_aria": "Moderar a {{name}}",
+  "participant_mute": "Silenciar",
+  "participant_unmute": "Reactivar sonido",
+  "participant_kick": "Expulsar",
 
   "session_new": "Nueva sesión",
   "session_close": "Cerrar sesión",