@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

package/server/modules/providers/services/session-synchronizer.service.ts

@@ -1,59 +1,146 @@
-import { scanStateDb } from '@/modules/database/index.js';
+import path from 'node:path';
+import { access } from 'node:fs/promises';
+
+import { scanStateDb, sessionsDb } from '@/modules/database/index.js';
 import { providerRegistry } from '@/modules/providers/provider.registry.js';
 import type { LLMProvider } from '@/shared/types.js';
 
 type SessionSynchronizeResult = {
   processedByProvider: Record<LLMProvider, number>;
+  /** Indexed sessions dropped because their transcript file no longer exists. */
+  prunedOrphans: number;
   failures: string[];
 };
 
+const pathExists = async (target: string): Promise<boolean> => {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Removes indexed sessions whose transcript file has disappeared from disk.
+ *
+ * Nothing else deletes these rows: the synchronizers only ever upsert, and the
+ * watcher reacts to `add`/`change` but not `unlink`. A transcript removed by
+ * hand — or written by a test run that pointed at the real `~/.claude` — left a
+ * permanent sidebar entry that opened an empty "Untitled" session.
+ *
+ * A row is only dropped when its *containing directory* still exists. That
+ * keeps an unmounted or not-yet-created home from being read as "every
+ * transcript was deleted" and wiping the whole index.
+ */
+const pruneOrphanedSessions = async (): Promise<number> => {
+  const knownDirectoryExists = new Map<string, boolean>();
+  let pruned = 0;
+
+  for (const { session_id: sessionId, jsonl_path: jsonlPath } of sessionsDb.getSessionsWithTranscriptPath()) {
+    if (await pathExists(jsonlPath)) {
+      continue;
+    }
+
+    const directory = path.dirname(jsonlPath);
+    let directoryExists = knownDirectoryExists.get(directory);
+    if (directoryExists === undefined) {
+      directoryExists = await pathExists(directory);
+      knownDirectoryExists.set(directory, directoryExists);
+    }
+
+    if (!directoryExists) {
+      continue;
+    }
+
+    if (sessionsDb.deleteSessionById(sessionId)) {
+      pruned += 1;
+    }
+  }
+
+  return pruned;
+};
+
+/**
+ * The scan that every `synchronizeSessions()` caller shares while it runs.
+ *
+ * Opening the UI fires `/api/projects` and `/api/projects/archived` at once,
+ * and each used to start its own full provider scan from the same
+ * `last_scanned_at` cursor: identical work over identical transcripts,
+ * contending for the same synchronous SQLite writes and doubling how long the
+ * sidebar sits on its loading screen. Callers that arrive while a scan is
+ * already running now await that scan instead of starting another.
+ */
+let inFlightSynchronization: Promise<SessionSynchronizeResult> | null = null;
+
+/**
+ * Runs all provider synchronizers and updates scan_state.last_scanned_at.
+ */
+async function runSessionSynchronization(): Promise<SessionSynchronizeResult> {
+  const lastScanAt = scanStateDb.getLastScannedAt();
+  const scanBoundary = new Date();
+  const processedByProvider: Record<LLMProvider, number> = {
+    claude: 0,
+    codex: 0,
+    cursor: 0,
+    opencode: 0,
+  };
+  const failures: string[] = [];
+
+  const results = await Promise.allSettled(
+    providerRegistry.listProviders().map(async (provider) => ({
+      provider: provider.id,
+      processed: await provider.sessionSynchronizer.synchronize(lastScanAt ?? undefined),
+    }))
+  );
+
+  for (const result of results) {
+    if (result.status === 'fulfilled') {
+      processedByProvider[result.value.provider] = result.value.processed;
+      continue;
+    }
+
+    const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+    failures.push(reason);
+  }
+
+  // Pruning is skipped after a partial sync: a provider that just failed may
+  // not have re-indexed transcripts it would otherwise have re-created.
+  const prunedOrphans = failures.length === 0 ? await pruneOrphanedSessions() : 0;
+
+  if (failures.length === 0) {
+    scanStateDb.updateLastScannedAt(scanBoundary);
+  } else {
+    console.warn(
+      `[Sessions] Skipping scan_state cursor advance because ${failures.length} provider sync(s) failed.`,
+    );
+  }
+
+  return {
+    processedByProvider,
+    prunedOrphans,
+    failures,
+  };
+}
+
 /**
  * Orchestrates provider-specific session indexers and indexed-session lifecycle operations.
  */
 export const sessionSynchronizerService = {
   /**
-   * Runs all provider synchronizers and updates scan_state.last_scanned_at.
+   * Scans every provider for new or changed sessions, coalescing concurrent
+   * callers onto a single scan.
    */
   async synchronizeSessions(): Promise<SessionSynchronizeResult> {
-    const lastScanAt = scanStateDb.getLastScannedAt();
-    const scanBoundary = new Date();
-    const processedByProvider: Record<LLMProvider, number> = {
-      claude: 0,
-      codex: 0,
-      cursor: 0,
-      opencode: 0,
-    };
-    const failures: string[] = [];
-
-    const results = await Promise.allSettled(
-      providerRegistry.listProviders().map(async (provider) => ({
-        provider: provider.id,
-        processed: await provider.sessionSynchronizer.synchronize(lastScanAt ?? undefined),
-      }))
-    );
-
-    for (const result of results) {
-      if (result.status === 'fulfilled') {
-        processedByProvider[result.value.provider] = result.value.processed;
-        continue;
-      }
-
-      const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
-      failures.push(reason);
+    if (inFlightSynchronization) {
+      return inFlightSynchronization;
     }
 
-    if (failures.length === 0) {
-      scanStateDb.updateLastScannedAt(scanBoundary);
-    } else {
-      console.warn(
-        `[Sessions] Skipping scan_state cursor advance because ${failures.length} provider sync(s) failed.`,
-      );
-    }
+    inFlightSynchronization = runSessionSynchronization().finally(() => {
+      inFlightSynchronization = null;
+    });
 
-    return {
-      processedByProvider,
-      failures,
-    };
+    return inFlightSynchronization;
   },
 
   /**

package/server/modules/providers/services/sessions-watcher.service.ts

@@ -4,11 +4,9 @@ import { promises as fsPromises } from 'node:fs';
 
 import chokidar, { type FSWatcher } from 'chokidar';
 
-import { projectsDb, sessionsDb } from '@/modules/database/index.js';
 import { sessionSynchronizerService } from '@/modules/providers/services/session-synchronizer.service.js';
-import { WS_OPEN_STATE, connectedClients } from '@/modules/websocket/index.js';
+import { broadcastSessionUpsertedBatch } from '@/modules/websocket/index.js';
 import type { LLMProvider } from '@/shared/types.js';
-import { generateDisplayName } from '@/modules/projects/index.js';
 
 type WatcherEventType = 'add' | 'change';
 
@@ -125,50 +123,6 @@ function queuePendingWatcherUpdate(
   schedulePendingWatcherFlush();
 }
 
-/**
- * Builds one `session_upserted` delta event for a provider-native session id.
- *
- * The event carries everything a sidebar needs to upsert the session in place
- * (session summary plus owning-project metadata), so clients never need a full
- * project-list refetch when a transcript file changes on disk. Returns `null`
- * when the id cannot be resolved to an indexed session row.
- */
-async function buildSessionUpsertedEvent(updatedProviderSessionId: string): Promise<string | null> {
-  const row = sessionsDb.getSessionByProviderSessionId(updatedProviderSessionId)
-    ?? sessionsDb.getSessionById(updatedProviderSessionId);
-  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 JSON.stringify({
-    kind: 'session_upserted',
-    sessionId: row.session_id,
-    provider: row.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(),
-  });
-}
-
 async function flushPendingWatcherUpdate(): Promise<void> {
   clearPendingWatcherFlushTimer();
 
@@ -190,23 +144,7 @@ async function flushPendingWatcherUpdate(): Promise<void> {
     // Per-session deltas instead of full project snapshots: an upsert of one
     // session can never clobber unrelated client state, so the frontend needs
     // no "suppress updates while a run is active" protection logic.
-    const events: string[] = [];
-    for (const updatedSessionId of queuedUpdate.updatedSessionIds) {
-      const event = await buildSessionUpsertedEvent(updatedSessionId);
-      if (event) {
-        events.push(event);
-      }
-    }
-
-    if (events.length > 0) {
-      connectedClients.forEach(client => {
-        if (client.readyState === WS_OPEN_STATE) {
-          for (const event of events) {
-            client.send(event);
-          }
-        }
-      });
-    }
+    await broadcastSessionUpsertedBatch(queuedUpdate.updatedSessionIds);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error('Session watcher refresh failed while broadcasting session_upserted', { error: message });
@@ -262,6 +200,7 @@ export async function initializeSessionsWatcher(): Promise<void> {
   const initialSync = await sessionSynchronizerService.synchronizeSessions();
   console.log('Initial session synchronization complete', {
     processedByProvider: initialSync.processedByProvider,
+    prunedOrphans: initialSync.prunedOrphans,
     failures: initialSync.failures,
   });
 

package/server/modules/providers/services/sessions.service.ts

@@ -3,15 +3,45 @@ import fsp from 'node:fs/promises';
 import path from 'node:path';
 
 import { projectsDb, sessionsDb } from '@/modules/database/index.js';
-import { chatRunRegistry } from '@/modules/websocket/index.js';
+import { broadcastSessionUpserted, chatRunRegistry } from '@/modules/websocket/index.js';
 import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import { listBusyClaudeCliSessions } from '@/modules/providers/services/claude-cli-liveness.service.js';
+import { sessionHistoryCache } from '@/modules/providers/services/session-history-cache.service.js';
 import type {
+  BackgroundTaskSummary,
   FetchHistoryOptions,
   FetchHistoryResult,
   LLMProvider,
   NormalizedMessage,
+  WorkflowAgentActivity,
 } from '@/shared/types.js';
-import { AppError } from '@/shared/utils.js';
+import { AppError, sliceTailPage } from '@/shared/utils.js';
+
+/**
+ * One session the running-sessions poll reports as busy.
+ *
+ * A chat run in progress is listed as before. A session whose turn has ended
+ * but whose background tasks are still outstanding is listed with
+ * `background: true` and `canInterrupt: false`: the composer stays usable
+ * (the runtime accepts a new turn while the work runs) and there is no run to
+ * abort — a task is stopped by id through `chat.stop-task` instead. `tasks`
+ * rides along on both kinds whenever the session has any.
+ *
+ * A turn driven outside CloudCLI — the Claude CLI in the Shell view, or a
+ * terminal the user opened themselves — is listed the same way, with
+ * `canInterrupt: false` because there is no run here to abort, and a
+ * `statusText` saying where the work is happening.
+ */
+type RunningSessionEntry = {
+  sessionId: string;
+  provider: LLMProvider;
+  startedAt: number;
+  lastSeq: number;
+  background?: true;
+  canInterrupt?: false;
+  statusText?: string;
+  tasks?: BackgroundTaskSummary[];
+};
 
 type CreateAppSessionResult = {
   sessionId: string;
@@ -124,18 +154,61 @@ export const sessionsService = {
   },
 
   /**
-   * Returns app-facing ids for provider runs that are currently processing.
+   * Returns app-facing ids for provider runs that are currently processing,
+   * plus every session whose background work outlived its turn.
    *
    * This is intentionally status-only: callers that only need sidebar activity
    * indicators should not attach to chat streams or request replayed messages.
    */
-  listRunningSessions(): Array<{
-    sessionId: string;
-    provider: LLMProvider;
-    startedAt: number;
-    lastSeq: number;
-  }> {
-    return chatRunRegistry.listRunningRuns();
+  async listRunningSessions(): Promise<RunningSessionEntry[]> {
+    const entries: RunningSessionEntry[] = chatRunRegistry.listRunningRuns();
+    const runningById = new Map(entries.map((entry) => [entry.sessionId, entry]));
+
+    for (const provider of providerRegistry.listProviders()) {
+      for (const { sessionId, tasks } of provider.runtime.listBackgroundWork?.() ?? []) {
+        const running = runningById.get(sessionId);
+        if (running) {
+          running.tasks = tasks;
+          continue;
+        }
+        entries.push({
+          sessionId,
+          provider: provider.id,
+          startedAt: Math.min(...tasks.map((task) => task.startedAt)),
+          // The completed run stays in the registry for a while, and a client
+          // that subscribes with its lastSeq replays the tail it missed.
+          lastSeq: chatRunRegistry.getRun(sessionId)?.lastSeq ?? 0,
+          background: true,
+          canInterrupt: false,
+          tasks,
+        });
+      }
+    }
+
+    // The chat-run registry only knows about turns CloudCLI drives itself, so
+    // without this a session working under the Claude CLI — including one
+    // CloudCLI spawned for its own Shell view — looks idle. A session already
+    // listed above keeps its richer entry.
+    for (const live of await listBusyClaudeCliSessions()) {
+      const session = sessionsDb.getSessionByProviderSessionId(live.providerSessionId);
+      if (!session || runningById.has(session.session_id)) {
+        continue;
+      }
+
+      entries.push({
+        sessionId: session.session_id,
+        provider: session.provider as LLMProvider,
+        startedAt: live.startedAt,
+        lastSeq: chatRunRegistry.getRun(session.session_id)?.lastSeq ?? 0,
+        // There is no run here to abort: the turn belongs to a CLI process
+        // CloudCLI does not own, so it can be reported but not interrupted.
+        canInterrupt: false,
+        statusText: 'Running in the Claude CLI',
+      });
+      runningById.set(session.session_id, entries[entries.length - 1]);
+    }
+
+    return entries;
   },
 
   /**
@@ -236,6 +309,79 @@ export const sessionsService = {
     };
   },
 
+  /**
+   * Branches a session into an independent one containing its conversation up
+   * to `upToAnchorId` (the whole thing when omitted).
+   *
+   * The source is left completely untouched — this is the "try two approaches"
+   * action, not a destructive one.
+   */
+  async forkSessionById(
+    sessionId: string,
+    options: { upToAnchorId?: string; title?: string } = {},
+  ): Promise<CreateAppSessionResult> {
+    const source = sessionsDb.getSessionById(sessionId);
+    if (!source) {
+      throw new AppError(`Session "${sessionId}" was not found.`, {
+        code: 'SESSION_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    const provider = source.provider as LLMProvider;
+    const fork = providerRegistry.resolveProvider(provider).fork;
+    if (!fork) {
+      throw new AppError(`Sessions cannot be forked for provider "${provider}".`, {
+        code: 'FORK_NOT_SUPPORTED',
+        statusCode: 409,
+      });
+    }
+
+    // A session that has never run has no transcript to copy, so there is
+    // nothing a fork of it could resume from.
+    if (!source.provider_session_id || !source.jsonl_path) {
+      throw new AppError('This session has not produced a transcript yet.', {
+        code: 'FORK_SOURCE_NOT_READY',
+        statusCode: 409,
+      });
+    }
+
+    const sessionName = options.title?.trim()
+      || `${source.custom_name?.trim() || 'Session'} (fork)`;
+
+    const forked = await fork.forkSession({
+      providerSessionId: source.provider_session_id,
+      jsonlPath: source.jsonl_path,
+      projectPath: source.project_path ?? '',
+      upToAnchorId: options.upToAnchorId,
+      title: sessionName,
+    });
+
+    const forkSessionId = randomUUID();
+    sessionsDb.createForkedSession({
+      sessionId: forkSessionId,
+      provider,
+      projectPath: source.project_path ?? '',
+      customName: sessionName,
+      providerSessionId: forked.providerSessionId,
+      jsonlPath: forked.jsonlPath,
+      forkedFromSessionId: sessionId,
+      // A fork that silently dropped to the catalog default would answer
+      // differently from the conversation it was branched from.
+      model: source.model,
+      effort: source.effort,
+    });
+
+    await broadcastSessionUpserted(forkSessionId);
+
+    return {
+      sessionId: forkSessionId,
+      provider,
+      projectPath: source.project_path ?? '',
+      sessionName,
+    };
+  },
+
   /**
    * Resolves the provider-native id only for an explicit user copy action.
    * Normal session payloads continue to expose only the stable app id.
@@ -268,6 +414,73 @@ export const sessionsService = {
    * and every returned message is remapped back to the app session id so
    * provider ids never reach the frontend.
    */
+  /**
+   * Resolves where a conversation must resume from so that one already-sent
+   * message, and everything after it, is replaced.
+   *
+   * Returns `null` when the provider cannot do this at all, which is how the
+   * chat gateway knows to refuse the request rather than silently sending the
+   * edit as a new message at the end of the conversation.
+   */
+  async resolveEditAnchor(
+    sessionId: string,
+    anchorId: string,
+  ): Promise<{ found: boolean; resumeThroughId: string | null } | null> {
+    const session = sessionsDb.getSessionById(sessionId);
+    if (!session) {
+      throw new AppError(`Session "${sessionId}" was not found.`, {
+        code: 'SESSION_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    const sessions = providerRegistry.resolveProvider(session.provider as LLMProvider).sessions;
+    if (!sessions.resolveEditAnchor) {
+      return null;
+    }
+
+    return sessions.resolveEditAnchor(sessionId, anchorId);
+  },
+
+  /**
+   * Whether editing a message on this session's provider means rewinding it on
+   * disk first, rather than handing the anchor to the runtime as a resume
+   * option.
+   *
+   * Answering this without doing anything is the point: the rewind moves the
+   * session onto a different provider transcript and cannot be undone, so the
+   * gateway has to know which shape the run takes before it commits to one.
+   */
+  providerRewindsForEdit(sessionId: string): boolean {
+    const session = sessionsDb.getSessionById(sessionId);
+    if (!session) {
+      throw new AppError(`Session "${sessionId}" was not found.`, {
+        code: 'SESSION_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    return Boolean(providerRegistry.resolveProvider(session.provider as LLMProvider).sessions.rewindSession);
+  },
+
+  /**
+   * Rewinds a session on disk so `keepThroughId` is the last row it holds.
+   *
+   * Only call this once the run is admitted — see `providerRewindsForEdit`.
+   */
+  async rewindSessionForEdit(sessionId: string, keepThroughId: string | null): Promise<void> {
+    const session = sessionsDb.getSessionById(sessionId);
+    if (!session) {
+      throw new AppError(`Session "${sessionId}" was not found.`, {
+        code: 'SESSION_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    const sessions = providerRegistry.resolveProvider(session.provider as LLMProvider).sessions;
+    await sessions.rewindSession?.(sessionId, keepThroughId);
+  },
+
   async fetchHistory(
     sessionId: string,
     options: Pick<FetchHistoryOptions, 'limit' | 'offset'> = {},
@@ -293,13 +506,52 @@ export const sessionsService = {
     }
 
     const provider = session.provider as LLMProvider;
-    const result = await providerRegistry.resolveProvider(provider).sessions.fetchHistory(sessionId, {
-      limit: options.limit ?? null,
-      offset: options.offset ?? 0,
-      projectPath: session.project_path ?? '',
-      providerSessionId: session.provider_session_id,
+    const providerSessions = providerRegistry.resolveProvider(provider).sessions;
+    const providerSessionId = session.provider_session_id;
+    const projectPath = session.project_path ?? '';
+    const requestedLimit = options.limit ?? null;
+    const requestedOffset = options.offset ?? 0;
+
+    // Claude and Codex history readers parse `jsonl_path` itself, so a page
+    // can be sliced from the stat-validated full-transcript cache instead of
+    // re-parsing the whole file per request. Cursor and OpenCode read their
+    // messages from elsewhere (store.db / shared SQLite), so that file's stat
+    // says nothing about their history — they stay on the direct path.
+    const transcriptPath = provider === 'claude' || provider === 'codex'
+      ? session.jsonl_path
+      : null;
+    const fullHistory = await sessionHistoryCache.getFullHistory({
+      sessionId,
+      transcriptPath,
+      loadFull: () => providerSessions.fetchHistory(sessionId, {
+        limit: null,
+        offset: 0,
+        projectPath,
+        providerSessionId,
+      }),
     });
 
+    let result: FetchHistoryResult;
+    if (fullHistory) {
+      // Providers slice with this same helper, so a cached page is identical
+      // to what a direct `(limit, offset)` read would have returned.
+      const { page, hasMore } = sliceTailPage(fullHistory.messages, requestedLimit, Math.max(0, requestedOffset));
+      result = {
+        ...fullHistory,
+        messages: page,
+        hasMore,
+        offset: requestedOffset,
+        limit: requestedLimit,
+      };
+    } else {
+      result = await providerSessions.fetchHistory(sessionId, {
+        limit: requestedLimit,
+        offset: requestedOffset,
+        projectPath,
+        providerSessionId,
+      });
+    }
+
     return {
       ...result,
       messages: result.messages.map((message) => ({
@@ -309,6 +561,34 @@ export const sessionsService = {
     };
   },
 
+  /**
+   * Reads what one agent of a workflow run did, for the card that opened it.
+   *
+   * Not found covers both a provider that spawns no workflow agents and a run
+   * that left no transcript for this agent: either way there is nothing to
+   * show, and the card says so in one line.
+   */
+  async readWorkflowAgentActivity(sessionId: string, runId: string, agentId: string): Promise<WorkflowAgentActivity> {
+    const session = sessionsDb.getSessionById(sessionId);
+    if (!session) {
+      throw new AppError(`Session "${sessionId}" was not found.`, {
+        code: 'SESSION_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    const sessions = providerRegistry.resolveProvider(session.provider as LLMProvider).sessions;
+    const activity = await sessions.readWorkflowAgentActivity?.(sessionId, runId, agentId);
+    if (!activity) {
+      throw new AppError(`Workflow agent "${agentId}" was not found.`, {
+        code: 'WORKFLOW_AGENT_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    return activity;
+  },
+
   /**
    * Resolves one session (by app id, falling back to the provider-native id)
    * to its metadata plus the owning project.
@@ -418,10 +698,22 @@ export const sessionsService = {
     }
 
     let removedFromDisk = false;
-    if (options.deletedFromDisk && session.jsonl_path) {
-      removedFromDisk = await removeFileIfExists(session.jsonl_path);
+    if (options.deletedFromDisk) {
+      // Every file the conversation has lived in, not just the one the row
+      // points at now: editing a message on a provider that rewinds by
+      // branching moves the session onto a copy and leaves the earlier
+      // transcript behind. Deleting only the current one would leave the
+      // replaced turns on disk, and unreachable through the app.
+      const transcripts = [
+        ...(session.jsonl_path ? [session.jsonl_path] : []),
+        ...sessionsDb.getSupersededTranscriptPaths(sessionId),
+      ];
+      for (const transcript of transcripts) {
+        removedFromDisk = (await removeFileIfExists(transcript)) || removedFromDisk;
+      }
     }
 
+    sessionsDb.clearSupersededProviderSessions(sessionId);
     const deleted = sessionsDb.deleteSessionById(sessionId);
     if (!deleted) {
       throw new AppError(`Session "${sessionId}" was not found.`, {