@cloudcli-ai/cloudcli 1.36.2 → 1.37.0

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

@@ -32,6 +32,25 @@ type ArchivedSessionListItem = {
   isProjectArchived: boolean;
 };
 
+type SessionDetails = {
+  /** Canonical app-facing session id (may differ from the looked-up id when a provider-native id was given). */
+  sessionId: string;
+  provider: LLMProvider;
+  summary: string;
+  createdAt: string | null;
+  updatedAt: string | null;
+  lastActivity: string | null;
+  isArchived: boolean;
+  project: {
+    projectId: string;
+    path: string;
+    fullPath: string;
+    displayName: string;
+    isStarred: boolean;
+    isArchived: boolean;
+  } | null;
+};
+
 /**
  * Removes one file if it exists.
  */
@@ -100,6 +119,23 @@ export const sessionsService = {
     return chatRunRegistry.listRunningRuns();
   },
 
+  /**
+   * Resolves the provider-native session id a runtime needs for resume.
+   *
+   * Callers hand provider runtimes the stable app session id; the provider
+   * CLIs/SDKs only understand their own native id, which lives on the session
+   * row. Ids without a row are assumed to be provider-native already (direct
+   * API callers that reference sessions the watcher has not indexed yet).
+   */
+  resolveProviderSessionId(sessionId: string | null | undefined): string | null {
+    if (!sessionId) {
+      return null;
+    }
+
+    const session = sessionsDb.getSessionById(sessionId);
+    return session ? session.provider_session_id : sessionId;
+  },
+
   /**
    * Normalizes one provider-native event into frontend session message events.
    */
@@ -189,6 +225,49 @@ export const sessionsService = {
     };
   },
 
