@cloudcli-ai/cloudcli 1.31.5 → 1.33.0

package/server/modules/providers/services/session-synchronizer.service.ts

@@ -22,6 +22,7 @@ export const sessionSynchronizerService = {
       codex: 0,
       cursor: 0,
       gemini: 0,
+      opencode: 0,
     };
     const failures: string[] = [];
 

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

@@ -18,19 +18,25 @@ const PROVIDER_WATCH_PATHS: Array<{ provider: LLMProvider; rootPath: string }> =
   },
   {
     provider: 'cursor',
-    rootPath: path.join(os.homedir(), '.cursor', 'chats'),
+    rootPath: path.join(os.homedir(), '.cursor', 'projects'),
   },
   {
     provider: 'codex',
     rootPath: path.join(os.homedir(), '.codex', 'sessions'),
   },
+  // {
+  //   provider: 'gemini',
+  //   rootPath: path.join(os.homedir(), '.gemini', 'sessions'),
+  // },
+  // Keep `sessions/` watcher disabled: Gemini also mirrors artifacts there,
+  // which causes duplicate synchronization events.
   {
     provider: 'gemini',
-    rootPath: path.join(os.homedir(), '.gemini', 'sessions'),
+    rootPath: path.join(os.homedir(), '.gemini', 'tmp'),
   },
   {
-    provider: 'gemini',
-    rootPath: path.join(os.homedir(), '.gemini', 'tmp'),
+    provider: 'opencode',
+    rootPath: path.join(os.homedir(), '.local', 'share', 'opencode'),
   },
 ];
 
@@ -65,6 +71,10 @@ let watcherRescheduleAfterRefresh = false;
  * Filters watcher events to provider-specific session artifact file types.
  */
 function isWatcherTargetFile(provider: LLMProvider, filePath: string): boolean {
+  if (provider === 'opencode') {
+    return path.basename(filePath) === 'opencode.db';
+  }
+
   if (provider === 'gemini') {
     return filePath.endsWith('.json') || filePath.endsWith('.jsonl');
   }

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

@@ -1,6 +1,7 @@
 import fsp from 'node:fs/promises';
+import path from 'node:path';
 
-import { sessionsDb } from '@/modules/database/index.js';
+import { projectsDb, sessionsDb } from '@/modules/database/index.js';
 import { providerRegistry } from '@/modules/providers/provider.registry.js';
 import type {
   FetchHistoryOptions,
@@ -10,6 +11,19 @@ import type {
 } from '@/shared/types.js';
 import { AppError } from '@/shared/utils.js';
 
+type ArchivedSessionListItem = {
+  sessionId: string;
+  provider: LLMProvider;
+  projectId: string | null;
+  projectPath: string | null;
+  projectDisplayName: string;
+  sessionTitle: string;
+  createdAt: string | null;
+  updatedAt: string | null;
+  lastActivity: string | null;
+  isProjectArchived: boolean;
+};
+
 /**
  * Removes one file if it exists.
  */
@@ -26,6 +40,28 @@ async function removeFileIfExists(filePath: string): Promise<boolean> {
   }
 }
 
+/**
+ * Archive rows need a stable project label even when the owning project is not
+ * part of the active sidebar payload. This lightweight resolver keeps the
+ * archive API self-contained while still matching the project's stored display
+ * name when one exists.
+ */
+function resolveProjectDisplayName(
+  projectPath: string | null,
+  customProjectName: string | null | undefined,
+): string {
+  const trimmedCustomName = typeof customProjectName === 'string' ? customProjectName.trim() : '';
+  if (trimmedCustomName.length > 0) {
+    return trimmedCustomName;
+  }
+
+  if (!projectPath) {
+    return 'Unknown Project';
+  }
+
+  return path.basename(projectPath) || projectPath;
+}
+
 /**
  * Application service for provider-backed session message operations.
  *
@@ -79,15 +115,53 @@ export const sessionsService = {
   },
 
   /**
-   * Deletes one persisted session row by id.
+   * Returns archived sessions with enough project metadata for the sidebar to
+   * group, filter, open, and restore them without a per-row follow-up query.
+   */
+  listArchivedSessions(): ArchivedSessionListItem[] {
+    const archivedSessions = sessionsDb.getArchivedSessions();
+    const projectCache = new Map<string, ReturnType<typeof projectsDb.getProjectPath>>();
+
+    return archivedSessions.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,
+        projectPath,
+        projectDisplayName: resolveProjectDisplayName(projectPath, project?.custom_project_name),
+        sessionTitle: session.custom_name?.trim() || session.session_id,
+        createdAt: session.created_at ?? null,
+        updatedAt: session.updated_at ?? null,
+        lastActivity: session.updated_at ?? session.created_at ?? null,
+        isProjectArchived: Boolean(project?.isArchived),
+      };
+    });
+  },
+
+  /**
+   * Archives or permanently deletes one persisted session row by id.
    *
-   * When `deletedFromDisk` is true and a session `jsonl_path` exists, the path
-   * is deleted from disk before the DB row is removed.
+   * Soft-delete mirrors the project behavior by toggling `isArchived` so the
+   * row disappears from active lists but remains restorable. Force-delete
+   * optionally removes the transcript file before deleting the database row.
    */
