@openchambery/web 1.19.20 → 2.0.0-beta.1

package/server/lib/opencode/env-runtime.test.js

@@ -10,6 +10,7 @@ const originalPath = process.env.PATH;
 const originalLocalAppData = process.env.LOCALAPPDATA;
 const originalSystemRoot = process.env.SystemRoot;
 const originalBundledOpencodeCliDir = process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+const originalOpenChamberDataDir = process.env.OPENCHAMBER_DATA_DIR;
 const originalResourcesPath = process.resourcesPath;
 const originalWslBinary = process.env.WSL_BINARY;
 const originalOpenChamberWslBinary = process.env.OPENCHAMBER_WSL_BINARY;
@@ -23,6 +24,16 @@ const createTempDir = (prefix) => {
   return dir;
 };
 
+const writeVersionBinary = (filePath, version) => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  if (process.platform === 'win32') {
+    fs.writeFileSync(filePath, `@echo off\r\necho ${version}\r\n`);
+    return;
+  }
+  fs.writeFileSync(filePath, `#!${process.execPath}\nconsole.log(${JSON.stringify(version)});\n`);
+  fs.chmodSync(filePath, 0o755);
+};
+
 const setPlatform = (platform) => {
   Object.defineProperty(process, 'platform', {
     value: platform,
@@ -74,6 +85,12 @@ afterEach(() => {
     delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
   }
 
+  if (typeof originalOpenChamberDataDir === 'string') {
+    process.env.OPENCHAMBER_DATA_DIR = originalOpenChamberDataDir;
+  } else {
+    delete process.env.OPENCHAMBER_DATA_DIR;
+  }
+
   Object.defineProperty(process, 'resourcesPath', {
     configurable: true,
     value: originalResourcesPath,
@@ -112,6 +129,7 @@ const createRuntime = (settings, options = {}) => {
     readSettingsFromDiskMigrated: async () => settings,
     spawnSync: options.spawnSync,
     homedir: options.homedir,
+    ensurePinnedOpenCode2Cli: options.ensurePinnedOpenCode2Cli,
   });
 
   return { runtime, state };
@@ -119,11 +137,11 @@ const createRuntime = (settings, options = {}) => {
 
 describe('OpenCode env runtime', () => {
   it('throws a specific error for a missing configured OpenCode binary in strict mode', async () => {
-    const { runtime } = createRuntime({ opencodeBinary: '/missing/opencode' });
+    const { runtime } = createRuntime({ opencodeBinary: '/missing/opencode2' });
 
     await expect(runtime.applyOpencodeBinaryFromSettings({ strict: true })).rejects.toMatchObject({
       code: 'OPENCODE_BINARY_INVALID',
-      message: expect.stringContaining('Configured OpenCode binary not found: /missing/opencode'),
+      message: expect.stringContaining('Configured OpenCode binary not found: /missing/opencode2'),
     });
   });
 
@@ -139,7 +157,7 @@ describe('OpenCode env runtime', () => {
 
   it('applies a valid configured executable OpenCode binary', async () => {
     const dir = createTempDir('openchamber-opencode-bin-');
-    const binary = path.join(dir, 'opencode');
+    const binary = path.join(dir, 'opencode2');
     fs.writeFileSync(binary, '#!/bin/sh\nexit 0\n');
     fs.chmodSync(binary, 0o755);
     const { runtime, state } = createRuntime({ opencodeBinary: binary });
@@ -150,16 +168,78 @@ describe('OpenCode env runtime', () => {
     expect(state.resolvedOpencodeBinarySource).toBe('settings');
   });
 
+  it('rejects a configured 1.x opencode version in strict mode', async () => {
+    const dir = createTempDir('openchamber-opencode-1x-');
+    const binary = path.join(dir, 'opencode');
+    writeVersionBinary(binary, '1.18.4');
+    const { runtime } = createRuntime({ opencodeBinary: binary });
+
+    await expect(runtime.applyOpencodeBinaryFromSettings({ strict: true })).rejects.toMatchObject({
+      code: 'OPENCODE_BINARY_INVALID',
+      message: expect.stringMatching(/1\.x.*OpenCode v2/s),
+    });
+  });
+
+  it('rejects an explicit OPENCODE_BINARY that reports a 1.x version', () => {
+    const dir = createTempDir('openchamber-env-opencode-1x-');
+    const binary = path.join(dir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    writeVersionBinary(binary, '1.18.4');
+    process.env.OPENCODE_BINARY = binary;
+    const { runtime } = createRuntime({});
+
+    expect(() => runtime.resolveOpencodeCliPath()).toThrow(
+      expect.objectContaining({
+        code: 'OPENCODE_BINARY_INVALID',
+        message: expect.stringMatching(/1\.x.*OpenCode v2/s),
+      })
+    );
+  });
+
+  it('discovers opencode from a home-directory install location', () => {
+    const home = createTempDir('openchamber-home-opencode-');
+    const binary = path.join(home, '.bun', 'bin', 'opencode');
+    writeVersionBinary(binary, '2.0.12');
+    process.env.PATH = createTempDir('openchamber-empty-path-home-');
+    delete process.env.OPENCODE_BINARY;
+    delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => home,
+    });
+
+    expect(runtime.resolveOpencodeCliPath()).toBe(binary);
+    expect(state.resolvedOpencodeBinarySource).toBe('fallback');
+  });
+
+  it('does not treat a PATH 1.x opencode binary as a resolved CLI', () => {
+    const pathDir = createTempDir('openchamber-path-opencode-1x-');
+    const pathBinary = path.join(pathDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    fs.writeFileSync(pathBinary, '#!/bin/sh\nexit 0\n');
+    if (process.platform !== 'win32') {
+      fs.chmodSync(pathBinary, 0o755);
+    }
+    process.env.PATH = pathDir;
+    delete process.env.OPENCODE_BINARY;
+    delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+    const emptyHome = createTempDir('openchamber-empty-home-1x-');
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+    });
+
+    expect(runtime.resolveOpencodeCliPath()).toBeNull();
+    expect(state.resolvedOpencodeBinarySource).toBeNull();
+  });
+
   it('prefers a user-installed OpenCode from PATH over the bundled CLI', () => {
     const bundledDir = createTempDir('openchamber-bundled-opencode-');
-    const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode2.exe' : 'opencode2');
     const pathDir = createTempDir('openchamber-path-opencode-');
     const pathBinary = path.join(pathDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
     fs.writeFileSync(bundledBinary, '#!/bin/sh\nexit 0\n');
-    fs.writeFileSync(pathBinary, '#!/bin/sh\nexit 0\n');
+    writeVersionBinary(pathBinary, '2.0.12');
     if (process.platform !== 'win32') {
       fs.chmodSync(bundledBinary, 0o755);
-      fs.chmodSync(pathBinary, 0o755);
     }
     process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
     process.env.PATH = pathDir;
@@ -172,14 +252,13 @@ describe('OpenCode env runtime', () => {
 
   it('keeps explicit OpenCode binary ahead of bundled CLI', () => {
     const bundledDir = createTempDir('openchamber-bundled-opencode-');
-    const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode2.exe' : 'opencode2');
     const explicitDir = createTempDir('openchamber-explicit-opencode-');
-    const explicitBinary = path.join(explicitDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    const explicitBinary = path.join(explicitDir, process.platform === 'win32' ? 'opencode2.exe' : 'opencode2');
     fs.writeFileSync(bundledBinary, '#!/bin/sh\nexit 0\n');
-    fs.writeFileSync(explicitBinary, '#!/bin/sh\nexit 0\n');
+    writeVersionBinary(explicitBinary, '2.0.12');
     if (process.platform !== 'win32') {
       fs.chmodSync(bundledBinary, 0o755);
-      fs.chmodSync(explicitBinary, 0o755);
     }
     process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
     process.env.OPENCODE_BINARY = explicitBinary;
@@ -189,10 +268,10 @@ describe('OpenCode env runtime', () => {
     expect(state.resolvedOpencodeBinarySource).toBe('env');
   });
 
-  it('falls back to the bundled OpenCode CLI from Electron resourcesPath when nothing else is installed', () => {
+  it('does not use a bundled OpenCode CLI from Electron resourcesPath', () => {
     const resourcesPath = createTempDir('openchamber-resources-');
     const bundledDir = path.join(resourcesPath, 'opencode-cli');
-    const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode2.exe' : 'opencode2');
     fs.mkdirSync(bundledDir, { recursive: true });
     fs.writeFileSync(bundledBinary, '#!/bin/sh\nexit 0\n');
     if (process.platform !== 'win32') {
@@ -203,18 +282,142 @@ describe('OpenCode env runtime', () => {
       value: resourcesPath,
     });
     process.env.PATH = createTempDir('openchamber-empty-path-');
-    delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+    process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
     delete process.env.OPENCODE_BINARY;
-    // The bundled CLI is the LAST resort now — hide the machine's own installs
-    // from the home-directory fallbacks and shell discovery.
     const emptyHome = createTempDir('openchamber-empty-home-');
     const { runtime, state } = createRuntime({}, {
       spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
       homedir: () => emptyHome,
     });
 
-    expect(runtime.resolveOpencodeCliPath()).toBe(bundledBinary);
+    expect(runtime.resolveOpencodeCliPath()).toBeNull();
+    expect(state.resolvedOpencodeBinarySource).toBeNull();
+  });
+
+  it('discovers a previously installed pin from the OpenChamber data dir', () => {
+    const dataDir = createTempDir('openchamber-installed-cli-');
+    const installedDir = path.join(dataDir, 'opencode-cli', '2.0.12');
+    const installedBinary = path.join(installedDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    fs.mkdirSync(installedDir, { recursive: true });
+    fs.writeFileSync(installedBinary, '#!/bin/sh\nexit 0\n');
+    if (process.platform !== 'win32') {
+      fs.chmodSync(installedBinary, 0o755);
+    }
+    process.env.OPENCHAMBER_DATA_DIR = dataDir;
+    process.env.PATH = createTempDir('openchamber-empty-path-installed-');
+    delete process.env.OPENCODE_BINARY;
+    delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+    const emptyHome = createTempDir('openchamber-empty-home-installed-');
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+    });
+
+    expect(runtime.resolveOpencodeCliPath()).toBe(installedBinary);
+    expect(state.resolvedOpencodeBinarySource).toBe('installed');
+  });
+
+  it('installs the pinned CLI when discovery finds nothing', async () => {
+    const installed = path.join(createTempDir('openchamber-ensure-install-'), process.platform === 'win32' ? 'opencode2.exe' : 'opencode2');
+    fs.writeFileSync(installed, '#!/bin/sh\nexit 0\n');
+    if (process.platform !== 'win32') {
+      fs.chmodSync(installed, 0o755);
+    }
+    process.env.PATH = createTempDir('openchamber-empty-path-ensure-');
+    delete process.env.OPENCODE_BINARY;
+    delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+    const emptyHome = createTempDir('openchamber-empty-home-ensure-');
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+      ensurePinnedOpenCode2Cli: async () => ({
+        path: installed,
+        version: '2.0.12',
+        source: 'installed',
+        installed: true,
+      }),
+    });
+
+    await expect(runtime.ensurePinnedOpenCode2CliEnv()).resolves.toBe(installed);
+    expect(state.resolvedOpencodeBinary).toBe(installed);
+    expect(state.resolvedOpencodeBinarySource).toBe('installed');
+    expect(process.env.OPENCODE_BINARY).toBe(installed);
+  });
+
+  it('falls back to a bundled 2.x CLI only after pin install fails', async () => {
+    const bundledDir = createTempDir('openchamber-bundled-fallback-');
+    const bundledName = process.platform === 'win32' ? 'opencode2.exe' : 'opencode2';
+    const bundledBinary = path.join(bundledDir, bundledName);
+    writeVersionBinary(bundledBinary, '2.0.12');
+    process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
+    process.env.PATH = createTempDir('openchamber-empty-path-bundled-fallback-');
+    process.env.OPENCHAMBER_DATA_DIR = createTempDir('openchamber-empty-data-bundled-fallback-');
+    delete process.env.OPENCODE_BINARY;
+    const emptyHome = createTempDir('openchamber-empty-home-bundled-fallback-');
+    const missingError = Object.assign(new Error('OpenCode CLI missing'), { code: 'OPENCODE_CLI_MISSING' });
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+      ensurePinnedOpenCode2Cli: async () => {
+        throw missingError;
+      },
+    });
+
+    await expect(runtime.ensurePinnedOpenCode2CliEnv()).resolves.toBe(bundledBinary);
+    expect(state.resolvedOpencodeBinary).toBe(bundledBinary);
     expect(state.resolvedOpencodeBinarySource).toBe('bundled');
+    expect(process.env.OPENCODE_BINARY).toBe(bundledBinary);
+  });
+
+  it('falls back to bundled opencode name when pin install fails', async () => {
+    const bundledDir = createTempDir('openchamber-bundled-opencode-name-');
+    const bundledName = process.platform === 'win32' ? 'opencode.exe' : 'opencode';
+    const bundledBinary = path.join(bundledDir, bundledName);
+    writeVersionBinary(bundledBinary, '2.0.12');
+    process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
+    process.env.PATH = createTempDir('openchamber-empty-path-bundled-opencode-');
+    process.env.OPENCHAMBER_DATA_DIR = createTempDir('openchamber-empty-data-bundled-opencode-');
+    delete process.env.OPENCODE_BINARY;
+    const emptyHome = createTempDir('openchamber-empty-home-bundled-opencode-');
+    const missingError = Object.assign(new Error('OpenCode CLI missing'), { code: 'OPENCODE_CLI_MISSING' });
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+      ensurePinnedOpenCode2Cli: async () => {
+        throw missingError;
+      },
+    });
+
+    await expect(runtime.ensurePinnedOpenCode2CliEnv()).resolves.toBe(bundledBinary);
+    expect(state.resolvedOpencodeBinarySource).toBe('bundled');
+    expect(process.env.OPENCODE_BINARY).toBe(bundledBinary);
+  });
+
+  it('does not adopt a bundled 1.x CLI after pin install fails', async () => {
+    const bundledDir = createTempDir('openchamber-bundled-1x-');
+    const bundledName = process.platform === 'win32' ? 'opencode2.exe' : 'opencode2';
+    const bundledBinary = path.join(bundledDir, bundledName);
+    writeVersionBinary(bundledBinary, '1.18.4');
+    process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
+    process.env.PATH = createTempDir('openchamber-empty-path-bundled-1x-');
+    process.env.OPENCHAMBER_DATA_DIR = createTempDir('openchamber-empty-data-bundled-1x-');
+    delete process.env.OPENCODE_BINARY;
+    const emptyHome = createTempDir('openchamber-empty-home-bundled-1x-');
+    const missingError = Object.assign(new Error('OpenCode CLI missing'), { code: 'OPENCODE_CLI_MISSING' });
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+      ensurePinnedOpenCode2Cli: async () => {
+        throw missingError;
+      },
+    });
+
+    await expect(runtime.ensurePinnedOpenCode2CliEnv()).rejects.toMatchObject({
+      code: 'OPENCODE_CLI_MISSING',
+    });
+    expect(state.resolvedOpencodeBinary).toBeNull();
+    expect(state.resolvedOpencodeBinarySource).toBeNull();
+    expect(process.env.OPENCODE_BINARY).toBeUndefined();
   });
 
   itIf(process.platform === 'darwin')('rejects known macOS OpenCode app bundle executable paths', async () => {
@@ -265,7 +468,8 @@ describe('OpenCode env runtime', () => {
     const cliBinary = path.join(createTempDir('openchamber-cli-'), 'opencode.exe');
     fs.mkdirSync(path.dirname(desktopBinary), { recursive: true });
     fs.writeFileSync(desktopBinary, '');
-    fs.writeFileSync(cliBinary, '');
+    fs.writeFileSync(cliBinary, `#!${process.execPath}\nconsole.log('2.0.12');\n`);
+    fs.chmodSync(cliBinary, 0o755);
     process.env.LOCALAPPDATA = localAppData;
     process.env.PATH = createTempDir('openchamber-empty-path-');
     process.env.SystemRoot = createTempDir('openchamber-empty-systemroot-');

package/server/lib/opencode/feature-routes-runtime.js

@@ -2,6 +2,7 @@ import { registerFsRoutes } from '../fs/routes.js';
 import { registerQuotaRoutes } from '../quota/routes.js';
 import { registerSmallModelRoutes } from '../small-model/routes.js';
 import { registerSessionGoalRoutes } from '../session-goal/routes.js';
+import { registerSessionMetadataRoutes } from '../session-metadata/routes.js';
 import { registerGitHubRoutes } from '../github/routes.js';
 import { registerGitRoutes } from '../git/routes.js';
 import { registerMagicPromptRoutes } from '../magic-prompts/routes.js';
@@ -113,6 +114,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       isUnsafeSkillRelativePath,
       buildOpenCodeUrl,
       getOpenCodeAuthHeaders,
+      getIsExternalOpenCode = () => false,
       getSmallModelService: routeGetSmallModelService,
       getOpenCodePort,
       buildAugmentedPath,
@@ -132,6 +134,10 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       getServerId,
       sessionIndexService,
       notifyContactTurnComplete,
+      sessionMetadataStore = null,
+      onSessionMetadataWritten = null,
+      persistSessionGoal = null,
+      readSessionMetadata = null,
     } = routeDependencies;
 
     registerSettingsUtilityRoutes(app, {
@@ -164,6 +170,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       refreshOpenCodeAfterConfigChange,
       buildOpenCodeUrl,
       getOpenCodeAuthHeaders,
+      getIsExternalOpenCode,
       onSettingsPersisted: (updated, changes) => {
         if (!questionAutoDelegateRuntime) return;
         if (!Object.prototype.hasOwnProperty.call(changes ?? {}, 'questionAutoDelegateEnabled')) return;
@@ -293,6 +300,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       resolveOptionalProjectDirectory,
       refreshOpenCodeAfterConfigChange,
       clientReloadDelayMs,
+      waitForOpenCodeReady,
       getAgentSources,
       getAgentConfig,
       createAgent,
@@ -387,7 +395,35 @@ export const createFeatureRoutesRuntime = (dependencies) => {
         throw new Error('Small model service is not configured');
       });
     registerSmallModelRoutes(app, { getSmallModelService });
-    registerSessionGoalRoutes(app);
+    registerSessionGoalRoutes(app, {
+      // Reuse the index-provided store seam — do not invent a second store.
+      persistSessionGoal: typeof persistSessionGoal === 'function'
+        ? persistSessionGoal
+        : (sessionMetadataStore
+          ? async (sessionId, _directory, goal) => {
+            const metadata = await sessionMetadataStore.setSessionMetadata(sessionId, {
+              openchamber: { goal },
+            });
+            return metadata;
+          }
+          : null),
+      readSessionMetadata: typeof readSessionMetadata === 'function'
+        ? readSessionMetadata
+        : (sessionMetadataStore
+          ? (sessionId) => sessionMetadataStore.get(sessionId)
+          : null),
+      // Same arm path as PUT /api/openchamber/sessions/:id/metadata.
+      onGoalPersisted: typeof onSessionMetadataWritten === 'function'
+        ? onSessionMetadataWritten
+        : null,
+    });
+    if (sessionMetadataStore) {
+      registerSessionMetadataRoutes(app, {
+        sessionMetadataStore,
+        broadcastGlobalUiEvent,
+        onMetadataWritten: onSessionMetadataWritten,
+      });
+    }
     registerGitHubRoutes(app);
     const broadcastOpenChamberEvent = createOpenChamberEventBroadcaster({
       getOpenChamberEventClients,