@cloudcli-ai/cloudcli 1.37.1 → 1.37.3

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,16 @@ 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 { sessionHistoryCache } from '@/modules/providers/services/session-history-cache.service.js';
 import type {
   FetchHistoryOptions,
   FetchHistoryResult,
   LLMProvider,
   NormalizedMessage,
 } from '@/shared/types.js';
-import { AppError } from '@/shared/utils.js';
+import { AppError, sliceTailPage } from '@/shared/utils.js';
 
 type CreateAppSessionResult = {
   sessionId: string;
@@ -236,6 +237,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 +342,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 +434,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) => ({
@@ -418,10 +598,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.`, {

package/server/modules/providers/tests/claude-auth.test.ts

@@ -136,6 +136,64 @@ test('checkCredentials: no CLAUDE_CODE_OAUTH_TOKEN, expired credentials file rep
   });
 });
 
+test('checkCredentials: expired access token with a live refresh token is still authenticated', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeCredentialsFile(homeDir, {
+      claudeAiOauth: {
+        accessToken: 'stale-token',
+        refreshToken: 'live-refresh-token',
+        expiresAt: 1_000_000_000_000,
+        refreshTokenExpiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000,
+      },
+      email: 'someone@example.com',
+    });
+
+    await withEnv({}, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      assert.equal(status.authenticated, true);
+      assert.equal(status.method, 'credentials_file');
+      assert.equal(status.email, 'someone@example.com');
+    });
+  });
+});
+
+test('checkCredentials: expired access token with a refresh token that has no recorded expiry is authenticated', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeCredentialsFile(homeDir, {
+      claudeAiOauth: {
+        accessToken: 'stale-token',
+        refreshToken: 'live-refresh-token',
+        expiresAt: 1_000_000_000_000,
+      },
+    });
+
+    await withEnv({}, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      assert.equal(status.authenticated, true);
+      assert.equal(status.method, 'credentials_file');
+    });
+  });
+});
+
+test('checkCredentials: expired access token with an expired refresh token reports not authenticated', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeCredentialsFile(homeDir, {
+      claudeAiOauth: {
+        accessToken: 'stale-token',
+        refreshToken: 'stale-refresh-token',
+        expiresAt: 1_000_000_000_000,
+        refreshTokenExpiresAt: 1_000_000_000_000,
+      },
+    });
+
+    await withEnv({}, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      assert.equal(status.authenticated, false);
+      assert.match(status.error ?? '', /expired/i);
+    });
+  });
+});
+
 test('checkCredentials: ANTHROPIC_API_KEY takes precedence over CLAUDE_CODE_OAUTH_TOKEN', async () => {
   await withTempHome(async () => {
     await withEnv(

package/server/modules/providers/tests/claude-models.test.ts

@@ -0,0 +1,87 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { extractClaudeEventModel } from '@/modules/providers/list/claude/claude-models.provider.js';
+
+const SESSION_ID = 'session-1';
+
+test('ignores the <synthetic> placeholder Claude Code stamps on synthesized rows', () => {
+  assert.equal(
+    extractClaudeEventModel(
+      { sessionId: SESSION_ID, message: { model: '<synthetic>' } },
+      SESSION_ID,
+    ),
+    null,
+  );
+  assert.equal(
+    extractClaudeEventModel({ sessionId: SESSION_ID, model: '<synthetic>' }, SESSION_ID),
+    null,
+  );
+});
+
+test('still surfaces real model ids from message and event fields', () => {
+  assert.equal(
+    extractClaudeEventModel(
+      { sessionId: SESSION_ID, message: { model: 'claude-sonnet-5' } },
+      SESSION_ID,
+    ),
+    'claude-sonnet-5',
+  );
+  assert.equal(
+    extractClaudeEventModel({ sessionId: SESSION_ID, model: 'opus' }, SESSION_ID),
+    'opus',
+  );
+});
+
+test('skips a placeholder content part so a later real model tag still wins', () => {
+  assert.equal(
+    extractClaudeEventModel(
+      {
+        sessionId: SESSION_ID,
+        message: {
+          content: [
+            { text: '<model><synthetic></model>' },
+            { text: '<model>claude-sonnet-5</model>' },
+          ],
+        },
+      },
+      SESSION_ID,
+    ),
+    'claude-sonnet-5',
+  );
+});
+
+test('a placeholder stdout hit does not shadow a real <model> tag in the same text', () => {
+  const text = '<local-command-stdout>Set model to <synthetic></local-command-stdout>'
+    + '<model>claude-sonnet-5</model>';
+  assert.equal(
+    extractClaudeEventModel(
+      { sessionId: SESSION_ID, message: { content: text } },
+      SESSION_ID,
+    ),
+    'claude-sonnet-5',
+  );
+  assert.equal(
+    extractClaudeEventModel(
+      { sessionId: SESSION_ID, message: { content: [{ text }] } },
+      SESSION_ID,
+    ),
+    'claude-sonnet-5',
+  );
+});
+
+test('falls back to the message model when every content hit is a placeholder', () => {
+  assert.equal(
+    extractClaudeEventModel(
+      {
+        sessionId: SESSION_ID,
+        message: {
+          content: '<model><synthetic></model>',
+          model: 'claude-sonnet-5',
+        },
+      },
+      SESSION_ID,
+    ),
+    'claude-sonnet-5',
+  );
+});