+  /**
+   * Resolves one session (by app id, falling back to the provider-native id)
+   * to its metadata plus the owning project.
+   *
+   * This backs deep links like `/session/:sessionId`: the frontend's paginated
+   * project payloads only carry each project's first session page, so a
+   * session opened directly by URL may not be present client-side at all —
+   * this lookup is the authoritative way to learn which project owns it.
+   */
+  getSessionDetailsById(sessionId: string): SessionDetails {
+    const session =
+      sessionsDb.getSessionById(sessionId) ?? sessionsDb.getSessionByProviderSessionId(sessionId);
+    if (!session) {
+      throw new AppError(`Session "${sessionId}" was not found.`, {
+        code: 'SESSION_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    const projectPath = session.project_path?.trim() ? session.project_path : null;
+    const project = projectPath ? projectsDb.getProjectPath(projectPath) : null;
+
+    return {
+      sessionId: session.session_id,
+      provider: session.provider as LLMProvider,
+      summary: session.custom_name?.trim() || '',
+      createdAt: session.created_at ?? null,
+      updatedAt: session.updated_at ?? null,
+      lastActivity: session.updated_at ?? session.created_at ?? null,
+      isArchived: Boolean(session.isArchived),
+      project: project && projectPath
+        ? {
+            projectId: project.project_id,
+            path: projectPath,
+            fullPath: projectPath,
+            displayName: resolveProjectDisplayName(projectPath, project.custom_project_name),
+            isStarred: Boolean(project.isStarred),
+            isArchived: Boolean(project.isArchived),
+          }
+        : null,
+    };
+  },
+
   /**
    * Returns archived sessions with enough project metadata for the sidebar to
    * group, filter, open, and restore them without a per-row follow-up query.

package/server/modules/providers/shared/base/abstract.provider.ts

@@ -3,6 +3,7 @@ import type {
   IProviderAuth,
   IProviderMcp,
   IProviderModels,
+  IProviderRuntime,
   IProviderSessionSynchronizer,
   IProviderSkills,
   IProviderSessions,
@@ -12,12 +13,12 @@ import type { LLMProvider } from '@/shared/types.js';
 /**
  * Shared provider base.
  *
- * Concrete providers must expose auth/MCP handlers and implement message
- * normalization/history loading because those behaviors depend on native
- * SDK/CLI formats.
+ * Concrete providers expose their live runtime plus model, auth, MCP, skill,
+ * session, and synchronization facets behind one registry-owned object.
  */
 export abstract class AbstractProvider implements IProvider {
   readonly id: LLMProvider;
+  abstract readonly runtime: IProviderRuntime;
   abstract readonly models: IProviderModels;
   abstract readonly mcp: IProviderMcp;
   abstract readonly auth: IProviderAuth;

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

@@ -0,0 +1,150 @@
+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 { ClaudeProviderAuth } from '@/modules/providers/list/claude/claude-auth.provider.js';
+
+// checkCredentials() is private, but unlike getStatus() it never shells out to the
+// `claude` CLI — it only reads env vars and ~/.claude files. Calling it directly
+// (TypeScript's `private` has no runtime effect) tests the priority order without
+// depending on `claude` being installed in the test environment.
+type CheckCredentialsResult = {
+  authenticated: boolean;
+  email: string | null;
+  method: string | null;
+  error?: string;
+};
+
+const checkCredentials = (auth: ClaudeProviderAuth): Promise<CheckCredentialsResult> =>
+  (auth as unknown as { checkCredentials: () => Promise<CheckCredentialsResult> }).checkCredentials();
+
+const ENV_KEYS = ['CLAUDE_CODE_OAUTH_TOKEN', 'ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'] as const;
+
+const withEnv = async (
+  overrides: Partial<Record<(typeof ENV_KEYS)[number], string>>,
+  fn: () => Promise<void>,
+) => {
+  const original: Partial<Record<(typeof ENV_KEYS)[number], string>> = {};
+  for (const key of ENV_KEYS) {
+    original[key] = process.env[key];
+    const value = overrides[key];
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+  try {
+    await fn();
+  } finally {
+    for (const key of ENV_KEYS) {
+      if (original[key] === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = original[key];
+      }
+    }
+  }
+};
+
+const withTempHome = async (fn: (homeDir: string) => Promise<void>) => {
+  const homeDir = await mkdtemp(path.join(os.tmpdir(), 'claude-auth-test-'));
+  const originalHome = process.env.HOME;
+  process.env.HOME = homeDir;
+  try {
+    await fn(homeDir);
+  } finally {
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    await rm(homeDir, { recursive: true, force: true });
+  }
+};
+
+const writeCredentialsFile = async (homeDir: string, body: unknown) => {
+  const claudeDir = path.join(homeDir, '.claude');
+  await mkdir(claudeDir, { recursive: true });
+  await writeFile(path.join(claudeDir, '.credentials.json'), JSON.stringify(body));
+};
+
+const writeSettingsFile = async (homeDir: string, env: Record<string, string>) => {
+  const claudeDir = path.join(homeDir, '.claude');
+  await mkdir(claudeDir, { recursive: true });
+  await writeFile(path.join(claudeDir, 'settings.json'), JSON.stringify({ env }));
+};
+
+test('checkCredentials: CLAUDE_CODE_OAUTH_TOKEN set is authenticated via environment, even with a stale credentials file', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeCredentialsFile(homeDir, {
+      claudeAiOauth: { accessToken: 'stale-token', expiresAt: 1_000_000_000_000 }, // long expired
+    });
+
+    await withEnv({ CLAUDE_CODE_OAUTH_TOKEN: 'test-oauth-token' }, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      assert.equal(status.authenticated, true);
+      assert.equal(status.method, 'environment');
+    });
+  });
+});
+
+test('checkCredentials: CLAUDE_CODE_OAUTH_TOKEN configured via settings.json env block is authenticated via environment', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeSettingsFile(homeDir, { CLAUDE_CODE_OAUTH_TOKEN: 'test-oauth-token-from-settings' });
+    await writeCredentialsFile(homeDir, {
+      claudeAiOauth: { accessToken: 'stale-token', expiresAt: 1_000_000_000_000 }, // long expired
+    });
+
+    await withEnv({}, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      assert.equal(status.authenticated, true);
+      assert.equal(status.method, 'environment');
+    });
+  });
+});
+
+test('checkCredentials: no CLAUDE_CODE_OAUTH_TOKEN, valid credentials file falls back to credentials_file', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeCredentialsFile(homeDir, {
+      claudeAiOauth: { accessToken: 'valid-token', expiresAt: Date.now() + 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: no CLAUDE_CODE_OAUTH_TOKEN, expired credentials file reports not authenticated', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeCredentialsFile(homeDir, {
+      claudeAiOauth: { accessToken: 'stale-token', expiresAt: 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(
+      { ANTHROPIC_API_KEY: 'test-api-key', CLAUDE_CODE_OAUTH_TOKEN: 'test-oauth-token' },
+      async () => {
+        const status = await checkCredentials(new ClaudeProviderAuth());
+        assert.equal(status.authenticated, true);
+        assert.equal(status.method, 'api_key');
+      },
+    );
+  });
+});

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

@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { ClaudeSessionsProvider } from '@/modules/providers/list/claude/claude-sessions.provider.js';
+
+const SESSION_ID = 'session-1';
+
+const SKILL_BODY = [
+  'Base directory for this skill: /tmp/claude/bundled-skills/2.1.220/abc123/claude-api',
+  '',
+  '# Building LLM-Powered Applications with Claude',
+  '',
+  'This skill helps you build LLM-powered applications with Claude.',
+].join('\n');
+
+test('claude: injected skill bodies are hidden even without the isMeta flag', () => {
+  const provider = new ClaudeSessionsProvider();
+
+  // The live SDK stream omits `isMeta`, so the payload has to be recognised by
+  // its content or it renders as a giant user bubble mid-run.
+  const live = provider.normalizeMessage(
+    {
+      uuid: 'u1',
+      timestamp: '2026-07-28T10:00:00.000Z',
+      message: { role: 'user', content: [{ type: 'text', text: SKILL_BODY }] },
+    },
+    SESSION_ID,
+  );
+  assert.deepEqual(live, []);
+
+  const persisted = provider.normalizeMessage(
+    {
+      uuid: 'u2',
+      timestamp: '2026-07-28T10:00:00.000Z',
+      isMeta: true,
+      message: { role: 'user', content: [{ type: 'text', text: SKILL_BODY }] },
+    },
+    SESSION_ID,
+  );
+  assert.deepEqual(persisted, []);
+});
+
+test('claude: the Skill tool result itself still reaches the UI', () => {
+  const provider = new ClaudeSessionsProvider();
+
+  const messages = provider.normalizeMessage(
+    {
+      uuid: 'u3',
+      timestamp: '2026-07-28T10:00:00.000Z',
+      message: {
+        role: 'user',
+        content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: 'Launching skill: claude-api' }],
+      },
+    },
+    SESSION_ID,
+  );
+
+  assert.equal(messages.length, 1);
+  assert.equal(messages[0].kind, 'tool_result');
+  assert.equal(messages[0].toolId, 'toolu_1');
+});

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

