@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

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

@@ -0,0 +1,165 @@
+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 });
+  }
+});
+
+test('invalidating a session re-parses its unchanged transcript on the next read', async () => {
+  await withTranscriptFile(async (transcriptPath) => {
+    const cache = createSessionHistoryCache();
+    let loads = 0;
+    const loadFull = async () => {
+      loads += 1;
+      return historyResult(`load-${loads}`);
+    };
+
+    // Claude's history reader decides a background agent's status from whether
+    // the session's CLI process is up — nothing the file's stat can reflect —
+    // so the runtime drops the entry when that process starts or ends.
+    const first = await cache.getFullHistory({ sessionId: 's1', transcriptPath, loadFull });
+    cache.invalidate('s1');
+    const second = await cache.getFullHistory({ sessionId: 's1', transcriptPath, loadFull });
+
+    assert.equal(loads, 2);
+    assert.notEqual(second, first);
+    assert.equal(second?.messages[0]?.content, 'load-2');
+  });
+});

package/server/modules/providers/tests/session-orphan-prune.test.ts

@@ -0,0 +1,107 @@
+import assert from 'node:assert/strict';
+import { mkdir, 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';
+
+// Each provider synchronizer resolves `os.homedir()` when the registry module is
+// first imported, so HOME has to point at an empty fixture home *before* that
+// import runs. Otherwise the sync pass walks the developer's real ~/.claude.
+const fixtureHome = await mkdtemp(path.join(os.tmpdir(), 'session-prune-home-'));
+const previousHome = process.env.HOME;
+const previousUserProfile = process.env.USERPROFILE;
+process.env.HOME = fixtureHome;
+process.env.USERPROFILE = fixtureHome;
+
+const { sessionSynchronizerService } = await import(
+  '@/modules/providers/services/session-synchronizer.service.js'
+);
+
+process.on('exit', () => {
+  if (previousHome === undefined) {
+    delete process.env.HOME;
+  } else {
+    process.env.HOME = previousHome;
+  }
+  if (previousUserProfile === undefined) {
+    delete process.env.USERPROFILE;
+  } else {
+    process.env.USERPROFILE = previousUserProfile;
+  }
+});
+
+async function withIsolatedDatabase(runTest: (workspace: string) => Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'session-prune-db-'));
+
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(tempDirectory, 'auth.db');
+  await initializeDatabase();
+
+  try {
+    await runTest(tempDirectory);
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+const PROJECT_PATH = '/tmp/session-prune-project';
+
+test('synchronizeSessions drops indexed sessions whose transcript file was deleted', async () => {
+  await withIsolatedDatabase(async (workspace) => {
+    const transcriptDirectory = path.join(workspace, 'transcripts');
+    await mkdir(transcriptDirectory, { recursive: true });
+
+    const livePath = path.join(transcriptDirectory, 'live.jsonl');
+    await writeFile(livePath, '{}\n');
+    const deletedPath = path.join(transcriptDirectory, 'deleted.jsonl');
+
+    sessionsDb.createSession('live-session', 'claude', PROJECT_PATH, 'Live', undefined, undefined, livePath);
+    sessionsDb.createSession('orphan-session', 'claude', PROJECT_PATH, 'Untitled Claude Session', undefined, undefined, deletedPath);
+
+    const result = await sessionSynchronizerService.synchronizeSessions();
+
+    assert.deepEqual(result.failures, []);
+    assert.equal(result.prunedOrphans, 1);
+    assert.equal(sessionsDb.getSessionById('orphan-session'), null);
+    assert.ok(sessionsDb.getSessionById('live-session'), 'a session whose transcript still exists must survive');
+  });
+});
+
+test('synchronizeSessions keeps sessions whose whole transcript directory is missing', async () => {
+  await withIsolatedDatabase(async (workspace) => {
+    // Stands in for an unmounted or not-yet-created home: every transcript
+    // "looks" deleted, so pruning here would wipe the entire index.
+    const unmountedPath = path.join(workspace, 'not-mounted', 'session.jsonl');
+
+    sessionsDb.createSession('unmounted-session', 'claude', PROJECT_PATH, 'Unmounted', undefined, undefined, unmountedPath);
+
+    const result = await sessionSynchronizerService.synchronizeSessions();
+
+    assert.equal(result.prunedOrphans, 0);
+    assert.ok(sessionsDb.getSessionById('unmounted-session'));
+  });
+});
+
+test('synchronizeSessions keeps sessions that have no transcript path yet', async () => {
+  await withIsolatedDatabase(async () => {
+    // App-created rows (jsonl_path NULL until the first provider write) and
+    // OpenCode rows (one shared sqlite file, so jsonl_path stays NULL).
+    sessionsDb.createAppSession('pending-app-session', 'claude', PROJECT_PATH, 'Pending');
+    sessionsDb.createSession('opencode-session', 'opencode', PROJECT_PATH, 'OpenCode', undefined, undefined, null);
+
+    const result = await sessionSynchronizerService.synchronizeSessions();
+
+    assert.equal(result.prunedOrphans, 0);
+    assert.ok(sessionsDb.getSessionById('pending-app-session'));
+    assert.ok(sessionsDb.getSessionById('opencode-session'));
+  });
+});

package/server/modules/providers/tests/session-synchronizer-coalescing.test.ts

@@ -0,0 +1,136 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase } from '@/modules/database/index.js';
+import type { IProvider } from '@/shared/interfaces.js';
+
+// Each provider synchronizer resolves `os.homedir()` when the registry module is
+// first imported, so HOME has to point at an empty fixture home *before* that
+// import runs. The registry is stubbed per test, but the import still happens.
+const fixtureHome = await mkdtemp(path.join(os.tmpdir(), 'session-sync-home-'));
+const previousHome = process.env.HOME;
+const previousUserProfile = process.env.USERPROFILE;
+process.env.HOME = fixtureHome;
+process.env.USERPROFILE = fixtureHome;
+
+const { providerRegistry } = await import('@/modules/providers/provider.registry.js');
+const { sessionSynchronizerService } = await import(
+  '@/modules/providers/services/session-synchronizer.service.js'
+);
+
+process.on('exit', () => {
+  if (previousHome === undefined) {
+    delete process.env.HOME;
+  } else {
+    process.env.HOME = previousHome;
+  }
+  if (previousUserProfile === undefined) {
+    delete process.env.USERPROFILE;
+  } else {
+    process.env.USERPROFILE = previousUserProfile;
+  }
+});
+
+async function withIsolatedDatabase(runTest: () => Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'session-sync-db-'));
+
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(tempDirectory, 'auth.db');
+  await initializeDatabase();
+
+  try {
+    await runTest();
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Installs a single fake provider whose scan only settles when the returned
+ * `release` is called, so a second caller can be observed arriving mid-scan.
+ */
+function stubSlowProvider() {
+  const originalListProviders = providerRegistry.listProviders;
+  let synchronizeCalls = 0;
+  let releaseScan: () => void = () => {};
+  const scanStarted = new Promise<void>((resolveStarted) => {
+    const fakeProvider = {
+      id: 'claude',
+      sessionSynchronizer: {
+        async synchronize() {
+          synchronizeCalls += 1;
+          resolveStarted();
+          await new Promise<void>((resolveScan) => {
+            releaseScan = resolveScan;
+          });
+          return 7;
+        },
+      },
+    } as unknown as IProvider;
+
+    providerRegistry.listProviders = () => [fakeProvider];
+  });
+
+  return {
+    scanStarted,
+    release: () => releaseScan(),
+    getSynchronizeCalls: () => synchronizeCalls,
+    restore: () => {
+      providerRegistry.listProviders = originalListProviders;
+    },
+  };
+}
+
+test('concurrent synchronizeSessions callers share one provider scan', async () => {
+  await withIsolatedDatabase(async () => {
+    const providerStub = stubSlowProvider();
+
+    try {
+      const first = sessionSynchronizerService.synchronizeSessions();
+      await providerStub.scanStarted;
+      // Opening the UI fires /api/projects and /api/projects/archived at once;
+      // the second must join the running scan instead of starting its own.
+      const second = sessionSynchronizerService.synchronizeSessions();
+
+      providerStub.release();
+      const [firstResult, secondResult] = await Promise.all([first, second]);
+
+      assert.equal(providerStub.getSynchronizeCalls(), 1);
+      assert.equal(firstResult.processedByProvider.claude, 7);
+      assert.deepEqual(secondResult, firstResult);
+    } finally {
+      providerStub.restore();
+    }
+  });
+});
+
+test('a synchronizeSessions call after the shared scan settles starts a new scan', async () => {
+  await withIsolatedDatabase(async () => {
+    const providerStub = stubSlowProvider();
+
+    try {
+      const first = sessionSynchronizerService.synchronizeSessions();
+      await providerStub.scanStarted;
+      providerStub.release();
+      await first;
+
+      const second = sessionSynchronizerService.synchronizeSessions();
+      providerStub.release();
+      await second;
+
+      assert.equal(providerStub.getSynchronizeCalls(), 2);
+    } finally {
+      providerStub.restore();
+    }
+  });
+});