@mseep/claudian 2.0.25

package/tests/unit/providers/opencode/OpencodeLaunchArtifacts.test.ts

@@ -0,0 +1,268 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import {
+  OPENCODE_SAFE_MODE_ID,
+  OPENCODE_YOLO_MODE_ID,
+} from '../../../../src/providers/opencode/modes';
+import {
+  buildOpencodeManagedConfig,
+  prepareOpencodeLaunchArtifacts,
+} from '../../../../src/providers/opencode/runtime/OpencodeLaunchArtifacts';
+
+describe('buildOpencodeManagedConfig', () => {
+  it('pins OpenCode build, YOLO, safe, and plan prompts to the managed prompt file', () => {
+    expect(buildOpencodeManagedConfig({}, '/vault/.claudian/opencode/system.md', 'Yishen')).toEqual({
+      $schema: 'https://opencode.ai/config.json',
+      agent: {
+        build: {
+          prompt: '{file:/vault/.claudian/opencode/system.md}',
+        },
+        [OPENCODE_YOLO_MODE_ID]: {
+          mode: 'primary',
+          permission: {
+            plan_enter: 'allow',
+            question: 'allow',
+          },
+          prompt: '{file:/vault/.claudian/opencode/system.md}',
+        },
+        [OPENCODE_SAFE_MODE_ID]: {
+          mode: 'primary',
+          permission: {
+            bash: 'ask',
+            edit: 'ask',
+            plan_enter: 'allow',
+            question: 'allow',
+          },
+          prompt: '{file:/vault/.claudian/opencode/system.md}',
+        },
+        plan: {
+          prompt: '{file:/vault/.claudian/opencode/system.md}',
+        },
+      },
+      username: 'Yishen',
+    });
+  });
+
+  it('can create a dedicated aux agent and default it for the process', () => {
+    expect(buildOpencodeManagedConfig(
+      {},
+      '/vault/.claudian/opencode/auxiliary/system.md',
+      undefined,
+      [{
+        definition: {
+          mode: 'primary',
+          permission: {
+            '*': 'deny',
+            read: 'allow',
+          },
+        },
+        id: 'claudian-aux-readonly',
+      }],
+      'claudian-aux-readonly',
+    )).toEqual({
+      $schema: 'https://opencode.ai/config.json',
+      agent: {
+        'claudian-aux-readonly': {
+          mode: 'primary',
+          permission: {
+            '*': 'deny',
+            read: 'allow',
+          },
+          prompt: '{file:/vault/.claudian/opencode/auxiliary/system.md}',
+        },
+      },
+      default_agent: 'claudian-aux-readonly',
+    });
+  });
+
+  it('merges the user config instead of replacing it', () => {
+    expect(buildOpencodeManagedConfig({
+      agent: {
+        build: {
+          model: 'openai/gpt-5',
+          permission: {
+            bash: 'ask',
+            edit: 'ask',
+          },
+        },
+      },
+      default_agent: 'build',
+      providers: {
+        openai: {
+          api_key: 'test-key',
+        },
+      },
+      username: 'Existing',
+    }, '/vault/.claudian/opencode/system.md')).toEqual({
+      $schema: 'https://opencode.ai/config.json',
+      agent: {
+        build: {
+          model: 'openai/gpt-5',
+          permission: {
+            bash: 'ask',
+            edit: 'ask',
+          },
+          prompt: '{file:/vault/.claudian/opencode/system.md}',
+        },
+        [OPENCODE_YOLO_MODE_ID]: {
+          mode: 'primary',
+          permission: {
+            plan_enter: 'allow',
+            question: 'allow',
+          },
+          prompt: '{file:/vault/.claudian/opencode/system.md}',
+        },
+        [OPENCODE_SAFE_MODE_ID]: {
+          mode: 'primary',
+          permission: {
+            bash: 'ask',
+            edit: 'ask',
+            plan_enter: 'allow',
+            question: 'allow',
+          },
+          prompt: '{file:/vault/.claudian/opencode/system.md}',
+        },
+        plan: {
+          prompt: '{file:/vault/.claudian/opencode/system.md}',
+        },
+      },
+      default_agent: 'build',
+      providers: {
+        openai: {
+          api_key: 'test-key',
+        },
+      },
+      username: 'Existing',
+    });
+  });
+});
+
+describe('prepareOpencodeLaunchArtifacts', () => {
+  it('layers the managed prompt config on top of OPENCODE_CONFIG', async () => {
+    const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'claudian-opencode-artifacts-'));
+    const baseConfigPath = path.join(tmpRoot, 'opencode.base.json');
+    await fs.writeFile(baseConfigPath, JSON.stringify({
+      agent: {
+        build: {
+          model: 'openai/gpt-5',
+        },
+      },
+      default_agent: 'build',
+      providers: {
+        anthropic: {
+          api_key: 'anthropic-key',
+        },
+      },
+    }), 'utf8');
+
+    const result = await prepareOpencodeLaunchArtifacts({
+      runtimeEnv: {
+        HOME: tmpRoot,
+        OPENCODE_CONFIG: baseConfigPath,
+      } as NodeJS.ProcessEnv,
+      settings: {
+        customPrompt: '',
+        mediaFolder: '',
+        userName: 'Yishen',
+        vaultPath: tmpRoot,
+      },
+      workspaceRoot: tmpRoot,
+    });
+
+    expect(result.configPath).toBe(path.join(tmpRoot, '.claudian', 'opencode', 'config.json'));
+    expect(result.systemPromptPath).toBe(path.join(tmpRoot, '.claudian', 'opencode', 'system.md'));
+    expect(result.configContent).toContain(`"prompt": "{file:${result.systemPromptPath}}"`);
+    const generatedConfig = JSON.parse(await fs.readFile(result.configPath, 'utf8'));
+    expect(generatedConfig).toMatchObject({
+      default_agent: 'build',
+      providers: {
+        anthropic: {
+          api_key: 'anthropic-key',
+        },
+      },
+      username: 'Yishen',
+    });
+    expect(generatedConfig.agent).toMatchObject({
+      build: {
+        model: 'openai/gpt-5',
+        prompt: `{file:${result.systemPromptPath}}`,
+      },
+      [OPENCODE_YOLO_MODE_ID]: {
+        mode: 'primary',
+        permission: {
+          plan_enter: 'allow',
+          question: 'allow',
+        },
+        prompt: `{file:${result.systemPromptPath}}`,
+      },
+      [OPENCODE_SAFE_MODE_ID]: {
+        mode: 'primary',
+        permission: {
+          bash: 'ask',
+          edit: 'ask',
+          plan_enter: 'allow',
+          question: 'allow',
+        },
+        prompt: `{file:${result.systemPromptPath}}`,
+      },
+      plan: {
+        prompt: `{file:${result.systemPromptPath}}`,
+      },
+    });
+  });
+
+  it('keeps the launch key stable when the resolved default database is later passed as OPENCODE_DB', async () => {
+    const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'claudian-opencode-artifacts-'));
+    const baseParams = {
+      settings: {
+        customPrompt: '',
+        mediaFolder: '',
+        userName: '',
+        vaultPath: tmpRoot,
+      },
+      workspaceRoot: tmpRoot,
+    };
+    const first = await prepareOpencodeLaunchArtifacts({
+      ...baseParams,
+      runtimeEnv: {
+        HOME: tmpRoot,
+      } as NodeJS.ProcessEnv,
+    });
+
+    const second = await prepareOpencodeLaunchArtifacts({
+      ...baseParams,
+      runtimeEnv: {
+        HOME: tmpRoot,
+        OPENCODE_DB: first.databasePath ?? undefined,
+      } as NodeJS.ProcessEnv,
+    });
+
+    expect(first.databasePath).toBe(second.databasePath);
+    expect(first.launchKey).toBe(second.launchKey);
+  });
+
+  it('creates the resolved OpenCode database directory before launch', async () => {
+    const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'claudian-opencode-artifacts-'));
+    const xdgDataHome = path.join(tmpRoot, 'xdg-data');
+    const databaseDir = path.join(xdgDataHome, 'opencode');
+
+    const result = await prepareOpencodeLaunchArtifacts({
+      runtimeEnv: {
+        HOME: path.join(tmpRoot, 'home'),
+        XDG_DATA_HOME: xdgDataHome,
+      } as NodeJS.ProcessEnv,
+      settings: {
+        customPrompt: '',
+        mediaFolder: '',
+        userName: '',
+        vaultPath: tmpRoot,
+      },
+      workspaceRoot: tmpRoot,
+    });
+
+    expect(result.databasePath).toBe(path.join(databaseDir, 'opencode.db'));
+    await expect(fs.access(databaseDir)).resolves.toBeUndefined();
+  });
+});