-  async deleteSessionById(
+  async deleteOrArchiveSessionById(
     sessionId: string,
-    deletedFromDisk = false,
-  ): Promise<{ sessionId: string; deletedFromDisk: boolean }> {
+    options: {
+      force?: boolean;
+      deletedFromDisk?: boolean;
+    } = {},
+  ): Promise<{ sessionId: string; action: 'archived' | 'deleted'; deletedFromDisk: boolean }> {
     const session = sessionsDb.getSessionById(sessionId);
     if (!session) {
       throw new AppError(`Session "${sessionId}" was not found.`, {
@@ -96,8 +170,17 @@ export const sessionsService = {
       });
     }
 
+    if (!options.force) {
+      sessionsDb.updateSessionIsArchived(sessionId, true);
+      return {
+        sessionId,
+        action: 'archived',
+        deletedFromDisk: false,
+      };
+    }
+
     let removedFromDisk = false;
-    if (deletedFromDisk && session.jsonl_path) {
+    if (options.deletedFromDisk && session.jsonl_path) {
       removedFromDisk = await removeFileIfExists(session.jsonl_path);
     }
 
@@ -109,7 +192,27 @@ export const sessionsService = {
       });
     }
 
-    return { sessionId, deletedFromDisk: removedFromDisk };
+    return {
+      sessionId,
+      action: 'deleted',
+      deletedFromDisk: removedFromDisk,
+    };
+  },
+
+  /**
+   * Restores one archived session back into the active sidebar lists.
+   */
+  restoreSessionById(sessionId: string): { sessionId: string; isArchived: false } {
+    const session = sessionsDb.getSessionById(sessionId);
+    if (!session) {
+      throw new AppError(`Session "${sessionId}" was not found.`, {
+        code: 'SESSION_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    sessionsDb.updateSessionIsArchived(sessionId, false);
+    return { sessionId, isArchived: false };
   },
 
   /**

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

@@ -0,0 +1,15 @@
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import type { ProviderSkill, ProviderSkillListOptions } from '@/shared/types.js';
+
+export const providerSkillsService = {
+  /**
+   * Lists normalized skills visible to one provider.
+   */
+  async listProviderSkills(
+    providerName: string,
+    options?: ProviderSkillListOptions,
+  ): Promise<ProviderSkill[]> {
+    const provider = providerRegistry.resolveProvider(providerName);
+    return provider.skills.listSkills(options);
+  },
+};

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

@@ -2,7 +2,9 @@ import type {
   IProvider,
   IProviderAuth,
   IProviderMcp,
+  IProviderModels,
   IProviderSessionSynchronizer,
+  IProviderSkills,
   IProviderSessions,
 } from '@/shared/interfaces.js';
 import type { LLMProvider } from '@/shared/types.js';
@@ -16,8 +18,10 @@ import type { LLMProvider } from '@/shared/types.js';
  */
 export abstract class AbstractProvider implements IProvider {
   readonly id: LLMProvider;
+  abstract readonly models: IProviderModels;
   abstract readonly mcp: IProviderMcp;
   abstract readonly auth: IProviderAuth;
+  abstract readonly skills: IProviderSkills;
   abstract readonly sessions: IProviderSessions;
   abstract readonly sessionSynchronizer: IProviderSessionSynchronizer;
 

package/server/modules/providers/shared/skills/skills.provider.ts

@@ -0,0 +1,64 @@
+import path from 'node:path';
+
+import type { IProviderSkills } from '@/shared/interfaces.js';
+import type {
+  LLMProvider,
+  ProviderSkill,
+  ProviderSkillListOptions,
+  ProviderSkillSource,
+} from '@/shared/types.js';
+import {
+  findProviderSkillMarkdownFiles,
+  readProviderSkillMarkdownDefinition,
+} from '@/shared/utils.js';
+
+const resolveWorkspacePath = (workspacePath?: string): string =>
+  path.resolve(workspacePath ?? process.cwd());
+
+/**
+ * Shared skills provider for provider-specific skill source discovery.
+ */
+export abstract class SkillsProvider implements IProviderSkills {
+  protected readonly provider: LLMProvider;
+
+  protected constructor(provider: LLMProvider) {
+    this.provider = provider;
+  }
+
+  async listSkills(options?: ProviderSkillListOptions): Promise<ProviderSkill[]> {
+    const workspacePath = resolveWorkspacePath(options?.workspacePath);
+    const sources = await this.getSkillSources(workspacePath);
+    const skills: ProviderSkill[] = [];
+
+    for (const source of sources) {
+      const skillFiles = await findProviderSkillMarkdownFiles(source.rootDir, {
+        recursive: source.recursive,
+      });
+      for (const skillPath of skillFiles) {
+        try {
+          const definition = await readProviderSkillMarkdownDefinition(skillPath);
+          const command = source.commandForSkill
+            ? source.commandForSkill(definition.name)
+            : `${source.commandPrefix ?? '/'}${definition.name}`;
+
+          skills.push({
+            provider: this.provider,
+            name: definition.name,
+            description: definition.description,
+            command,
+            scope: source.scope,
+            sourcePath: skillPath,
+            pluginName: source.pluginName,
+            pluginId: source.pluginId,
+          });
+        } catch {
+          // A malformed or unreadable skill markdown file should not hide other valid skills.
+        }
+      }
+    }
+
+    return skills;
+  }
+
+  protected abstract getSkillSources(workspacePath: string): Promise<ProviderSkillSource[]>;
+}

package/server/modules/providers/tests/mcp.test.ts

@@ -169,6 +169,93 @@ test('providerMcpService handles codex MCP TOML config and capability validation
   }
 });
 
+/**
+ * This test covers OpenCode MCP support for user/project config files, JSONC-compatible
+ * reads, and validation for unsupported scope/transport combinations.
+ */
+test('providerMcpService handles opencode MCP config and capability validation', { concurrency: false }, async () => {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'llm-mcp-opencode-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await fs.mkdir(workspacePath, { recursive: true });
+  await fs.mkdir(path.join(tempRoot, '.config', 'opencode'), { recursive: true });
+  await fs.writeFile(
+    path.join(tempRoot, '.config', 'opencode', 'opencode.jsonc'),
+    `{
+      // Existing comments should not block OpenCode MCP reads.
+      "mcp": {}
+    }\n`,
+    'utf8',
+  );
+
+  const restoreHomeDir = patchHomeDir(tempRoot);
+  try {
+    await providerMcpService.upsertProviderMcpServer('opencode', {
+      name: 'opencode-user-stdio',
+      scope: 'user',
+      transport: 'stdio',
+      command: 'node',
+      args: ['server.js'],
+      env: { API_KEY: 'x' },
+    });
+
+    await providerMcpService.upsertProviderMcpServer('opencode', {
+      name: 'opencode-project-http',
+      scope: 'project',
+      transport: 'http',
+      url: 'https://opencode.example.com/mcp',
+      headers: { Authorization: 'Bearer token' },
+      workspacePath,
+    });
+
+    const userConfig = await readJson(path.join(tempRoot, '.config', 'opencode', 'opencode.jsonc'));
+    const userServers = userConfig.mcp as Record<string, unknown>;
+    const userStdio = userServers['opencode-user-stdio'] as Record<string, unknown>;
+    assert.equal(userStdio.type, 'local');
+    assert.deepEqual(userStdio.command, ['node', 'server.js']);
+    assert.deepEqual(userStdio.environment, { API_KEY: 'x' });
+
+    const projectConfig = await readJson(path.join(workspacePath, 'opencode.json'));
+    const projectServers = projectConfig.mcp as Record<string, unknown>;
+    const projectHttp = projectServers['opencode-project-http'] as Record<string, unknown>;
+    assert.equal(projectHttp.type, 'remote');
+    assert.equal(projectHttp.url, 'https://opencode.example.com/mcp');
+
+    const grouped = await providerMcpService.listProviderMcpServers('opencode', { workspacePath });
+    assert.ok(grouped.user.some((server) => server.name === 'opencode-user-stdio' && server.transport === 'stdio'));
+    assert.ok(grouped.project.some((server) => server.name === 'opencode-project-http' && server.transport === 'http'));
+
+    await assert.rejects(
+      providerMcpService.upsertProviderMcpServer('opencode', {
+        name: 'opencode-local',
+        scope: 'local',
+        transport: 'stdio',
+        command: 'node',
+      }),
+      (error: unknown) =>
+        error instanceof AppError &&
+        error.code === 'MCP_SCOPE_NOT_SUPPORTED' &&
+        error.statusCode === 400,
+    );
+
+    await assert.rejects(
+      providerMcpService.upsertProviderMcpServer('opencode', {
+        name: 'opencode-sse',
+        scope: 'project',
+        transport: 'sse',
+        url: 'https://example.com/sse',
+        workspacePath,
+      }),
+      (error: unknown) =>
+        error instanceof AppError &&
+        error.code === 'MCP_TRANSPORT_NOT_SUPPORTED' &&
+        error.statusCode === 400,
+    );
+  } finally {
+    restoreHomeDir();
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
 /**
  * This test covers Gemini/Cursor MCP JSON formats and user/project scope persistence.
  */
@@ -254,8 +341,7 @@ test('providerMcpService global adder writes to all providers and rejects unsupp
       workspacePath,
     });
 
-    const expectCursorGlobal = process.platform !== 'win32';
-    assert.equal(globalResult.length, expectCursorGlobal ? 4 : 3);
+    assert.equal(globalResult.length, 5);
     assert.ok(globalResult.every((entry) => entry.created === true));
 
     const claudeProject = await readJson(path.join(workspacePath, '.mcp.json'));
@@ -267,10 +353,11 @@ test('providerMcpService global adder writes to all providers and rejects unsupp
     const geminiProject = await readJson(path.join(workspacePath, '.gemini', 'settings.json'));
     assert.ok((geminiProject.mcpServers as Record<string, unknown>)['global-http']);
 
-    if (expectCursorGlobal) {
-      const cursorProject = await readJson(path.join(workspacePath, '.cursor', 'mcp.json'));
-      assert.ok((cursorProject.mcpServers as Record<string, unknown>)['global-http']);
-    }
+    const opencodeProject = await readJson(path.join(workspacePath, 'opencode.json'));
+    assert.ok((opencodeProject.mcp as Record<string, unknown>)['global-http']);
+
+    const cursorProject = await readJson(path.join(workspacePath, '.cursor', 'mcp.json'));
+    assert.ok((cursorProject.mcpServers as Record<string, unknown>)['global-http']);
 
     await assert.rejects(
       providerMcpService.addMcpServerToAllProviders({

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

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  buildOpenCodeDefinitionFromIds,
+  parseOpenCodeModelsStdout,
+} 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',
+    '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',
+    },
+  ]);
+});