@piecemaker-legal/piecemaker 1.0.0

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();
+    }
+  });
+});

package/server/modules/providers/tests/sessions-details.test.ts

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, projectsDb, sessionsDb } from '@/modules/database/index.js';
+import { sessionsService } from '@/modules/providers/services/sessions.service.js';
+import { AppError, normalizeProjectPath } from '@/shared/utils.js';
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'sessions-details-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  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 });
+  }
+}
+
+test('getSessionDetailsById resolves the owning project for a disk-indexed session', async () => {
+  await withIsolatedDatabase(() => {
+    const projectPath = '/home/user/example-project';
+    const sessionId = sessionsDb.createSession('provider-abc', 'claude', projectPath, 'My session');
+    const projectRow = projectsDb.getProjectPath(projectPath);
+    assert.ok(projectRow, 'project row should exist after createSession');
+
+    const details = sessionsService.getSessionDetailsById(sessionId);
+
+    assert.equal(details.sessionId, sessionId);
+    assert.equal(details.provider, 'claude');
+    assert.equal(details.summary, 'My session');
+    assert.equal(details.isArchived, false);
+    assert.ok(details.project, 'project should be resolved');
+    assert.equal(details.project?.projectId, projectRow?.project_id);
+    // Paths are normalized to platform separators when stored.
+    assert.equal(details.project?.fullPath, normalizeProjectPath(projectPath));
+  });
+});
+
+test('getSessionDetailsById falls back to the provider-native id and returns the canonical app id', async () => {
+  await withIsolatedDatabase(() => {
+    const projectPath = '/home/user/alias-project';
+    const appSessionId = sessionsDb.createAppSession('app-session-1', 'claude', projectPath);
+    sessionsDb.assignProviderSessionId(appSessionId, 'provider-native-1');
+
+    const details = sessionsService.getSessionDetailsById('provider-native-1');
+
+    assert.equal(details.sessionId, appSessionId);
+    assert.equal(details.project?.fullPath, normalizeProjectPath(projectPath));
+  });
+});
+
+test('getSessionDetailsById throws SESSION_NOT_FOUND for unknown ids', async () => {
+  await withIsolatedDatabase(() => {
+    assert.throws(
+      () => sessionsService.getSessionDetailsById('does-not-exist'),
+      (error: unknown) => error instanceof AppError && error.code === 'SESSION_NOT_FOUND',
+    );
+  });
+});

package/server/modules/providers/tests/sessions.service.test.ts