package/tests/unit/providers/opencode/OpencodePaths.test.ts

@@ -0,0 +1,35 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import {
+  resolveExistingOpencodeDatabasePath,
+  resolveOpencodeDatabasePath,
+  resolveOpencodeDataDir,
+} from '../../../../src/providers/opencode/runtime/OpencodePaths';
+
+describe('OpencodePaths', () => {
+  it('prefers XDG data directories for OpenCode data', () => {
+    expect(resolveOpencodeDataDir({
+      HOME: '/home/tester',
+      XDG_DATA_HOME: '/tmp/xdg-data',
+    } as NodeJS.ProcessEnv)).toBe('/tmp/xdg-data/opencode');
+  });
+
+  it('falls back to the existing resolved database when persisted metadata points at a missing path', () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'claudian-opencode-paths-'));
+    const xdgDataHome = path.join(tmpRoot, 'xdg-data');
+    const dbDir = path.join(xdgDataHome, 'opencode');
+    const dbPath = path.join(dbDir, 'opencode.db');
+    fs.mkdirSync(dbDir, { recursive: true });
+    fs.writeFileSync(dbPath, '');
+
+    const env = {
+      HOME: path.join(tmpRoot, 'home'),
+      XDG_DATA_HOME: xdgDataHome,
+    } as NodeJS.ProcessEnv;
+
+    expect(resolveOpencodeDatabasePath(env)).toBe(dbPath);
+    expect(resolveExistingOpencodeDatabasePath('/missing/opencode.db', env)).toBe(dbPath);
+  });
+});

