@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

package/server/modules/websocket/services/chat-websocket.service.ts

@@ -3,7 +3,7 @@ import path from 'node:path';
 import type { WebSocket } from 'ws';
 
 import { sessionsDb } from '@/modules/database/index.js';
-import { providerModelsService } from '@/modules/providers/index.js';
+import { providerModelsService, sessionsService } from '@/modules/providers/index.js';
 import { chatRunRegistry } from '@/modules/websocket/services/chat-run-registry.service.js';
 import { connectedClients, WS_OPEN_STATE } from '@/modules/websocket/services/websocket-state.service.js';
 import {
@@ -64,7 +64,7 @@ export function filterImagesToUploadStore(
 }
 
 /** Application boundary for dispatching provider runs and approvals. */
-type ProviderRuntimeGateway = {
+export type ProviderRuntimeGateway = {
   hasRuntime(provider: string): boolean;
   run(
     provider: LLMProvider,
@@ -73,6 +73,9 @@ type ProviderRuntimeGateway = {
     writer: ProviderRuntimeWriter,
   ): Promise<unknown>;
   abort(provider: LLMProvider, sessionId: string): Promise<boolean>;
+  stopBackgroundTask(provider: LLMProvider, sessionId: string, taskId: string): Promise<boolean>;
+  /** Whether a provider runtime still holds background work for the session after its turn ended. */
+  hasBackgroundWork(sessionId: string): boolean;
   resolveToolApproval(requestId: string, payload: ProviderPermissionDecision): void;
   getPendingApprovalsForSession(sessionId: string): unknown[];
 };
@@ -149,10 +152,34 @@ async function handleChatSend(
   data: AnyRecord,
   dependencies: ChatWebSocketDependencies
 ): Promise<void> {
+  const resolved = resolveSendTarget(ws, data, dependencies, 'chat.send');
+  if (!resolved) {
+    return;
+  }
+
+  await dispatchRun(ws, userId, resolved.sessionId, resolved.session, data, dependencies);
+}
+
+type ResolvedSendTarget = {
+  sessionId: string;
+  session: NonNullable<ReturnType<typeof sessionsDb.getSessionById>>;
+  provider: LLMProvider;
+};
+
+/**
+ * Shared front half of `chat.send` and `chat.edit-send`: the session row and
+ * provider come from the database, never from the client.
+ */
+function resolveSendTarget(
+  ws: WebSocket,
+  data: AnyRecord,
+  dependencies: ChatWebSocketDependencies,
+  frameName: string,
+): ResolvedSendTarget | null {
   const sessionId = readRequiredSessionId(data);
   if (!sessionId) {
-    sendProtocolError(ws, 'SESSION_ID_REQUIRED', 'chat.send requires a sessionId.');
-    return;
+    sendProtocolError(ws, 'SESSION_ID_REQUIRED', `${frameName} requires a sessionId.`);
+    return null;
   }
 
   const session = sessionsDb.getSessionById(sessionId);
@@ -163,15 +190,36 @@ async function handleChatSend(
       `Session "${sessionId}" was not found. Create it via POST /api/providers/sessions first.`,
       sessionId
     );
-    return;
+    return null;
   }
 
   const provider = session.provider as LLMProvider;
   if (!dependencies.runtime.hasRuntime(provider)) {
     sendProtocolError(ws, 'UNSUPPORTED_PROVIDER', `Provider "${provider}" is not available.`, sessionId);
-    return;
+    return null;
   }
 
+  return { sessionId, session, provider };
+}
+
+/**
+ * Registers the run and hands the turn to the provider runtime.
+ *
+ * `extraRuntimeOptions` is how an edited message asks the provider to resume
+ * partway instead of continuing from the tip; a normal send passes nothing.
+ */
+async function dispatchRun(
+  ws: WebSocket | null,
+  userId: string | number | null,
+  sessionId: string,
+  session: NonNullable<ReturnType<typeof sessionsDb.getSessionById>>,
+  data: AnyRecord,
+  dependencies: ChatWebSocketDependencies,
+  extraRuntimeOptions: AnyRecord = {},
+  beforeRun?: (run: NonNullable<ReturnType<typeof chatRunRegistry.startRun>>) => void | Promise<void>,
+): Promise<{ started: boolean; error: string | null }> {
+  const provider = session.provider as LLMProvider;
+
   const run = chatRunRegistry.startRun({
     appSessionId: sessionId,
     provider,
@@ -181,13 +229,15 @@ async function handleChatSend(
   });
 
   if (!run) {
-    sendProtocolError(
-      ws,
-      'RUN_IN_PROGRESS',
-      `Session "${sessionId}" already has a run in progress.`,
-      sessionId
-    );
-    return;
+    if (ws) {
+      sendProtocolError(
+        ws,
+        'RUN_IN_PROGRESS',
+        `Session "${sessionId}" already has a run in progress.`,
+        sessionId
+      );
+    }
+    return { started: false, error: 'A run is already in progress for this session.' };
   }
 
   const clientOptions = (data.options ?? {}) as AnyRecord;
@@ -221,6 +271,7 @@ async function handleChatSend(
   // app session id.
   const runtimeOptions: AnyRecord = {
     ...clientOptions,
+    ...extraRuntimeOptions,
     // Attachments are re-validated server-side: only direct children of the
     // global upload store may reach provider runtimes or their file tools.
     attachments: uniqueAttachments,
@@ -231,11 +282,17 @@ async function handleChatSend(
     projectPath: session.project_path ?? clientOptions.projectPath,
   };
 
+  let failure: string | null = null;
   try {
+    // Runs only now that the session is reserved, because an edit rewinds the
+    // conversation here and a rewind for a run that was never admitted cannot
+    // be taken back. Inside the try so a rewind that throws still releases the
+    // run instead of leaving the session processing forever.
+    await beforeRun?.(run);
     await dependencies.runtime.run(provider, command, runtimeOptions, run.writer);
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`[Chat] Provider runtime "${provider}" failed`, { sessionId, error: message });
+    failure = error instanceof Error ? error.message : String(error);
+    console.error(`[Chat] Provider runtime "${provider}" failed`, { sessionId, error: failure });
   } finally {
     // Safety net: a runtime that crashed (or resolved) without emitting its
     // terminal `complete` would otherwise leave the session stuck in
@@ -244,6 +301,113 @@ async function handleChatSend(
     // settles, and the session-keyed completeRun would kill that new run.
     chatRunRegistry.completeRunIfCurrent(run, { exitCode: 1 });
   }
+
+  return { started: true, error: failure };
+}
+
+/**
+ * Handles `chat.edit-send`: replaces an already-sent message and everything
+ * after it with a new turn.
+ *
+ * Nothing is deleted. The provider resumes the conversation partway and
+ * appends the replacement, so the abandoned attempt stays in the transcript
+ * file and is simply no longer part of the live conversation — the same shape
+ * Claude Code's rewind and Codex's fork-with-cut-point produce.
+ */
+async function handleChatEditSend(
+  ws: WebSocket,
+  userId: string | number | null,
+  data: AnyRecord,
+  dependencies: ChatWebSocketDependencies
+): Promise<void> {
+  const resolved = resolveSendTarget(ws, data, dependencies, 'chat.edit-send');
+  if (!resolved) {
+    return;
+  }
+
+  const { sessionId, session, provider } = resolved;
+  const anchorId = typeof data.anchorId === 'string' ? data.anchorId.trim() : '';
+  if (!anchorId) {
+    sendProtocolError(ws, 'ANCHOR_REQUIRED', 'chat.edit-send requires the anchorId of the message being replaced.', sessionId);
+    return;
+  }
+
+  let resumeThroughId: string | null;
+  try {
+    const anchor = await sessionsService.resolveEditAnchor(sessionId, anchorId);
+    if (!anchor) {
+      sendProtocolError(
+        ws,
+        'EDIT_NOT_SUPPORTED',
+        `Provider "${provider}" cannot replace an already-sent message.`,
+        sessionId
+      );
+      return;
+    }
+    if (!anchor.found) {
+      sendProtocolError(ws, 'ANCHOR_NOT_FOUND', 'That message is no longer in the transcript.', sessionId);
+      return;
+    }
+    resumeThroughId = anchor.resumeThroughId;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    sendProtocolError(ws, 'ANCHOR_LOOKUP_FAILED', `Could not read the transcript: ${message}`, sessionId);
+    return;
+  }
+
+  // Providers split here on what their runtime can do. Claude resumes its
+  // transcript partway, so the anchor rides along as a run option. Codex
+  // cannot — a thread only grows — so the conversation is rewound on disk and
+  // the run that follows is an ordinary resume of whatever the session then
+  // points at. Which of the two applies is decided here; the rewind itself
+  // waits until the run has actually been admitted.
+  const rewinds = sessionsService.providerRewindsForEdit(sessionId);
+
+  await dispatchRun(
+    ws,
+    userId,
+    sessionId,
+    session,
+    data,
+    dependencies,
+    // `null` is meaningful: the edited turn was the first prompt, so the
+    // conversation starts over instead of resuming.
+    rewinds
+      ? {}
+      : { resumeAnchorId: resumeThroughId ?? undefined, resumeFromScratch: resumeThroughId === null },
+    async (run) => {
+      // Emitted through the run's writer so it is sequenced and replayed like
+      // any other event — a second tab watching this session has to truncate
+      // too.
+      //
+      // Before the rewind, not after it. A rewind that has to branch spawns a
+      // process and waits on a JSON-RPC round trip, and holding the frame
+      // until that came back left the message the user had just edited away
+      // sitting on screen for about a second — the very flicker this feature
+      // exists to avoid. Announcing first is safe because a rewind that fails
+      // still ends the run, and the terminal `complete` makes every client
+      // re-read the transcript, which puts back anything that turned out not
+      // to have been replaced after all.
+      run.writer.send({
+        kind: 'history_truncated',
+        provider,
+        sessionId,
+        anchorId,
+      });
+
+      if (rewinds) {
+        try {
+          await sessionsService.rewindSessionForEdit(sessionId, resumeThroughId);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          sendProtocolError(ws, 'EDIT_REWIND_FAILED', `Could not rewind the conversation: ${message}`, sessionId);
+          // Ends the run before the provider is asked to continue a
+          // conversation that was not rewound after all.
+          throw error;
+        }
+      }
+    },
+  );
 }
 
 /**
@@ -276,6 +440,52 @@ async function handleChatAbort(
   });
 }
 
+/**
+ * Handles `chat.stop-task`: stops one background task of a session — an
+ * agent, a workflow or a backgrounded command that is still going after its
+ * turn ended. Unlike `chat.abort` there is no run to consult: the task lives
+ * in the provider's held process, which is the only thing that can stop it.
+ * The provider then reports the task as stopped on the session's stream, so
+ * nothing is echoed back here on success.
+ */
+async function handleChatStopTask(
+  ws: WebSocket,
+  data: AnyRecord,
+  dependencies: ChatWebSocketDependencies
+): Promise<void> {
+  const sessionId = readRequiredSessionId(data);
+  if (!sessionId) {
+    sendProtocolError(ws, 'SESSION_ID_REQUIRED', 'chat.stop-task requires a sessionId.');
+    return;
+  }
+
+  const taskId = typeof data.taskId === 'string' ? data.taskId.trim() : '';
+  if (!taskId) {
+    sendProtocolError(ws, 'TASK_ID_REQUIRED', 'chat.stop-task requires a taskId.', sessionId);
+    return;
+  }
+
+  const session = sessionsDb.getSessionById(sessionId);
+  if (!session) {
+    sendProtocolError(ws, 'SESSION_NOT_FOUND', `Session "${sessionId}" was not found.`, sessionId);
+    return;
+  }
+
+  const stopped = await dependencies.runtime.stopBackgroundTask(
+    session.provider as LLMProvider,
+    sessionId,
+    taskId,
+  );
+  if (!stopped) {
+    sendProtocolError(
+      ws,
+      'NO_SUCH_TASK',
+      `Session "${sessionId}" has no running background task "${taskId}".`,
+      sessionId,
+    );
+  }
+}
+
 /**
  * Handles `chat.subscribe`: for each requested session, reports whether a run
  * is processing, re-attaches the live stream to this socket, replays missed
@@ -313,7 +523,11 @@ function handleChatSubscribe(
 
     // Future live events for this run should land on the socket that asked —
     // this is what makes mid-stream page refreshes work for all providers.
-    if (isProcessing) {
+    // A session whose turn ended but whose background work is still going
+    // keeps producing events through the same writer (task progress, the
+    // turn the CLI pushes when a task reports), so a tab opened during that
+    // work attaches too; the registry keeps the run while the work lasts.
+    if (isProcessing || dependencies.runtime.hasBackgroundWork(sessionId)) {
       chatRunRegistry.attachConnection(sessionId, ws);
     }
 
@@ -366,6 +580,7 @@ function handlePermissionResponse(data: AnyRecord, dependencies: ChatWebSocketDe
  * Inbound protocol (client to server):
  * - `chat.send`                { sessionId, content, options? }
  * - `chat.abort`               { sessionId }
+ * - `chat.stop-task`           { sessionId, taskId }
  * - `chat.subscribe`           { sessions: [{ sessionId, lastSeq? }] }
  * - `chat.permission-response` { requestId, allow, updatedInput?, message?, rememberEntry? }
  *
@@ -374,6 +589,71 @@ function handlePermissionResponse(data: AnyRecord, dependencies: ChatWebSocketDe
  * (`chat_subscribed`, `session_upserted`, `loading_progress`,
  * `protocol_error`).
  */
+/**
+ * Runs a turn for a session with no client attached.
+ *
+ * Used by scheduled messages, which fire from a timer: there is no socket to
+ * report errors to and no audience to stream to. The run is registered exactly
+ * like an interactive one, so anyone who opens the session while it is going
+ * subscribes and replays it from the start, and the session shows as busy
+ * everywhere in the meantime.
+ *
+ * Resolves when the provider run settles. Returns false when the session has
+ * gone away or is busy without `interruptActiveRun`, which the caller reports
+ * on the schedule.
+ */
+export async function runDetachedChatTurn(
+  input: {
+    sessionId: string;
+    userId: string | number | null;
+    content: string;
+    options?: AnyRecord;
+    /**
+     * Aborts a run already in progress instead of refusing to start. A
+     * scheduled message sets this: the user picked the time knowing it might
+     * land mid-run, so the timer outranks whatever is running.
+     */
+    interruptActiveRun?: boolean;
+  },
+  dependencies: ChatWebSocketDependencies,
+): Promise<{ started: boolean; error: string | null }> {
+  const session = sessionsDb.getSessionById(input.sessionId);
+  if (!session) {
+    return { started: false, error: 'The session no longer exists.' };
+  }
+
+  const provider = session.provider as LLMProvider;
+  if (!dependencies.runtime.hasRuntime(provider)) {
+    return { started: false, error: `Provider "${provider}" is not available.` };
+  }
+
+  const activeRun = chatRunRegistry.getRun(input.sessionId);
+  if (activeRun && activeRun.status === 'running') {
+    if (!input.interruptActiveRun) {
+      return { started: false, error: 'A run was already in progress for this session.' };
+    }
+    // Same shape as `chat.abort`: cancel the provider run and emit the
+    // terminal `complete` on its behalf, so every watching client sees the
+    // interrupted run end before this turn's stream begins. The interrupted
+    // run's own dispatch settles later through completeRunIfCurrent, which is
+    // scoped to that run and cannot touch the one started here.
+    const aborted = await dependencies.runtime.abort(activeRun.provider, input.sessionId);
+    chatRunRegistry.completeRun(input.sessionId, {
+      exitCode: aborted ? 0 : 1,
+      aborted: true,
+    });
+  }
+
+  return dispatchRun(
+    null,
+    input.userId,
+    input.sessionId,
+    session,
+    { sessionId: input.sessionId, content: input.content, options: input.options ?? {} },
+    dependencies,
+  );
+}
+
 export function handleChatConnection(
   ws: WebSocket,
   request: AuthenticatedWebSocketRequest,
@@ -395,12 +675,18 @@ export function handleChatConnection(
       const messageType = typeof data.type === 'string' ? data.type : '';
 
       switch (messageType) {
+        case 'chat.edit-send':
+          await handleChatEditSend(ws, userId, data, dependencies);
+          return;
         case 'chat.send':
           await handleChatSend(ws, userId, data, dependencies);
           return;
         case 'chat.abort':
           await handleChatAbort(ws, data, dependencies);
           return;
+        case 'chat.stop-task':
+          await handleChatStopTask(ws, data, dependencies);
+          return;
         case 'chat.subscribe':
           handleChatSubscribe(ws, data, dependencies);
           return;

package/server/modules/websocket/services/session-upsert-broadcast.service.ts

@@ -0,0 +1,108 @@
+import path from 'node:path';
+
+import { projectsDb, sessionsDb } from '@/modules/database/index.js';
+import { generateDisplayName } from '@/modules/projects/index.js';
+import { connectedClients, WS_OPEN_STATE } from '@/modules/websocket/services/websocket-state.service.js';
+import type { SessionUpsertedEvent } from '@/shared/types.js';
+
+/**
+ * The single producer of the `session_upserted` delta.
+ *
+ * The event carries everything a sidebar needs to upsert a session in place
+ * (its summary plus the owning project's metadata), so clients never refetch
+ * the whole project list because one transcript changed on disk.
+ *
+ * It used to be built in two places — the on-disk sessions watcher and the
+ * chat run registry — and only the registry's copy set `providerSessionId`.
+ * That field is how the client notices a row it is showing has been merged
+ * into its canonical app-session row, so a merge announced by any other path
+ * left a stale duplicate in the sidebar. One builder, one shape.
+ */
+async function buildSessionUpsertedEvent(
+  sessionIdOrProviderSessionId: string,
+): Promise<SessionUpsertedEvent | null> {
+  // Resolving by provider id first covers the watcher, which only ever sees
+  // the id written in the transcript. For a row where the two ids are equal
+  // — legacy rows, and any session indexed from disk before its mapping
+  // existed — both lookups land on the same row anyway.
+  const row = sessionsDb.getSessionByProviderSessionId(sessionIdOrProviderSessionId)
+    ?? sessionsDb.getSessionById(sessionIdOrProviderSessionId);
+  if (!row || row.isArchived) {
+    return null;
+  }
+
+  const projectPath = row.project_path;
+  const project = projectPath ? projectsDb.getProjectPath(projectPath) : null;
+  const displayName = project?.custom_project_name?.trim()
+    ? project.custom_project_name
+    : await generateDisplayName(path.basename(projectPath ?? '') || (projectPath ?? ''), projectPath);
+
+  return {
+    kind: 'session_upserted',
+    sessionId: row.session_id,
+    providerSessionId: row.provider_session_id ?? null,
+    // The column is a plain TEXT and typed as `string` on the row, but only
+    // provider adapters ever write it.
+    provider: row.provider as SessionUpsertedEvent['provider'],
+    session: {
+      id: row.session_id,
+      summary: row.custom_name || '',
+      messageCount: 0,
+      lastActivity: row.updated_at ?? row.created_at ?? new Date().toISOString(),
+    },
+    project: project
+      ? {
+        projectId: project.project_id,
+        path: project.project_path,
+        fullPath: project.project_path,
+        displayName,
+        isStarred: Boolean(project.isStarred),
+      }
+      : null,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+function sendToConnectedClients(payloads: string[]): void {
+  if (payloads.length === 0) {
+    return;
+  }
+
+  connectedClients.forEach((client) => {
+    if (client.readyState === WS_OPEN_STATE) {
+      for (const payload of payloads) {
+        client.send(payload);
+      }
+    }
+  });
+}
+
+/** Announces one session. Used by the chat run registry when a run reports its provider-native id. */
+export async function broadcastSessionUpserted(sessionIdOrProviderSessionId: string): Promise<void> {
+  const event = await buildSessionUpsertedEvent(sessionIdOrProviderSessionId);
+  if (event) {
+    sendToConnectedClients([JSON.stringify(event)]);
+  }
+}
+
+/**
+ * Announces a batch of sessions. Used by the providers module's sessions
+ * watcher, whose debounced flush can carry dozens of ids at once — the client
+ * set is walked once for the whole batch rather than once per session.
+ */
+export async function broadcastSessionUpsertedBatch(
+  sessionIds: Iterable<string>,
+): Promise<void> {
+  const payloads: string[] = [];
+  for (const sessionId of sessionIds) {
+    const event = await buildSessionUpsertedEvent(sessionId);
+    if (event) {
+      payloads.push(JSON.stringify(event));
+    }
+  }
+
+  sendToConnectedClients(payloads);
+}
+
+/** @internal Exported for the broadcast tests, which assert the payload shape directly. */
+export { buildSessionUpsertedEvent };