@@ -0,0 +1,193 @@
+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 { closeConnection, initializeDatabase, projectsDb, sessionsDb } from '@/modules/database/index.js';
+import { sessionsService } from '@/modules/providers/services/sessions.service.js';
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'sessions-service-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 });
+  }
+}
+
+test('provider session id returns the mapped native id', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-session-id', 'codex', '/tmp/session-id-copy-project');
+    sessionsDb.assignProviderSessionId('app-session-id', 'codex-native-session-id');
+
+    assert.equal(sessionsService.getProviderSessionId('app-session-id'), 'codex-native-session-id');
+  });
+});
+
+test('app session names use at most four whole words from the initial message', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    const result = sessionsService.createAppSession(
+      'codex',
+      '/tmp/session-name-project',
+      '  supercalifragilisticexpialidocious\nsecond   third fourth fifth  ',
+    );
+
+    assert.equal(result.sessionName, 'supercalifragilisticexpialidocious second third fourth');
+    assert.equal(
+      sessionsDb.getSessionById(result.sessionId)?.custom_name,
+      'supercalifragilisticexpialidocious second third fourth',
+    );
+  });
+});
+
+test('app sessions without message text receive a stable fallback name', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    const result = sessionsService.createAppSession('claude', '/tmp/attachment-only-project', '  \n ');
+
+    assert.equal(result.sessionName, 'Untitled Session');
+    assert.equal(sessionsDb.getSessionById(result.sessionId)?.custom_name, 'Untitled Session');
+  });
+});
+
+test('provider session id is unavailable until the provider assigns one', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('pending-app-session', 'claude', '/tmp/session-id-copy-project');
+
+    assert.throws(
+      () => sessionsService.getProviderSessionId('pending-app-session'),
+      (error: unknown) => {
+        const typedError = error as { code?: string; statusCode?: number };
+        return typedError.code === 'PROVIDER_SESSION_ID_NOT_AVAILABLE' && typedError.statusCode === 409;
+      },
+    );
+  });
+});
+
+test('provider session id reports a missing app session', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    assert.throws(
+      () => sessionsService.getProviderSessionId('missing-session'),
+      (error: unknown) => {
+        const typedError = error as { code?: string; statusCode?: number };
+        return typedError.code === 'SESSION_NOT_FOUND' && typedError.statusCode === 404;
+      },
+    );
+  });
+});
+
+test('recent sessions map project metadata and preserve database pagination', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createSession(
+      'older-session',
+      'claude',
+      '/tmp/recent-project',
+      'Older conversation',
+      '2026-08-01T08:00:00.000Z',
+      '2026-08-01T09:00:00.000Z',
+    );
+    sessionsDb.createSession(
+      'newer-session',
+      'codex',
+      '/tmp/recent-project',
+      'Newer conversation',
+      '2026-08-01T10:00:00.000Z',
+      '2026-08-01T11:00:00.000Z',
+    );
+    projectsDb.updateCustomProjectName('/tmp/recent-project', 'Recent Project');
+
+    const project = projectsDb.getProjectPath('/tmp/recent-project');
+    const page = sessionsService.listRecentSessions(1, 0);
+
+    assert.deepEqual(page, {
+      conversations: [{
+        sessionId: 'newer-session',
+        provider: 'codex',
+        projectId: project?.project_id ?? null,
+        projectDisplayName: 'Recent Project',
+        sessionTitle: 'Newer conversation',
+        lastActivity: '2026-08-01T11:00:00.000Z',
+      }],
+      total: 2,
+      hasMore: true,
+    });
+  });
+});
+
+/** One Claude transcript row of user or assistant text, linked by uuid chain. */
+function claudeTextRow(
+  sessionId: string,
+  role: 'user' | 'assistant',
+  text: string,
+  ordinal: number,
+): Record<string, unknown> {
+  return {
+    type: role,
+    uuid: `row-${ordinal}`,
+    parentUuid: ordinal === 0 ? null : `row-${ordinal - 1}`,
+    timestamp: new Date(Date.UTC(2026, 0, 1, 0, 0, ordinal)).toISOString(),
+    sessionId,
+    message: { role, content: [{ type: 'text', text }] },
+  };
+}
+
+test('history pages are sliced from the cached full transcript and see appended rows', { concurrency: false }, async () => {
+  const transcriptDirectory = await mkdtemp(path.join(os.tmpdir(), 'sessions-service-history-'));
+  const sessionId = 'claude-history-cache-session';
+  const transcriptPath = path.join(transcriptDirectory, `${sessionId}.jsonl`);
+
+  try {
+    await withIsolatedDatabase(async () => {
+      const rows = [
+        claudeTextRow(sessionId, 'user', 'one', 0),
+        claudeTextRow(sessionId, 'assistant', 'reply one', 1),
+        claudeTextRow(sessionId, 'user', 'two', 2),
+        claudeTextRow(sessionId, 'assistant', 'reply two', 3),
+      ];
+      await writeFile(transcriptPath, `${rows.map((row) => JSON.stringify(row)).join('\n')}\n`, 'utf8');
+      sessionsDb.createSession(
+        sessionId,
+        'claude',
+        '/tmp/history-cache-project',
+        'History cache conversation',
+        '2026-01-01T00:00:00.000Z',
+        '2026-01-01T00:00:10.000Z',
+        transcriptPath,
+      );
+
+      const page = await sessionsService.fetchHistory(sessionId, { limit: 2, offset: 0 });
+      assert.equal(page.total, 4);
+      assert.equal(page.hasMore, true);
+      assert.deepEqual(page.messages.map((message) => message.content), ['two', 'reply two']);
+
+      // A row appended after the page was cached must appear on the next read.
+      await appendFile(
+        transcriptPath,
+        `${JSON.stringify(claudeTextRow(sessionId, 'user', 'three', 4))}\n`,
+        'utf8',
+      );
+      const refreshed = await sessionsService.fetchHistory(sessionId, { limit: 2, offset: 0 });
+      assert.equal(refreshed.total, 5);
+      assert.deepEqual(refreshed.messages.map((message) => message.content), ['reply two', 'three']);
+
+      // An older page keeps the tail-offset contract while served from cache.
+      const older = await sessionsService.fetchHistory(sessionId, { limit: 2, offset: 2 });
+      assert.deepEqual(older.messages.map((message) => message.content), ['reply one', 'two']);
+      assert.equal(older.hasMore, true);
+    });
+  } finally {
+    await rm(transcriptDirectory, { recursive: true, force: true });
+  }
+});