package/tests/unit/providers/opencode/OpencodeRuntimeCommandLoader.test.ts

@@ -0,0 +1,129 @@
+import { OpencodeRuntimeCommandLoader } from '@/providers/opencode/app/OpencodeRuntimeCommandLoader';
+import { OpencodeChatRuntime } from '@/providers/opencode/runtime/OpencodeChatRuntime';
+
+function createMockPlugin(): any {
+  return {
+    settings: {
+      providerConfigs: {
+        opencode: {
+          enabled: true,
+        },
+      },
+    },
+  };
+}
+
+describe('OpencodeRuntimeCommandLoader', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('uses an isolated in-memory session for blank-tab command warmup', async () => {
+    const commands = [{ id: 'acp:review', name: 'review', content: '' }];
+    const syncSpy = jest.spyOn(OpencodeChatRuntime.prototype, 'syncConversationState').mockImplementation(() => {});
+    const ensureReadySpy = jest.spyOn(OpencodeChatRuntime.prototype, 'ensureReady').mockResolvedValue(true);
+    const getSupportedCommandsSpy = jest.spyOn(OpencodeChatRuntime.prototype, 'getSupportedCommands').mockResolvedValue(commands);
+    const cleanupSpy = jest.spyOn(OpencodeChatRuntime.prototype, 'cleanup').mockImplementation(() => {});
+    const loader = new OpencodeRuntimeCommandLoader();
+
+    await expect(loader.loadCommands({
+      allowSessionCreation: true,
+      conversation: null,
+      externalContextPaths: [],
+      plugin: createMockPlugin(),
+      runtime: null,
+    })).resolves.toEqual(commands);
+
+    expect(syncSpy).toHaveBeenCalledWith({
+      providerState: { databasePath: ':memory:' },
+      sessionId: null,
+    });
+    expect(ensureReadySpy).toHaveBeenCalledWith({ allowSessionCreation: true });
+    expect(getSupportedCommandsSpy).toHaveBeenCalledTimes(1);
+    expect(cleanupSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps blank tabs cold unless warmup is explicitly requested', async () => {
+    const ensureReadySpy = jest.spyOn(OpencodeChatRuntime.prototype, 'ensureReady');
+    const loader = new OpencodeRuntimeCommandLoader();
+
+    await expect(loader.loadCommands({
+      conversation: null,
+      externalContextPaths: [],
+      plugin: createMockPlugin(),
+      runtime: null,
+    })).resolves.toEqual([]);
+
+    expect(ensureReadySpy).not.toHaveBeenCalled();
+  });
+
+  it('warms pre-session conversations that already have messages', async () => {
+    const commands = [{ id: 'acp:review', name: 'review', content: '' }];
+    const syncSpy = jest.spyOn(OpencodeChatRuntime.prototype, 'syncConversationState').mockImplementation(() => {});
+    const ensureReadySpy = jest.spyOn(OpencodeChatRuntime.prototype, 'ensureReady').mockResolvedValue(true);
+    const getSupportedCommandsSpy = jest.spyOn(OpencodeChatRuntime.prototype, 'getSupportedCommands').mockResolvedValue(commands);
+    const loader = new OpencodeRuntimeCommandLoader();
+
+    await expect(loader.loadCommands({
+      conversation: {
+        id: 'conv-opencode',
+        messages: [{ id: 'm1' }],
+        providerState: {},
+        sessionId: null,
+      } as any,
+      externalContextPaths: [],
+      plugin: createMockPlugin(),
+      runtime: null,
+    })).resolves.toEqual(commands);
+
+    expect(syncSpy).toHaveBeenCalledWith({
+      id: 'conv-opencode',
+      messages: [{ id: 'm1' }],
+      providerState: {},
+      sessionId: null,
+    }, []);
+    expect(ensureReadySpy).toHaveBeenCalledWith({ allowSessionCreation: true });
+    expect(getSupportedCommandsSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not create a pre-session command warmup session on the bound tab runtime', async () => {
+    const commands = [{ id: 'acp:review', name: 'review', content: '' }];
+    const syncSpy = jest.spyOn(OpencodeChatRuntime.prototype, 'syncConversationState').mockImplementation(() => {});
+    const ensureReadySpy = jest.spyOn(OpencodeChatRuntime.prototype, 'ensureReady').mockResolvedValue(true);
+    const getSupportedCommandsSpy = jest.spyOn(OpencodeChatRuntime.prototype, 'getSupportedCommands').mockResolvedValue(commands);
+    const cleanupSpy = jest.spyOn(OpencodeChatRuntime.prototype, 'cleanup').mockImplementation(() => {});
+    const boundRuntime = {
+      providerId: 'opencode',
+      cleanup: jest.fn(),
+      ensureReady: jest.fn(),
+      getSupportedCommands: jest.fn(),
+      syncConversationState: jest.fn(),
+    };
+    const loader = new OpencodeRuntimeCommandLoader();
+
+    await expect(loader.loadCommands({
+      conversation: {
+        id: 'conv-opencode',
+        messages: [{ id: 'm1' }],
+        providerState: {},
+        sessionId: null,
+      } as any,
+      externalContextPaths: [],
+      plugin: createMockPlugin(),
+      runtime: boundRuntime as any,
+    })).resolves.toEqual(commands);
+
+    expect(boundRuntime.syncConversationState).not.toHaveBeenCalled();
+    expect(boundRuntime.ensureReady).not.toHaveBeenCalled();
+    expect(boundRuntime.getSupportedCommands).not.toHaveBeenCalled();
+    expect(syncSpy).toHaveBeenCalledWith({
+      id: 'conv-opencode',
+      messages: [{ id: 'm1' }],
+      providerState: {},
+      sessionId: null,
+    }, []);
+    expect(ensureReadySpy).toHaveBeenCalledWith({ allowSessionCreation: true });
+    expect(getSupportedCommandsSpy).toHaveBeenCalledTimes(1);
+    expect(cleanupSpy).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/unit/providers/opencode/OpencodeSettingsReconciler.test.ts

@@ -0,0 +1,96 @@
+import { getOpencodeDiscoveryState, updateOpencodeDiscoveryState } from '../../../../src/providers/opencode/discoveryState';
+import { opencodeSettingsReconciler } from '../../../../src/providers/opencode/env/OpencodeSettingsReconciler';
+
+describe('opencodeSettingsReconciler.normalizeModelVariantSettings', () => {
+  it('migrates saved variant model ids into base model ids plus effort', () => {
+    const settings: Record<string, unknown> = {
+      effortLevel: '',
+      model: 'opencode:anthropic/claude-sonnet-4/high',
+      providerConfigs: {
+        opencode: {
+          discoveredModels: [
+            { label: 'Anthropic/Claude Sonnet 4', rawId: 'anthropic/claude-sonnet-4' },
+            { label: 'Anthropic/Claude Sonnet 4 (high)', rawId: 'anthropic/claude-sonnet-4/high' },
+          ],
+          visibleModels: ['anthropic/claude-sonnet-4/high'],
+        },
+      },
+      savedProviderEffort: {},
+      savedProviderModel: {
+        opencode: 'opencode:anthropic/claude-sonnet-4/high',
+      },
+      settingsProvider: 'opencode',
+      titleGenerationModel: 'opencode:anthropic/claude-sonnet-4/high',
+    };
+
+    expect(opencodeSettingsReconciler.normalizeModelVariantSettings(settings)).toBe(true);
+    expect(settings).toMatchObject({
+      effortLevel: 'high',
+      model: 'opencode:anthropic/claude-sonnet-4',
+      savedProviderEffort: {
+        opencode: 'high',
+      },
+      savedProviderModel: {
+        opencode: 'opencode:anthropic/claude-sonnet-4',
+      },
+      titleGenerationModel: 'opencode:anthropic/claude-sonnet-4',
+    });
+  });
+});
+
+describe('opencodeSettingsReconciler.handleEnvironmentChange', () => {
+  it('clears provider-owned discovery state when environment changes', () => {
+    const settings: Record<string, unknown> = {};
+    updateOpencodeDiscoveryState(settings, {
+      availableModes: [{ id: 'build', name: 'Build' }],
+      discoveredModels: [{ label: 'OpenAI/GPT-5', rawId: 'openai/gpt-5' }],
+    });
+
+    expect(opencodeSettingsReconciler.handleEnvironmentChange?.(settings)).toBe(true);
+    expect(getOpencodeDiscoveryState(settings)).toEqual({
+      availableModes: [],
+      discoveredModels: [],
+      thinkingOptionsByModel: {},
+    });
+  });
+});
+
+describe('opencodeSettingsReconciler.reconcileModelWithEnvironment', () => {
+  it('invalidates persisted OpenCode session state when the runtime database/config env changes', () => {
+    const settings: Record<string, unknown> = {
+      providerConfigs: {
+        opencode: {
+          enabled: true,
+          environmentHash: 'OPENCODE_DB=/old/opencode.db',
+          environmentVariables: 'OPENCODE_DB=/new/opencode.db\nOPENCODE_CONFIG=/tmp/opencode.json',
+        },
+      },
+    };
+    const conversations = [
+      {
+        id: 'conv-opencode',
+        messages: [],
+        providerId: 'opencode',
+        providerState: { databasePath: '/old/opencode.db' },
+        sessionId: 'session-1',
+      },
+      {
+        id: 'conv-other',
+        messages: [],
+        providerId: 'claude',
+        providerState: { providerSessionId: 'claude-session' },
+        sessionId: 'claude-session',
+      },
+    ] as any;
+
+    const result = opencodeSettingsReconciler.reconcileModelWithEnvironment(settings, conversations);
+
+    expect(result.changed).toBe(true);
+    expect(result.invalidatedConversations).toHaveLength(1);
+    expect(conversations[0].sessionId).toBeNull();
+    expect(conversations[0].providerState).toBeUndefined();
+    expect((settings.providerConfigs as any).opencode.environmentHash).toBe(
+      'OPENCODE_CONFIG=/tmp/opencode.json|OPENCODE_DB=/new/opencode.db',
+    );
+  });
+});