@cloudcli-ai/cloudcli 1.37.0 → 1.37.1

package/server/modules/providers/services/session-conversations-search.service.ts

@@ -787,11 +787,18 @@ async function parseClaudeSessionMatches(
       ? matchedSessionsForFile
       : [session];
 
-    const targetSessionIds = new Set(targetSessions.map((candidate) => candidate.session_id));
+    // Transcript lines are tagged with the provider session id (e.g. Claude's own
+    // conversation UUID), which is not necessarily the app-facing `session_id`.
+    // Match and attribute by the provider id, but map results back to the
+    // internal `session_id` the rest of the app uses to identify sessions.
+    const providerToInternalId = new Map<string, string>();
     const customNameBySessionId = new Map<string, string | null>();
     for (const candidate of targetSessions) {
-      customNameBySessionId.set(candidate.session_id, candidate.custom_name ?? null);
+      const providerId = candidate.provider_session_id || candidate.session_id;
+      providerToInternalId.set(providerId, candidate.session_id);
+      customNameBySessionId.set(providerId, candidate.custom_name ?? null);
     }
+    const targetSessionIds = new Set(providerToInternalId.keys());
 
     type ClaudeSessionSearchState = {
       matches: SessionConversationMatch[];
@@ -912,8 +919,9 @@ async function parseClaudeSessionMatches(
         continue;
       }
 
-      fileResults.set(sessionId, {
-        sessionId,
+      const internalSessionId = providerToInternalId.get(sessionId) ?? sessionId;
+      fileResults.set(internalSessionId, {
+        sessionId: internalSessionId,
         provider: 'claude',
         sessionSummary: toSummaryText(
           customNameBySessionId.get(sessionId) ?? null,

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

@@ -17,6 +17,7 @@ type CreateAppSessionResult = {
   sessionId: string;
   provider: LLMProvider;
   projectPath: string;
+  sessionName: string;
 };
 
 type ArchivedSessionListItem = {
@@ -32,6 +33,17 @@ type ArchivedSessionListItem = {
   isProjectArchived: boolean;
 };
 
+type RecentSessionListItem = Pick<
+  ArchivedSessionListItem,
+  'sessionId' | 'provider' | 'projectId' | 'projectDisplayName' | 'sessionTitle' | 'lastActivity'
+>;
+
+type RecentSessionsPage = {
+  conversations: RecentSessionListItem[];
+  total: number;
+  hasMore: boolean;
+};
+
 type SessionDetails = {
   /** Canonical app-facing session id (may differ from the looked-up id when a provider-native id was given). */
   sessionId: string;
@@ -51,6 +63,13 @@ type SessionDetails = {
   } | null;
 };
 
+const MAX_CLOUDCLI_SESSION_NAME_WORDS = 4;
+
+function buildCloudCliSessionName(initialMessage: string): string {
+  const words = initialMessage.trim().split(/\s+/).filter(Boolean);
+  return words.slice(0, MAX_CLOUDCLI_SESSION_NAME_WORDS).join(' ') || 'Untitled Session';
+}
+
 /**
  * Removes one file if it exists.
  */
@@ -119,6 +138,40 @@ export const sessionsService = {
     return chatRunRegistry.listRunningRuns();
   },
 
+  /**
+   * Returns the active conversation feed in true global activity order.
+   */
+  listRecentSessions(limit: number, offset: number): RecentSessionsPage {
+    const page = sessionsDb.getRecentSessionsPage(limit, offset);
+    const projectCache = new Map<string, ReturnType<typeof projectsDb.getProjectPath>>();
+    const conversations = page.sessions.map((session) => {
+      const projectPath = session.project_path?.trim() ? session.project_path : null;
+      let project = null;
+
+      if (projectPath) {
+        if (!projectCache.has(projectPath)) {
+          projectCache.set(projectPath, projectsDb.getProjectPath(projectPath));
+        }
+        project = projectCache.get(projectPath) ?? null;
+      }
+
+      return {
+        sessionId: session.session_id,
+        provider: session.provider as LLMProvider,
+        projectId: project?.project_id ?? null,
+        projectDisplayName: resolveProjectDisplayName(projectPath, project?.custom_project_name),
+        sessionTitle: session.custom_name?.trim() || session.session_id,
+        lastActivity: session.updated_at ?? session.created_at ?? null,
+      };
+    });
+
+    return {
+      conversations,
+      total: page.total,
+      hasMore: offset + conversations.length < page.total,
+    };
+  },
+
   /**
    * Resolves the provider-native session id a runtime needs for resume.
    *
@@ -154,9 +207,15 @@ export const sessionsService = {
    * (via `POST /api/providers/sessions`) when the user starts a brand-new
    * chat, navigates to the returned id immediately, and the id never changes
    * for the lifetime of the conversation. The provider-native id is mapped to
-   * this row later, when the provider runtime announces it mid-run.
+   * this row later, when the provider runtime announces it mid-run. Its title
+   * comes directly from the first visible CloudCLI message and is limited to
+   * four whole words before any provider-owned storage exists.
    */
-  createAppSession(provider: LLMProvider, projectPath: string): CreateAppSessionResult {
+  createAppSession(
+    provider: LLMProvider,
+    projectPath: string,
+    initialMessage: string,
+  ): CreateAppSessionResult {
     const normalizedProjectPath = projectPath.trim();
     if (!normalizedProjectPath) {
       throw new AppError('projectPath is required.', {
@@ -166,15 +225,40 @@ export const sessionsService = {
     }
 
     const sessionId = randomUUID();
-    sessionsDb.createAppSession(sessionId, provider, normalizedProjectPath);
+    const sessionName = buildCloudCliSessionName(initialMessage);
+    sessionsDb.createAppSession(sessionId, provider, normalizedProjectPath, sessionName);
 
     return {
       sessionId,
       provider,
       projectPath: normalizedProjectPath,
+      sessionName,
     };
   },
 
+  /**
+   * Resolves the provider-native id only for an explicit user copy action.
+   * Normal session payloads continue to expose only the stable app id.
+   */
+  getProviderSessionId(sessionId: string): string {
+    const session = sessionsDb.getSessionById(sessionId);
+    if (!session) {
+      throw new AppError(`Session "${sessionId}" was not found.`, {
+        code: 'SESSION_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    if (!session.provider_session_id) {
+      throw new AppError('This session ID is not available yet.', {
+        code: 'PROVIDER_SESSION_ID_NOT_AVAILABLE',
+        statusCode: 409,
+      });
+    }
+
+    return session.provider_session_id;
+  },
+
   /**
    * Fetches persisted history by app session id.
    *

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

@@ -64,24 +64,24 @@ const writeCodexTranscript = async (
   return filePath;
 };
 
-test('Codex synchronizer titles app-created sessions from the first user message', { concurrency: false }, async () => {
+test('Codex synchronizer preserves the title assigned when CloudCLI creates a session', { concurrency: false }, async () => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-session-sync-app-'));
   const workspacePath = path.join(tempRoot, 'workspace');
   await mkdir(workspacePath, { recursive: true });
   const restoreHomeDir = patchHomeDir(tempRoot);
 
   try {
-    await writeCodexTranscript(tempRoot, 'codex-app-1', workspacePath, 'Fix the login redirect bug');
+    await writeCodexTranscript(tempRoot, 'codex-app-1', workspacePath, 'Provider transcript title must not win');
     await withIsolatedDatabase(async () => {
       // The app allocates its own id and later maps the provider id onto it,
       // exactly as a message sent from cloudcli does.
-      sessionsDb.createAppSession('app-1', 'codex', workspacePath);
+      sessionsDb.createAppSession('app-1', 'codex', workspacePath, 'Fix the login redirect');
       sessionsDb.assignProviderSessionId('app-1', 'codex-app-1');
 
       const synchronizer = new CodexSessionSynchronizer();
       await synchronizer.synchronize();
 
-      assert.equal(sessionsDb.getSessionById('app-1')?.custom_name, 'Fix the login redirect bug');
+      assert.equal(sessionsDb.getSessionById('app-1')?.custom_name, 'Fix the login redirect');
     });
   } finally {
     restoreHomeDir();
@@ -152,7 +152,7 @@ test('Codex synchronizer leaves indexed sessions untitled when no name is availa
   }
 });
 
-test('Codex history renders Promise.all shell wrappers as Bash activity', { concurrency: false }, async () => {
+test('Codex history preserves wrapped exec tool calls and results', { 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 });
@@ -161,15 +161,46 @@ test('Codex history renders Promise.all shell wrappers as Bash activity', { conc
   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, [
+    const wrappedCalls = [
+      {
+        callId: 'shell-command-1',
+        input: 'const cmds = ["echo one", "echo two"]; await Promise.all(cmds.map(command => tools.shell_command({ command })));',
+        expectedToolName: 'Bash',
+        expectedToolInput: JSON.stringify({ command: 'echo one\necho two' }),
+      },
+      {
+        callId: 'json-shell-command-1',
+        input: 'const r = await tools.shell_command({"command":"Get-Content -Raw README.md","workdir":"C:\\\\workspace","timeout_ms":10000}); text(r)',
+        expectedToolName: 'Bash',
+        expectedToolInput: JSON.stringify({ command: 'Get-Content -Raw README.md' }),
+      },
+      {
+        callId: 'exec-command-1',
+        input: 'await tools.exec_command({"command":"echo current"});',
+        expectedToolName: 'Bash',
+        expectedToolInput: JSON.stringify({ command: 'echo current' }),
+      },
+      { callId: 'apply-patch-1', input: 'await tools.apply_patch("*** Begin Patch\\n*** End Patch");' },
+      { callId: 'web-run-1', input: 'await tools.web__run({ search_query: [{ q: "Codex" }] });' },
+      { callId: 'update-plan-1', input: 'await tools.update_plan({ plan: [] });' },
+      { callId: 'unknown-1', input: 'await tools.unknown_wrapper({ value: true });' },
+    ];
+    const transcriptLines = [
       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');
+    ];
+    for (const call of wrappedCalls) {
+      transcriptLines.push(
+        JSON.stringify({
+          type: 'response_item',
+          payload: { type: 'custom_tool_call', name: 'exec', call_id: call.callId, input: call.input },
+        }),
+        JSON.stringify({
+          type: 'response_item',
+          payload: { type: 'custom_tool_call_output', call_id: call.callId, output: `result:${call.callId}` },
+        }),
+      );
+    }
+    await writeFile(transcriptPath, `${transcriptLines.join('\n')}\n`, 'utf8');
 
     await withIsolatedDatabase(async () => {
       sessionsDb.createAppSession('app-exec-1', 'codex', workspacePath);
@@ -179,11 +210,19 @@ test('Codex history renders Promise.all shell wrappers as Bash activity', { conc
       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);
+      const toolUsesById = new Map(toolUses.map((message) => [message.toolId, message]));
+      const toolResultsById = new Map(toolResults.map((message) => [message.toolId, message]));
+
+      assert.equal(toolUses.length, wrappedCalls.length);
+      assert.equal(toolResults.length, wrappedCalls.length);
+      for (const call of wrappedCalls) {
+        const toolUse = toolUsesById.get(call.callId);
+        assert.ok(toolUse);
+        assert.equal(toolUse.toolName, call.expectedToolName || 'exec');
+        assert.equal(toolUse.toolInput, call.expectedToolInput || call.input);
+        assert.equal(toolUse.toolResult?.content, `result:${call.callId}`);
+        assert.equal(toolResultsById.get(call.callId)?.content, `result:${call.callId}`);
+      }
     });
   } finally {
     restoreHomeDir();

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

@@ -2,141 +2,40 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 
 import {
-  buildOpenCodeDefinitionFromVerboseModels,
-  buildOpenCodeDefinitionFromIds,
-  parseOpenCodeModelsStdout,
-  parseOpenCodeVerboseModelsStdout,
+  OpenCodeProviderModels,
+  OPENCODE_PREDEFINED_MODELS,
 } from '@/modules/providers/list/opencode/opencode-models.provider.js';
 
-test('OpenCode models provider parses plain CLI output and removes duplicates', () => {
-  const ids = parseOpenCodeModelsStdout(`
-opencode/big-pickle
-not a model
-anthropic/claude-opus-4-7-fast
-anthropic/claude-opus-4-7-fast
-openai/gpt-5.5-pro
-`);
-
-  assert.deepEqual(ids, [
-    'opencode/big-pickle',
-    'anthropic/claude-opus-4-7-fast',
-    'openai/gpt-5.5-pro',
-  ]);
-});
-
-test('OpenCode models provider formats frontend labels from provider-prefixed ids', () => {
-  const definition = buildOpenCodeDefinitionFromIds([
-    'opencode/deepseek-v4-flash-free',
-    'opencode/nemotron-3-super-free',
-    'anthropic/claude-3-5-sonnet-20241022',
-    'anthropic/claude-opus-4-7-fast',
-    'google/model-alpha',
-    'openai/gpt-5.4-mini-fast',
-    'openai/gpt-5.5-pro',
-    'newprovider/alpha-v12-special-20261231',
-  ]);
-
-  assert.deepEqual(definition.OPTIONS, [
-    {
-      value: 'opencode/deepseek-v4-flash-free',
-      label: 'Deepseek V4 Flash Free',
-      description: 'opencode - opencode/deepseek-v4-flash-free',
-    },
-    {
-      value: 'opencode/nemotron-3-super-free',
-      label: 'Nemotron 3 Super Free',
-      description: 'opencode - opencode/nemotron-3-super-free',
-    },
-    {
-      value: 'anthropic/claude-3-5-sonnet-20241022',
-      label: 'Claude 3.5 Sonnet (2024-10-22)',
-      description: 'anthropic - anthropic/claude-3-5-sonnet-20241022',
-    },
-    {
-      value: 'anthropic/claude-opus-4-7-fast',
-      label: 'Claude Opus 4.7 Fast',
-      description: 'anthropic - anthropic/claude-opus-4-7-fast',
-    },
-    {
-      value: 'openai/gpt-5.4-mini-fast',
-      label: 'GPT-5.4 Mini Fast',
-      description: 'openai - openai/gpt-5.4-mini-fast',
-    },
-    {
-      value: 'openai/gpt-5.5-pro',
-      label: 'GPT-5.5 Pro',
-      description: 'openai - openai/gpt-5.5-pro',
-    },
-    {
-      value: 'newprovider/alpha-v12-special-20261231',
-      label: 'Alpha V12 Special (2026-12-31)',
-      description: 'newprovider - newprovider/alpha-v12-special-20261231',
-    },
-  ]);
-});
-
-test('OpenCode models provider maps verbose model variants to effort options', () => {
-  const models = parseOpenCodeVerboseModelsStdout(`
-opencode/deepseek-v4-flash-free
-{
-  "id": "deepseek-v4-flash-free",
-  "providerID": "opencode",
-  "name": "DeepSeek V4 Flash Free",
-  "variants": {
-    "low": {
-      "reasoningEffort": "low"
-    },
-    "high": {
-      "reasoningEffort": "high"
-    }
-  }
-}
-anthropic/claude-sonnet-5
-{
-  "id": "claude-sonnet-5",
-  "providerID": "anthropic",
-  "name": "Claude Sonnet 5",
-  "variants": {
-    "low": {
-      "effort": "low"
-    },
-    "max": {
-      "effort": "max"
-    }
-  }
-}
-google/model-alpha
-{
-  "id": "model-alpha",
-  "providerID": "google",
-  "name": "Model Alpha"
-}
-`);
-
-  const definition = buildOpenCodeDefinitionFromVerboseModels(models);
-
-  assert.deepEqual(definition.OPTIONS, [
-    {
-      value: 'opencode/deepseek-v4-flash-free',
-      label: 'DeepSeek V4 Flash Free',
-      description: 'opencode - opencode/deepseek-v4-flash-free',
-      effort: {
-        values: [
-          { value: 'low' },
-          { value: 'high' },
-        ],
-      },
-    },
-    {
-      value: 'anthropic/claude-sonnet-5',
-      label: 'Claude Sonnet 5',
-      description: 'anthropic - anthropic/claude-sonnet-5',
-      effort: {
-        values: [
-          { value: 'low' },
-          { value: 'max' },
-        ],
-      },
-    },
-  ]);
+test('OpenCode exposes only the curated predefined catalog', async () => {
+  const adapter = new OpenCodeProviderModels();
+
+  assert.deepEqual(await adapter.getSupportedModels(), OPENCODE_PREDEFINED_MODELS);
+  assert.equal(
+    (await adapter.getCurrentActiveModel()).model,
+    OPENCODE_PREDEFINED_MODELS.DEFAULT,
+  );
+  // OpenCode routes by `<providerID>/<modelID>`, so every option has to carry a
+  // provider prefix that `opencode models --verbose` reports.
+  const providerIds = new Set(
+    OPENCODE_PREDEFINED_MODELS.OPTIONS.map((option) => option.value.split('/')[0]),
+  );
+  assert.deepEqual([...providerIds].sort(), ['anthropic', 'opencode', 'openai'].sort());
+  assert.equal(
+    OPENCODE_PREDEFINED_MODELS.OPTIONS.every((option) => /^[a-z0-9-]+\/.+/.test(option.value)),
+    true,
+  );
+  assert.equal(
+    new Set(OPENCODE_PREDEFINED_MODELS.OPTIONS.map((option) => option.value)).size,
+    OPENCODE_PREDEFINED_MODELS.OPTIONS.length,
+  );
+  assert.equal(OPENCODE_PREDEFINED_MODELS.DEFAULT, 'opencode/gpt-5.6-terra');
+  assert.ok(
+    OPENCODE_PREDEFINED_MODELS.OPTIONS.some((option) => option.value === 'opencode/claude-opus-5'),
+  );
+  assert.ok(
+    OPENCODE_PREDEFINED_MODELS.OPTIONS.some((option) => option.value === 'anthropic/claude-opus-5'),
+  );
+  assert.ok(
+    OPENCODE_PREDEFINED_MODELS.OPTIONS.some((option) => option.value === 'openai/gpt-5.6'),
+  );
 });

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

@@ -470,22 +470,22 @@ const seedOpenCodeSession = async (
   }
 };
 
-test('OpenCode synchronizer titles app-created sessions from the first user message', { concurrency: false }, async () => {
+test('OpenCode synchronizer preserves the title assigned when CloudCLI creates a session', { concurrency: false }, async () => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'opencode-session-sync-app-'));
   const workspacePath = path.join(tempRoot, 'workspace');
   await mkdir(workspacePath, { recursive: true });
   const restoreHomeDir = patchHomeDir(tempRoot);
 
   try {
-    // Stored title differs from the first message so we can prove the first
-    // message wins for sessions started from cloudcli.
+    // Both provider-owned values differ from the CloudCLI title so either one
+    // leaking through would change the assertion below.
     await seedOpenCodeSession(tempRoot, workspacePath, {
       sessionId: 'oc-app-1',
       title: 'OpenCode generated title',
-      firstUserText: 'Fix the checkout crash',
+      firstUserText: 'OpenCode first user prompt',
     });
     await withIsolatedDatabase(async () => {
-      sessionsDb.createAppSession('app-1', 'opencode', workspacePath);
+      sessionsDb.createAppSession('app-1', 'opencode', workspacePath, 'Fix the checkout crash');
       sessionsDb.assignProviderSessionId('app-1', 'oc-app-1');
 
       await new OpenCodeSessionSynchronizer().synchronize();