@@ -6,6 +6,7 @@ import test from 'node:test';
 
 import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
 import { CodexSessionSynchronizer } from '@/modules/providers/list/codex/codex-session-synchronizer.provider.js';
+import { CodexSessionsProvider } from '@/modules/providers/list/codex/codex-sessions.provider.js';
 
 const patchHomeDir = (nextHomeDir: string) => {
   const original = os.homedir;
@@ -88,6 +89,47 @@ test('Codex synchronizer titles app-created sessions from the first user message
   }
 });
 
+test('Codex synchronizer skips sub-agent rollout files', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-session-sync-subagent-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    // Codex >=0.144 spawn_agent threads write their own rollout files into the
+    // same sessions tree, marked via thread_source/source in session_meta.
+    const sessionsDir = path.join(tempRoot, '.codex', 'sessions', '2026', '07', '07');
+    await mkdir(sessionsDir, { recursive: true });
+    await writeFile(
+      path.join(sessionsDir, 'rollout-codex-subagent-1.jsonl'),
+      `${JSON.stringify({
+        type: 'session_meta',
+        payload: {
+          id: 'codex-subagent-1',
+          cwd: workspacePath,
+          thread_source: 'subagent',
+          parent_thread_id: 'codex-parent-1',
+          source: { subagent: { thread_spawn: { parent_thread_id: 'codex-parent-1', depth: 1 } } },
+        },
+      })}\n`,
+      'utf8'
+    );
+    await writeCodexTranscript(tempRoot, 'codex-parent-1', workspacePath);
+
+    await withIsolatedDatabase(async () => {
+      const synchronizer = new CodexSessionSynchronizer();
+      const processed = await synchronizer.synchronize();
+
+      assert.equal(processed, 1);
+      assert.ok(sessionsDb.getSessionById('codex-parent-1'));
+      assert.equal(sessionsDb.getSessionById('codex-subagent-1'), null);
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
 test('Codex synchronizer leaves indexed sessions untitled when no name is available', { concurrency: false }, async () => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-session-sync-indexed-'));
   const workspacePath = path.join(tempRoot, 'workspace');
@@ -109,3 +151,42 @@ test('Codex synchronizer leaves indexed sessions untitled when no name is availa
     await rm(tempRoot, { recursive: true, force: true });
   }
 });
+
+test('Codex history renders Promise.all shell wrappers as Bash activity', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-exec-history-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    const providerSessionId = 'codex-exec-1';
+    const transcriptPath = await writeCodexTranscript(tempRoot, providerSessionId, workspacePath);
+    const execInput = 'const cmds = ["echo one", "echo two"]; await Promise.all(cmds.map(command => tools.shell_command({ command })));';
+    const planInput = 'await tools.update_plan({ plan: [] });';
+    await writeFile(transcriptPath, [
+      JSON.stringify({ type: 'session_meta', payload: { id: providerSessionId, cwd: workspacePath } }),
+      JSON.stringify({ type: 'response_item', payload: { type: 'custom_tool_call', name: 'exec', call_id: 'exec-1', input: execInput } }),
+      JSON.stringify({ type: 'response_item', payload: { type: 'custom_tool_call_output', call_id: 'exec-1', output: 'done' } }),
+      JSON.stringify({ type: 'response_item', payload: { type: 'custom_tool_call', name: 'exec', call_id: 'plan-1', input: planInput } }),
+      JSON.stringify({ type: 'response_item', payload: { type: 'custom_tool_call_output', call_id: 'plan-1', output: 'done' } }),
+    ].join('\n') + '\n', 'utf8');
+
+    await withIsolatedDatabase(async () => {
+      sessionsDb.createAppSession('app-exec-1', 'codex', workspacePath);
+      sessionsDb.assignProviderSessionId('app-exec-1', providerSessionId);
+      await new CodexSessionSynchronizer().synchronize();
+
+      const history = await new CodexSessionsProvider().fetchHistory('app-exec-1');
+      const toolUses = history.messages.filter((message) => message.kind === 'tool_use');
+      const toolResults = history.messages.filter((message) => message.kind === 'tool_result');
+
+      assert.equal(toolUses.length, 1);
+      assert.equal(toolUses[0].toolName, 'Bash');
+      assert.equal(toolUses[0].toolInput, JSON.stringify({ command: 'echo one\necho two' }));
+      assert.equal(toolResults.some((message) => message.toolCallId === 'plan-1'), false);
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});

package/server/modules/providers/tests/{provider-image-history.test.ts → provider-attachment-history.test.ts}

@@ -4,7 +4,7 @@ import test from 'node:test';
 import { ClaudeSessionsProvider } from '@/modules/providers/list/claude/claude-sessions.provider.js';
 import { CodexSessionsProvider, extractCodexUserImages } from '@/modules/providers/list/codex/codex-sessions.provider.js';
 import { CursorSessionsProvider } from '@/modules/providers/list/cursor/cursor-sessions.provider.js';
-import { appendImagesInputTag } from '@/shared/image-attachments.js';
+import { appendFilesInputTag, appendImagesInputTag } from '@/shared/image-attachments.js';
 
 const SESSION_ID = 'session-1';
 
@@ -71,6 +71,29 @@ test('claude history: plain text user turns carry no images field', () => {
   assert.equal(messages[0].images, undefined);
 });
 
+test('claude history: file reference blocks restore non-image attachments', () => {
+  const provider = new ClaudeSessionsProvider();
+  const entry = {
+    uuid: 'u4',
+    timestamp: '2026-07-03T10:00:00.000Z',
+    message: {
+      role: 'user',
+      content: [{
+        type: 'text',
+        text: appendFilesInputTag('Summarize this', [
+          { path: 'C:/Users/x/.cloudcli/assets/brief.pdf', name: 'brief.pdf' },
+        ]),
+      }],
+    },
+  };
+
+  const messages = provider.normalizeMessage(entry, SESSION_ID);
+  assert.equal(messages[0].content, 'Summarize this');
+  assert.deepEqual(messages[0].files, [
+    { path: 'C:/Users/x/.cloudcli/assets/brief.pdf', name: 'brief.pdf' },
+  ]);
+});
+
 // ---------------------------------------------------------------- Codex
 
 test('codex history: user_message payload images become path attachments', () => {
@@ -123,6 +146,27 @@ test('codex history: normalized user entries keep their images', () => {
   assert.deepEqual(messages[0].images, [{ path: '.cloudcli/assets/a.png' }]);
 });
 
+test('codex history: normalized user entries restore file reference blocks', () => {
+  const provider = new CodexSessionsProvider();
+  const messages = provider.normalizeMessage(
+    {
+      timestamp: '2026-07-03T10:00:00.000Z',
+      message: {
+        role: 'user',
+        content: appendFilesInputTag('Review this', [
+          { path: 'C:/Users/x/.cloudcli/assets/spec.docx', name: 'spec.docx' },
+        ]),
+      },
+    },
+    SESSION_ID,
+  );
+
+  assert.equal(messages[0].content, 'Review this');
+  assert.deepEqual(messages[0].files, [
+    { path: 'C:/Users/x/.cloudcli/assets/spec.docx', name: 'spec.docx' },
+  ]);
+});
+
 // ---------------------------------------------------------------- Cursor
 
 test('cursor history: <images_input> inside user_query is stripped and attached', () => {
@@ -178,3 +222,26 @@ test('cursor history: user text without a tag keeps existing behavior', () => {
   assert.equal(messages[0].content, 'plain question');
   assert.equal(messages[0].images, undefined);
 });
+
+test('cursor history: file reference blocks are stripped and attached', () => {
+  const provider = new CursorSessionsProvider();
+  const taggedPrompt = appendFilesInputTag('Check the data', [
+    { path: 'C:/Users/x/.cloudcli/assets/data.csv', name: 'data.csv' },
+  ]);
+  const messages = provider.normalizeCursorBlobs([
+    {
+      id: 'blob-file',
+      sequence: 1,
+      rowid: 1,
+      content: {
+        role: 'user',
+        content: `<user_query>${taggedPrompt}</user_query>`,
+      },
+    },
+  ], SESSION_ID);
+
+  assert.equal(messages[0].content, 'Check the data');
+  assert.deepEqual(messages[0].files, [
+    { path: 'C:/Users/x/.cloudcli/assets/data.csv', name: 'data.csv' },
+  ]);
+});