@cloudcli-ai/cloudcli 1.37.1 → 1.37.3

package/server/modules/providers/tests/provider-token-usage.service.test.ts

@@ -6,7 +6,10 @@ import test from 'node:test';
 
 import Database from 'better-sqlite3';
 
-import { createProviderTokenUsageService } from '@/modules/providers/services/provider-token-usage.service.js';
+import {
+  createProviderTokenUsageService,
+  summarizeClaudeTokenUsage,
+} from '@/modules/providers/services/provider-token-usage.service.js';
 import { AppError } from '@/shared/utils.js';
 
 function createSessionRow(overrides: Record<string, unknown> = {}) {
@@ -19,6 +22,7 @@ function createSessionRow(overrides: Record<string, unknown> = {}) {
     custom_name: null,
     model: null,
     effort: null,
+    forked_from_session_id: null,
     isArchived: 0,
     created_at: '2026-01-01T00:00:00.000Z',
     updated_at: '2026-01-01T00:00:00.000Z',
@@ -184,3 +188,186 @@ test('token usage reports SESSION_NOT_FOUND for an unknown app session id', asyn
     ),
   );
 });
+
+test('the Claude summarizer reads the newest assistant turn, not the whole conversation', () => {
+  const entries = [
+    { type: 'assistant', message: { usage: { input_tokens: 5, cache_read_input_tokens: 1000, output_tokens: 50 } } },
+    { type: 'user', message: { role: 'user', content: 'next' } },
+    // The newest turn's prompt is the whole context, so its cache_read already
+    // includes everything before it. Summing turns would double-count.
+    { type: 'assistant', message: { usage: { input_tokens: 3, cache_read_input_tokens: 4000, cache_creation_input_tokens: 100, output_tokens: 80 } } },
+  ];
+
+  assert.deepEqual(summarizeClaudeTokenUsage(entries, '200000'), {
+    used: 4183,
+    total: 200_000,
+    inputTokens: 4103,
+    outputTokens: 80,
+    cacheReadTokens: 4000,
+    cacheCreationTokens: 100,
+    cacheTokens: 4100,
+    breakdown: { input: 4103, output: 80 },
+  });
+});
+
+test('the Claude summarizer skips synthetic rows that carry an all-zero usage block', () => {
+  // Interrupts, API errors and "No response requested." are written as
+  // assistant rows with a fully zeroed usage block. Reading one as the newest
+  // turn dropped the composer counter to 0 until the next turn pushed it back.
+  const entries = [
+    { type: 'assistant', message: { usage: { input_tokens: 3, cache_read_input_tokens: 4000, output_tokens: 80 } } },
+    {
+      type: 'assistant',
+      message: {
+        model: '<synthetic>',
+        usage: {
+          input_tokens: 0,
+          output_tokens: 0,
+          cache_creation_input_tokens: 0,
+          cache_read_input_tokens: 0,
+        },
+      },
+    },
+  ];
+
+  assert.equal(summarizeClaudeTokenUsage(entries, '200000').used, 4083);
+});
+
+test('the Claude summarizer skips a subagent sidechain turn', () => {
+  // A sidechain turn reports the subagent's own context window. Reading it
+  // made the counter drop to the subagent's number mid-run.
+  const entries = [
+    { type: 'assistant', message: { usage: { input_tokens: 3, cache_read_input_tokens: 4000, output_tokens: 80 } } },
+    {
+      type: 'assistant',
+      isSidechain: true,
+      message: { usage: { input_tokens: 10, cache_read_input_tokens: 900, output_tokens: 5 } },
+    },
+  ];
+
+  assert.equal(summarizeClaudeTokenUsage(entries, '200000').used, 4083);
+});
+
+test('the Claude summarizer reports zero for a transcript with no assistant turn yet', () => {
+  const usage = summarizeClaudeTokenUsage([{ type: 'user', message: { role: 'user', content: 'hi' } }], '200000');
+
+  assert.equal(usage.used, 0);
+  assert.equal(usage.total, 200_000);
+});
+
+/** Padding rows large enough to push earlier rows out of the 4MB tail window. */
+function paddingLines(totalBytes: number): string {
+  const line = JSON.stringify({ type: 'attachment', filler: 'x'.repeat(4096) });
+  return Array.from({ length: Math.ceil(totalBytes / line.length) }, () => line).join('\n');
+}
+
+test('Claude token usage reads only the tail of a large transcript', async () => {
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-claude-tail-'));
+  const sessionFilePath = path.join(tempDirectory, 'provider-session.jsonl');
+
+  try {
+    await writeFile(sessionFilePath, [
+      paddingLines(5 * 1024 * 1024),
+      JSON.stringify({ type: 'assistant', message: { usage: { input_tokens: 7, output_tokens: 2 } } }),
+    ].join('\n'));
+
+    const service = createProviderTokenUsageService({
+      getSessionById: () => createSessionRow({ jsonl_path: sessionFilePath }),
+      getClaudeContextWindow: () => '180000',
+      // Reading the whole file here would defeat the tail read; fail loudly.
+      readTextFile: () => { throw new Error('full read must not happen when the tail has usage'); },
+    });
+
+    const usage = await service.getSessionTokenUsage('app-session');
+    assert.equal(usage.inputTokens, 7);
+    assert.equal(usage.outputTokens, 2);
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('Claude token usage falls back to the whole file when the tail has no usage row', async () => {
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-claude-fallback-'));
+  const sessionFilePath = path.join(tempDirectory, 'provider-session.jsonl');
+
+  try {
+    await writeFile(sessionFilePath, [
+      JSON.stringify({ type: 'assistant', message: { usage: { input_tokens: 11, output_tokens: 3 } } }),
+      paddingLines(5 * 1024 * 1024),
+    ].join('\n'));
+
+    const service = createProviderTokenUsageService({
+      getSessionById: () => createSessionRow({ jsonl_path: sessionFilePath }),
+      getClaudeContextWindow: () => '180000',
+    });
+
+    const usage = await service.getSessionTokenUsage('app-session');
+    assert.equal(usage.inputTokens, 11);
+    assert.equal(usage.outputTokens, 3);
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('Codex token usage reads only the tail of a large rollout', async () => {
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-codex-tail-'));
+  const sessionFilePath = path.join(tempDirectory, 'rollout-provider-session.jsonl');
+
+  try {
+    await writeFile(sessionFilePath, [
+      paddingLines(5 * 1024 * 1024),
+      JSON.stringify({
+        type: 'event_msg',
+        payload: {
+          type: 'token_count',
+          info: {
+            total_token_usage: { input_tokens: 21, output_tokens: 8, total_tokens: 29 },
+            model_context_window: 150_000,
+          },
+        },
+      }),
+    ].join('\n'));
+
+    const service = createProviderTokenUsageService({
+      getSessionById: () => createSessionRow({ provider: 'codex', jsonl_path: sessionFilePath }),
+      readTextFile: () => { throw new Error('full read must not happen when the tail has usage'); },
+    });
+
+    assert.deepEqual(await service.getSessionTokenUsage('app-session'), {
+      used: 29,
+      total: 150_000,
+      inputTokens: 21,
+      outputTokens: 8,
+      breakdown: { input: 21, output: 8 },
+    });
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('Codex token usage falls back to the whole file when the tail has no token_count row', async () => {
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-codex-fallback-'));
+  const sessionFilePath = path.join(tempDirectory, 'rollout-provider-session.jsonl');
+
+  try {
+    await writeFile(sessionFilePath, [
+      JSON.stringify({
+        type: 'event_msg',
+        payload: {
+          type: 'token_count',
+          info: { total_token_usage: { input_tokens: 5, output_tokens: 1, total_tokens: 6 } },
+        },
+      }),
+      paddingLines(5 * 1024 * 1024),
+    ].join('\n'));
+
+    const service = createProviderTokenUsageService({
+      getSessionById: () => createSessionRow({ provider: 'codex', jsonl_path: sessionFilePath }),
+    });
+
+    const usage = await service.getSessionTokenUsage('app-session');
+    assert.equal(usage.used, 6);
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});

package/server/modules/providers/tests/provider.routes.test.ts

@@ -78,6 +78,67 @@ test('session creation route names a CloudCLI session from the initial message',
   });
 });
 
+test('conversation search streams title matches before transcript results', async () => {
+  await withProviderServer(async (baseUrl, workspacePath) => {
+    sessionsDb.createAppSession(
+      'title-only-session',
+      'codex',
+      workspacePath,
+      'Release planning notes',
+    );
+    const transcriptPath = path.join(path.dirname(workspacePath), 'codex-search.jsonl');
+    await writeFile(transcriptPath, `${JSON.stringify({
+      type: 'event_msg',
+      timestamp: '2026-08-12T09:00:00.000Z',
+      payload: {
+        type: 'user_message',
+        kind: 'plain',
+        message: 'Release planning also appears in this conversation.',
+      },
+    })}\n`);
+    sessionsDb.createSession(
+      'transcript-session',
+      'codex',
+      workspacePath,
+      'Unrelated session',
+      undefined,
+      undefined,
+      transcriptPath,
+    );
+
+    const response = await fetch(
+      `${baseUrl}/api/providers/search/sessions?q=release%20planning&limit=50`,
+    );
+    const eventStream = await response.text();
+    const titleEventIndex = eventStream.indexOf('event: title-results');
+    const conversationEventIndex = eventStream.indexOf('event: result');
+    const doneEventIndex = eventStream.indexOf('event: done');
+
+    assert.equal(response.status, 200);
+    assert.ok(titleEventIndex >= 0);
+    assert.ok(conversationEventIndex > titleEventIndex);
+    assert.ok(doneEventIndex > titleEventIndex);
+
+    const titleDataLine = eventStream
+      .slice(titleEventIndex, conversationEventIndex)
+      .split('\n')
+      .find((line) => line.startsWith('data: '));
+    assert.ok(titleDataLine);
+
+    const titlePayload = JSON.parse(titleDataLine.slice('data: '.length)) as {
+      titleResults: Array<{
+        sessionId: string;
+        sessionTitle: string;
+        provider: string;
+      }>;
+    };
+    assert.equal(titlePayload.titleResults.length, 1);
+    assert.equal(titlePayload.titleResults[0]?.sessionId, 'title-only-session');
+    assert.equal(titlePayload.titleResults[0]?.sessionTitle, 'Release planning notes');
+    assert.equal(titlePayload.titleResults[0]?.provider, 'codex');
+  });
+});
+
 test('reasoning effort is persisted and returned with the active session model', async () => {
   await withProviderServer(async (baseUrl, workspacePath) => {
     sessionsDb.createAppSession('effort-session', 'codex', workspacePath);

package/server/modules/providers/tests/session-fork.test.ts

@@ -0,0 +1,173 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import { sessionsService } from '@/modules/providers/services/sessions.service.js';
+import type { IProviderFork } from '@/shared/interfaces.js';
+
+const SOURCE_ID = 'fork-source';
+
+type ForkCall = {
+  providerSessionId: string;
+  jsonlPath: string;
+  upToAnchorId?: string;
+  title?: string;
+};
+
+async function withForkableClaude(
+  runTest: (context: { calls: ForkCall[]; directory: string }) => Promise<void>,
+  options: { disableFork?: boolean } = {},
+): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const directory = await mkdtemp(path.join(os.tmpdir(), 'session-fork-'));
+  const sourcePath = path.join(directory, 'native-source.jsonl');
+  const forkedPath = path.join(directory, 'native-fork.jsonl');
+  await writeFile(sourcePath, '{}\n', 'utf8');
+  await writeFile(forkedPath, '{}\n', 'utf8');
+
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(directory, 'auth.db');
+  await initializeDatabase();
+
+  const calls: ForkCall[] = [];
+  const claude = providerRegistry.resolveProvider('claude') as { fork?: IProviderFork };
+  const realFork = claude.fork;
+  const replacement = options.disableFork
+    ? undefined
+    : {
+      forkSession: async (input: ForkCall) => {
+        calls.push(input);
+        return { providerSessionId: 'native-fork', jsonlPath: forkedPath };
+      },
+    } as IProviderFork;
+
+  Object.defineProperty(claude, 'fork', { value: replacement, configurable: true, writable: true });
+
+  try {
+    await runTest({ calls, directory });
+  } finally {
+    Object.defineProperty(claude, 'fork', { value: realFork, configurable: true, writable: true });
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+function seedSource(directory: string): void {
+  const now = new Date().toISOString();
+  sessionsDb.createSession(
+    SOURCE_ID,
+    'claude',
+    directory,
+    'Original session',
+    now,
+    now,
+    path.join(directory, 'native-source.jsonl'),
+  );
+  sessionsDb.assignProviderSessionId(SOURCE_ID, 'native-source');
+}
+
+test('a fork becomes an independent session that points back at its source', async () => {
+  await withForkableClaude(async ({ calls, directory }) => {
+    seedSource(directory);
+
+    const result = await sessionsService.forkSessionById(SOURCE_ID, { upToAnchorId: 'uuid-3' });
+
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].providerSessionId, 'native-source');
+    assert.equal(calls[0].upToAnchorId, 'uuid-3');
+
+    const forked = sessionsDb.getSessionById(result.sessionId);
+    assert.ok(forked);
+    // Written before the watcher can see the new file, so it is never indexed
+    // a second time under its provider-native id.
+    assert.equal(forked?.provider_session_id, 'native-fork');
+    assert.equal(forked?.jsonl_path, path.join(directory, 'native-fork.jsonl'));
+    assert.equal(forked?.forked_from_session_id, SOURCE_ID);
+    assert.equal(forked?.custom_name, 'Original session (fork)');
+
+    // The source is untouched: this is "try two approaches", not a move.
+    const source = sessionsDb.getSessionById(SOURCE_ID);
+    assert.equal(source?.provider_session_id, 'native-source');
+    assert.equal(source?.custom_name, 'Original session');
+  });
+});
+
+test('a fork inherits the model and effort of the conversation it branched from', async () => {
+  await withForkableClaude(async ({ directory }) => {
+    seedSource(directory);
+    sessionsDb.setSessionModel(SOURCE_ID, 'claude-opus-5');
+    sessionsDb.setSessionEffort(SOURCE_ID, 'xhigh');
+
+    const result = await sessionsService.forkSessionById(SOURCE_ID);
+
+    const forked = sessionsDb.getSessionById(result.sessionId);
+    assert.equal(forked?.model, 'claude-opus-5');
+    assert.equal(forked?.effort, 'xhigh');
+  });
+});
+
+test('forking replaces a row the watcher already made for the new transcript', async () => {
+  await withForkableClaude(async ({ directory }) => {
+    seedSource(directory);
+    // The watcher wins the race and indexes the fork under its native id.
+    const now = new Date().toISOString();
+    sessionsDb.createSession(
+      'native-fork',
+      'claude',
+      directory,
+      'Indexed by the watcher',
+      now,
+      now,
+      path.join(directory, 'native-fork.jsonl'),
+    );
+
+    const result = await sessionsService.forkSessionById(SOURCE_ID);
+
+    assert.equal(sessionsDb.getSessionById('native-fork'), null);
+    assert.equal(sessionsDb.getSessionById(result.sessionId)?.provider_session_id, 'native-fork');
+  });
+});
+
+test('a session with no transcript yet cannot be forked', async () => {
+  await withForkableClaude(async ({ directory }) => {
+    // An app-created session that has never run: no provider id, no transcript.
+    sessionsDb.createAppSession('never-ran', 'claude', directory, 'Never ran');
+
+    await assert.rejects(
+      () => sessionsService.forkSessionById('never-ran'),
+      (error: Error & { code?: string }) => error.code === 'FORK_SOURCE_NOT_READY',
+    );
+  });
+});
+
+test('a provider without the capability is refused rather than silently ignored', async () => {
+  await withForkableClaude(
+    async ({ directory }) => {
+      seedSource(directory);
+
+      await assert.rejects(
+        () => sessionsService.forkSessionById(SOURCE_ID),
+        (error: Error & { code?: string }) => error.code === 'FORK_NOT_SUPPORTED',
+      );
+    },
+    { disableFork: true },
+  );
+});
+
+test('forking a session that does not exist is a 404', async () => {
+  await withForkableClaude(async () => {
+    await assert.rejects(
+      () => sessionsService.forkSessionById('no-such-session'),
+      (error: Error & { code?: string }) => error.code === 'SESSION_NOT_FOUND',
+    );
+  });
+});

package/server/modules/providers/tests/session-history-cache.service.test.ts

@@ -0,0 +1,143 @@
+import assert from 'node:assert/strict';
+import { appendFile, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { createSessionHistoryCache } from '@/modules/providers/services/session-history-cache.service.js';
+import type { FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
+
+function historyResult(marker: string): FetchHistoryResult {
+  const message = {
+    id: marker,
+    sessionId: 'session',
+    timestamp: '2026-01-01T00:00:00.000Z',
+    provider: 'claude',
+    kind: 'text',
+    role: 'user',
+    content: marker,
+  } as NormalizedMessage;
+
+  return { messages: [message], total: 1, hasMore: false, offset: 0, limit: null };
+}
+
+async function withTranscriptFile(
+  runTest: (transcriptPath: string) => Promise<void>,
+): Promise<void> {
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'session-history-cache-'));
+  const transcriptPath = path.join(tempDirectory, 'session.jsonl');
+  await writeFile(transcriptPath, '{"type":"user"}\n', 'utf8');
+  try {
+    await runTest(transcriptPath);
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+test('an unchanged transcript file is loaded once and then served from cache', async () => {
+  await withTranscriptFile(async (transcriptPath) => {
+    const cache = createSessionHistoryCache();
+    let loads = 0;
+    const loadFull = async () => {
+      loads += 1;
+      return historyResult(`load-${loads}`);
+    };
+
+    const first = await cache.getFullHistory({ sessionId: 's1', transcriptPath, loadFull });
+    const second = await cache.getFullHistory({ sessionId: 's1', transcriptPath, loadFull });
+
+    assert.equal(loads, 1);
+    assert.equal(second, first);
+  });
+});
+
+test('growing the transcript file invalidates the cached load', async () => {
+  await withTranscriptFile(async (transcriptPath) => {
+    const cache = createSessionHistoryCache();
+    let loads = 0;
+    const loadFull = async () => {
+      loads += 1;
+      return historyResult(`load-${loads}`);
+    };
+
+    await cache.getFullHistory({ sessionId: 's1', transcriptPath, loadFull });
+    await appendFile(transcriptPath, '{"type":"assistant"}\n', 'utf8');
+    const afterAppend = await cache.getFullHistory({ sessionId: 's1', transcriptPath, loadFull });
+
+    assert.equal(loads, 2);
+    assert.equal(afterAppend?.messages[0]?.id, 'load-2');
+  });
+});
+
+test('a missing transcript path or file bypasses the cache', async () => {
+  const cache = createSessionHistoryCache();
+  let loads = 0;
+  const loadFull = async () => {
+    loads += 1;
+    return historyResult('unused');
+  };
+
+  assert.equal(await cache.getFullHistory({ sessionId: 's1', transcriptPath: null, loadFull }), null);
+  assert.equal(
+    await cache.getFullHistory({
+      sessionId: 's1',
+      transcriptPath: path.join(os.tmpdir(), 'session-history-cache-does-not-exist.jsonl'),
+      loadFull,
+    }),
+    null,
+  );
+  assert.equal(loads, 0);
+});
+
+test('concurrent misses share a single load', async () => {
+  await withTranscriptFile(async (transcriptPath) => {
+    const cache = createSessionHistoryCache();
+    let loads = 0;
+    let release: (() => void) | undefined;
+    const gate = new Promise<void>((resolve) => { release = resolve; });
+    const loadFull = async () => {
+      loads += 1;
+      await gate;
+      return historyResult(`load-${loads}`);
+    };
+
+    const firstRequest = cache.getFullHistory({ sessionId: 's1', transcriptPath, loadFull });
+    const secondRequest = cache.getFullHistory({ sessionId: 's1', transcriptPath, loadFull });
+    release!();
+    const [first, second] = await Promise.all([firstRequest, secondRequest]);
+
+    assert.equal(loads, 1);
+    assert.equal(second, first);
+  });
+});
+
+test('the oldest entries are evicted over budget, but the newest survives alone', async () => {
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'session-history-cache-evict-'));
+  try {
+    const firstPath = path.join(tempDirectory, 'first.jsonl');
+    const secondPath = path.join(tempDirectory, 'second.jsonl');
+    // Each file is 100 bytes, so a 150-byte budget holds exactly one entry —
+    // and the newest entry stays cached even though it exceeds nothing alone.
+    await writeFile(firstPath, 'x'.repeat(100), 'utf8');
+    await writeFile(secondPath, 'y'.repeat(100), 'utf8');
+
+    const cache = createSessionHistoryCache(150);
+    const loadsBySession = new Map<string, number>();
+    const loaderFor = (sessionId: string) => async () => {
+      loadsBySession.set(sessionId, (loadsBySession.get(sessionId) ?? 0) + 1);
+      return historyResult(sessionId);
+    };
+
+    await cache.getFullHistory({ sessionId: 's1', transcriptPath: firstPath, loadFull: loaderFor('s1') });
+    await cache.getFullHistory({ sessionId: 's2', transcriptPath: secondPath, loadFull: loaderFor('s2') });
+
+    // s2 is still cached; s1 was evicted to fit the budget.
+    await cache.getFullHistory({ sessionId: 's2', transcriptPath: secondPath, loadFull: loaderFor('s2') });
+    await cache.getFullHistory({ sessionId: 's1', transcriptPath: firstPath, loadFull: loaderFor('s1') });
+
+    assert.equal(loadsBySession.get('s2'), 1);
+    assert.equal(loadsBySession.get('s1'), 2);
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});