@vantran-se/openchamber-web 1.24.3 → 2.0.1

package/server/lib/opencode/credential-db.test.js

@@ -0,0 +1,104 @@
+import { describe, expect, it, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+import { projectCredentialValue, readCredentialsFromDb, resolveCredentialDbPath } from './credential-db.js';
+
+const sqlite = (() => {
+  try {
+    return createRequire(import.meta.url)('node:sqlite');
+  } catch {
+    return null;
+  }
+})();
+
+const seed = (dbPath, rows) => {
+  const db = new sqlite.DatabaseSync(dbPath);
+  db.exec(
+    'CREATE TABLE credential (id TEXT PRIMARY KEY, integration_id TEXT, label TEXT NOT NULL, value TEXT NOT NULL, ' +
+      'connector_id TEXT, method_id TEXT, active INTEGER, time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL)',
+  );
+  const insert = db.prepare(
+    'INSERT INTO credential (id, integration_id, label, value, active, time_created, time_updated) VALUES (?, ?, ?, ?, ?, ?, ?)',
+  );
+  for (const row of rows) {
+    insert.run(row.id, row.integration, row.label ?? 'default', JSON.stringify(row.value), row.active ?? null, row.time ?? 1, row.time ?? 1);
+  }
+  db.close();
+};
+
+describe('projectCredentialValue', () => {
+  it('maps a stored key to the legacy api entry', () => {
+    expect(projectCredentialValue({ type: 'key', key: 'sk-1', metadata: { region: 'eu' } })).toEqual({
+      type: 'api',
+      key: 'sk-1',
+      metadata: { region: 'eu' },
+    });
+  });
+
+  it('maps a stored oauth credential, including the account and enterprise fields', () => {
+    expect(
+      projectCredentialValue({
+        type: 'oauth',
+        methodID: 'chatgpt-browser',
+        access: 'a',
+        refresh: 'r',
+        expires: 42,
+        metadata: { accountID: 'acc', enterpriseUrl: 'https://ghe.example' },
+      }),
+    ).toEqual({ type: 'oauth', access: 'a', refresh: 'r', expires: 42, accountId: 'acc', enterpriseUrl: 'https://ghe.example' });
+  });
+
+  it('rejects shapes it does not understand instead of guessing', () => {
+    expect(projectCredentialValue('not json')).toBeNull();
+    expect(projectCredentialValue({ type: 'oauth', access: 'a' })).toBeNull();
+    expect(projectCredentialValue({ type: 'something-new', key: 'x' })).toBeNull();
+  });
+});
+
+describe('resolveCredentialDbPath', () => {
+  it('defaults to opencode.db in the data dir and honours OPENCODE_DB', () => {
+    expect(resolveCredentialDbPath({ dataDir: '/data', env: {}, path })).toBe(path.join('/data', 'opencode.db'));
+    expect(resolveCredentialDbPath({ dataDir: '/data', env: { OPENCODE_DB: 'other.db' }, path })).toBe(path.resolve('/data', 'other.db'));
+    expect(resolveCredentialDbPath({ dataDir: '/data', env: { OPENCODE_DB: '/abs/x.db' }, path })).toBe(path.resolve('/abs/x.db'));
+  });
+});
+
+describe.skipIf(!sqlite)('readCredentialsFromDb', () => {
+  let dir;
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-cred-'));
+  });
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('returns null when there is no database, so the caller can fall back', () => {
+    expect(readCredentialsFromDb({ dbPath: path.join(dir, 'opencode.db'), fs })).toBeNull();
+  });
+
+  it('picks the active credential per integration, else the newest one', () => {
+    const dbPath = path.join(dir, 'opencode.db');
+    seed(dbPath, [
+      { id: 'c1', integration: 'openai', value: { type: 'oauth', access: 'old', refresh: 'r1', expires: 1 }, active: 0, time: 5 },
+      { id: 'c2', integration: 'openai', value: { type: 'oauth', access: 'new', refresh: 'r2', expires: 2 }, active: 1, time: 2 },
+      { id: 'c3', integration: 'opencode-go', value: { type: 'key', key: 'go-old' }, time: 1 },
+      { id: 'c4', integration: 'opencode-go', value: { type: 'key', key: 'go-new' }, time: 9 },
+      { id: 'c5', integration: 'weird', value: { type: 'future' }, time: 1 },
+    ]);
+    expect(readCredentialsFromDb({ dbPath, fs })).toEqual({
+      openai: { type: 'oauth', access: 'new', refresh: 'r2', expires: 2 },
+      'opencode-go': { type: 'api', key: 'go-new' },
+    });
+  });
+
+  it('returns null rather than throwing when the schema is not what it expects', () => {
+    const dbPath = path.join(dir, 'opencode.db');
+    const db = new sqlite.DatabaseSync(dbPath);
+    db.exec('CREATE TABLE credential (id TEXT PRIMARY KEY)');
+    db.close();
+    expect(readCredentialsFromDb({ dbPath, fs })).toBeNull();
+  });
+});

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

@@ -18,6 +18,9 @@ export const createOpenCodeEnvRuntime = (deps) => {
     readSettingsFromDiskMigrated,
   } = deps;
   const runSpawnSync = typeof deps.spawnSync === 'function' ? deps.spawnSync : spawnSync;
+  const readProvidedLoginShellEnvSnapshot = typeof deps.providedLoginShellEnvSnapshot === 'function'
+    ? deps.providedLoginShellEnvSnapshot
+    : () => undefined;
   const resolveHomeDir = typeof deps.homedir === 'function' ? deps.homedir : () => os.homedir();
 
   const parseNullSeparatedEnvSnapshot = (raw) => {
@@ -195,6 +198,14 @@ export const createOpenCodeEnvRuntime = (deps) => {
       return state.cachedLoginShellEnvSnapshot;
     }
 
+    // An embedding host (Desktop) that already probed the login shell hands
+    // its snapshot over; see login-shell-env.js.
+    const provided = readProvidedLoginShellEnvSnapshot();
+    if (provided !== undefined) {
+      state.cachedLoginShellEnvSnapshot = provided;
+      return provided;
+    }
+
     if (process.platform === 'win32') {
       const windowsSnapshot = getWindowsShellEnvSnapshot();
       state.cachedLoginShellEnvSnapshot = windowsSnapshot;
@@ -678,6 +689,14 @@ export const createOpenCodeEnvRuntime = (deps) => {
     return isExecutable(trimmed) ? trimmed : null;
   };
 
+  // OpenCode 2.x platform packages first, then the 1.x names.
+  const WINDOWS_X64_NATIVE_PACKAGES = [
+    path.join('@opencode', 'cli-windows-x64-baseline'),
+    path.join('@opencode', 'cli-windows-x64'),
+    'opencode-windows-x64-baseline',
+    'opencode-windows-x64',
+  ];
+
   const getWindowsNativeOpencodePackageNames = () => {
     // TEMPORARY WORKAROUND — Windows ARM64: native opencode.exe fails with a Bun
     // FFI/TinyCC dlopen error (https://github.com/anomalyco/opencode/issues/19130).
@@ -686,31 +705,41 @@ export const createOpenCodeEnvRuntime = (deps) => {
     // arm64 branch below when the upstream issue is resolved.
     if (process.arch === 'arm64') {
       // --- ORIGINAL (restore when ARM64 is fixed) ---
-      // return ['opencode-windows-arm64'];
-      return ['opencode-windows-x64-baseline', 'opencode-windows-x64'];
+      // return ['@opencode/cli-windows-arm64', 'opencode-windows-arm64'];
+      return WINDOWS_X64_NATIVE_PACKAGES;
     }
     if (process.arch === 'x64') {
       // Prefer the baseline build when bypassing package-manager wrappers so the
       // direct binary still runs on hosts without AVX2 support.
-      return ['opencode-windows-x64-baseline', 'opencode-windows-x64'];
+      return WINDOWS_X64_NATIVE_PACKAGES;
     }
     return [];
   };
 
+  // An npm-installed OpenCode lives under one of these package directories:
+  // `@opencode/cli` (OpenCode 2.x) or `opencode-ai` (1.x). Both ship a
+  // `bin/opencode.exe` that postinstall replaces with the platform binary from
+  // the matching optional dependency (`@opencode/cli-windows-x64` or
+  // `opencode-windows-x64`).
+  const OPENCODE_NPM_PACKAGE_DIRS = [path.join('@opencode', 'cli'), 'opencode-ai'];
+
   const resolveNativeOpencodeBinaryFromNodeModules = (nodeModulesDir) => {
     if (typeof nodeModulesDir !== 'string' || nodeModulesDir.trim().length === 0) {
       return null;
     }
 
-    const packageShim = path.join(nodeModulesDir, 'opencode-ai', 'bin', 'opencode.exe');
-    if (isExecutable(packageShim)) {
-      return packageShim;
+    for (const packageDir of OPENCODE_NPM_PACKAGE_DIRS) {
+      const packageShim = path.join(nodeModulesDir, packageDir, 'bin', 'opencode.exe');
+      if (isExecutable(packageShim)) {
+        return packageShim;
+      }
     }
 
     for (const packageName of getWindowsNativeOpencodePackageNames()) {
       const candidates = [
         path.join(nodeModulesDir, packageName, 'bin', 'opencode.exe'),
-        path.join(nodeModulesDir, 'opencode-ai', 'node_modules', packageName, 'bin', 'opencode.exe'),
+        ...OPENCODE_NPM_PACKAGE_DIRS.map((packageDir) =>
+          path.join(nodeModulesDir, packageDir, 'node_modules', packageName, 'bin', 'opencode.exe')),
       ];
       for (const candidate of candidates) {
         if (isExecutable(candidate)) {
@@ -747,13 +776,18 @@ export const createOpenCodeEnvRuntime = (deps) => {
 
     try {
       const content = fs.readFileSync(wrapperPath, 'utf8');
-      const launcherMatch = content.match(/node_modules[\\/]+opencode-ai[\\/]+bin[\\/]+opencode/i);
+      const launcherMatch = content.match(/node_modules[\\/]+(?:@opencode[\\/]+cli|opencode-ai)[\\/]+bin[\\/]+opencode/i);
       if (!launcherMatch) {
         return null;
       }
 
       const launcherPath = path.resolve(path.dirname(wrapperPath), launcherMatch[0].replace(/[\\/]+/g, path.sep));
-      return path.dirname(path.dirname(path.dirname(launcherPath)));
+      // Walk back up to `node_modules`: past `bin`, the package directory and,
+      // for the scoped 2.x package, its scope.
+      const depth = /[\\/]@opencode[\\/]/i.test(launcherMatch[0]) ? 4 : 3;
+      let nodeModulesDir = launcherPath;
+      for (let index = 0; index < depth; index += 1) nodeModulesDir = path.dirname(nodeModulesDir);
+      return nodeModulesDir;
     } catch {
       return null;
     }
@@ -793,6 +827,11 @@ export const createOpenCodeEnvRuntime = (deps) => {
       pushCandidate(path.dirname(path.dirname(fileDir)));
     }
 
+    if (lower.endsWith(`${path.sep}node_modules${path.sep}@opencode${path.sep}cli${path.sep}bin${path.sep}opencode`)
+      || lower.endsWith(`${path.sep}node_modules${path.sep}@opencode${path.sep}cli${path.sep}bin${path.sep}opencode.exe`)) {
+      pushCandidate(path.dirname(path.dirname(path.dirname(fileDir))));
+    }
+
     if (path.basename(fileDir).toLowerCase() === 'npm') {
       pushCandidate(path.join(fileDir, 'node_modules'));
     }

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

@@ -115,6 +115,7 @@ const createRuntime = (settings, options = {}) => {
     readSettingsFromDiskMigrated: async () => settings,
     spawnSync: options.spawnSync,
     homedir: options.homedir,
+    providedLoginShellEnvSnapshot: options.providedLoginShellEnvSnapshot,
   });
 
   return { runtime, state };
@@ -225,6 +226,33 @@ describe('OpenCode env runtime', () => {
     }
   });
 
+  it('uses a login-shell snapshot provided by the host instead of probing the shell', () => {
+    let probes = 0;
+    const spawnSyncSpy = () => { probes += 1; return { status: 0, stdout: 'PATH=/from/probe\0' }; };
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: spawnSyncSpy,
+      providedLoginShellEnvSnapshot: () => ({ PATH: '/from/host' }),
+    });
+    state.cachedLoginShellEnvSnapshot = undefined;
+
+    expect(runtime.getLoginShellEnvSnapshot()).toEqual({ PATH: '/from/host' });
+    expect(state.cachedLoginShellEnvSnapshot).toEqual({ PATH: '/from/host' });
+    expect(probes).toBe(0);
+  });
+
+  it('does not probe the shell when the host provided an empty snapshot', () => {
+    let probes = 0;
+    const spawnSyncSpy = () => { probes += 1; return { status: 0, stdout: 'PATH=/from/probe\0' }; };
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: spawnSyncSpy,
+      providedLoginShellEnvSnapshot: () => null,
+    });
+    state.cachedLoginShellEnvSnapshot = undefined;
+
+    expect(runtime.getLoginShellEnvSnapshot()).toBeNull();
+    expect(probes).toBe(0);
+  });
+
   it('clears AppImage ARGV0 even when no login-shell snapshot is available', () => {
     const previousArgv0 = process.env.ARGV0;
     process.env.ARGV0 = '/path/to/OpenChamber.AppImage';
@@ -528,6 +556,23 @@ describe('OpenCode env runtime', () => {
     });
   });
 
+  it('resolves an npm-installed OpenCode 2.x cmd shim to its packaged Windows executable', () => {
+    setPlatform('win32');
+    const npmDir = createTempDir('openchamber-opencode-npm-v2-');
+    const shim = path.join(npmDir, 'opencode.cmd');
+    const nativeBinary = path.join(npmDir, 'node_modules', '@opencode', 'cli', 'bin', 'opencode.exe');
+    fs.mkdirSync(path.dirname(nativeBinary), { recursive: true });
+    fs.writeFileSync(nativeBinary, '');
+    fs.writeFileSync(shim, '@ECHO off\r\n"%dp0%\\node_modules\\@opencode\\cli\\bin\\opencode.exe" %*\r\n');
+    const { runtime } = createRuntime({});
+
+    expect(runtime.resolveManagedOpenCodeLaunchSpec(shim)).toEqual({
+      binary: nativeBinary,
+      args: [],
+      wrapperType: 'native-wrapper',
+    });
+  });
+
   it('resolves npm OpenCode cmd shims to the packaged Windows executable', () => {
     setPlatform('win32');
     const npmDir = createTempDir('openchamber-opencode-npm-');

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

@@ -32,8 +32,8 @@ import { getNpmInfo, clearCache as clearNpmCache } from './npm-registry.js';
 import { parseNpmSpec, parsePathSpec, isExactSemver } from './plugin-spec.js';
 import { registerOpenCodeRoutes } from './routes.js';
 import { getProviderSources, removeProviderConfig, upsertProviderConfig } from './providers.js';
-import { getAgentSources, getAgentConfig, createAgent, updateAgent, deleteAgent } from './agents.js';
-import { getCommandSources, createCommand, updateCommand, deleteCommand } from './commands.js';
+import { getAgentSources, getAgentConfig, getAgentPermissions, createAgent, updateAgent, deleteAgent } from './agents.js';
+import { getCommandSources, getCommandConfig, createCommand, updateCommand, deleteCommand } from './commands.js';
 import { listMcpConfigs, getMcpConfig, createMcpConfig, updateMcpConfig, deleteMcpConfig } from './mcp.js';
 import { listSnippets, getSnippet, createSnippet, updateSnippet, deleteSnippet, expandSnippets } from './snippets.js';
 import {
@@ -86,7 +86,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
         import('../walkthrough/index.js'),
         import('../walkthrough/pull-request.js'),
       ]);
-      walkthroughService = { ...service, getPullRequestDiff: pullRequest.getPullRequestDiff };
+      walkthroughService = { ...service, getPullRequestDiff: pullRequest.getPullRequestDiff, getPullRequestFileContents: pullRequest.getPullRequestFileContents };
     }
     return walkthroughService;
   };
@@ -102,6 +102,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       resolveGitBinaryForSpawn,
       createFsSearchRuntime,
       openchamberDataDir,
+      onGuestDeactivated,
       openchamberUserConfigRoot,
       managedChatsRoot,
       normalizeDirectoryPath,
@@ -114,6 +115,9 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       refreshOpenCodeAfterConfigChange,
       getOpenCodeResolutionSnapshot,
       getOpenCodeUpgradeCapability,
+      upgradeOpenCodeCli,
+      getOpenCodeCompatibility,
+      installOpenCodeV2,
       formatSettingsResponse,
       readSettingsFromDisk,
       readSettingsFromDiskMigrated,
@@ -157,7 +161,8 @@ export const createFeatureRoutesRuntime = (dependencies) => {
     registerPermissionAutoAcceptRoutes(app, permissionAutoAcceptRuntime);
     registerMessageQueueRoutes(app, messageQueueRuntime);
     registerRoutingRoutes(app, routingRuntime);
-    // Before the generic OpenCode proxy: turns `openchamber/auto` into a real model.
+    // Before the generic OpenCode proxy: swallows the `openchamber/auto` model
+    // switch and routes the sends that follow it.
     registerRoutingPromptRewrite(app, routingRuntime);
 
     registerOpenCodeRoutes(app, {
@@ -165,6 +170,9 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       clientReloadDelayMs,
       getOpenCodeResolutionSnapshot,
       getOpenCodeUpgradeCapability,
+      upgradeOpenCodeCli,
+      getOpenCodeCompatibility,
+      installOpenCodeV2,
       formatSettingsResponse,
       readSettingsFromDisk,
       readSettingsFromDiskMigrated,
@@ -233,10 +241,12 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       clientReloadDelayMs,
       getAgentSources,
       getAgentConfig,
+      getAgentPermissions,
       createAgent,
       updateAgent,
       deleteAgent,
       getCommandSources,
+      getCommandConfig,
       createCommand,
       updateCommand,
       deleteCommand,
@@ -321,7 +331,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
     registerGitHubRoutes(app);
     registerLinearRoutes(app);
     await registerBuiltInGuests({ persistPath: extensionsPersistPath(openchamberDataDir), root: routeDependencies.builtInExtensionsDir });
-    registerGuestRoutes(app, { openchamberDataDir, openchamberVersion, resolveGitBinaryForSpawn, resolveOptionalProjectDirectory, getSmallModelService });
+    registerGuestRoutes(app, { openchamberDataDir, openchamberVersion, resolveGitBinaryForSpawn, resolveOptionalProjectDirectory, getSmallModelService, onGuestDeactivated });
     registerGitRoutes(app, {
       emitWorktreeChanged: ({ directories, at }) => {
         const clients = getOpenChamberEventClients();

package/server/lib/opencode/lifecycle-process.test.js

@@ -12,6 +12,7 @@ const createRuntime = (waitForReady, state) => createOpenCodeLifecycleRuntime({
   state,
   env: { ENV_CONFIGURED_OPENCODE_PORT: 45678, ENV_CONFIGURED_OPENCODE_HOSTNAME: '127.0.0.1' },
   syncToHmrState() {}, syncFromHmrState() {},
+  checkOpenCodeBinary: async () => '2.0.14',
   ensureOpencodeCliEnv: () => process.execPath,
   applyOpencodeBinaryFromSettings: async () => {},
   ensureLocalOpenCodeServerPassword: async () => 'fixture-only',
@@ -30,8 +31,10 @@ describe('managed process lifecycle with real children', () => {
       process.env.OPENCHAMBER_MANAGED_PROCESS_REGISTRY = path.join(root, 'registry');
       const marker = path.join(root, 'pids');
       const childScript = `process.on('SIGTERM', () => {}); require('node:fs').appendFileSync(${JSON.stringify(marker)}, process.pid + '\\n'); process.stdout.write('ready\\n'); setInterval(() => {}, 1000);`;
-      let readinessMessage = 'opencode server listening on http://127.0.0.1:45678\n';
-      if (failure === 'invalid-readiness') readinessMessage = 'opencode server listening without a URL\n';
+      let readinessMessage = 'server listening on http://127.0.0.1:45678\n';
+      // A line that looks like the readiness line but carries no URL is noise,
+      // not readiness: the start must time out rather than connect to nothing.
+      if (failure === 'invalid-readiness') readinessMessage = 'server listening without a URL\n';
       if (failure === 'startup-timeout' || failure === 'shutdown-during-startup') readinessMessage = '';
       // Node is an isolated stand-in for the native OpenCode binary. Lifecycle
       // still launches its real `serve --hostname ... --port ...` command.
@@ -60,10 +63,10 @@ describe('managed process lifecycle with real children', () => {
           state.isShuttingDown = true;
           await state.openCodeProcess.close();
           await rejected;
-        } else if (failure === 'startup-timeout') {
+        } else if (failure === 'startup-timeout' || failure === 'invalid-readiness') {
           await expect(runtime.startOpenCode()).rejects.toThrow('Timeout waiting for OpenCode');
         } else {
-          await expect(runtime.startOpenCode()).rejects.toThrow(failure === 'health-error' ? 'fixture health failure' : 'Failed to parse server url');
+          await expect(runtime.startOpenCode()).rejects.toThrow('fixture health failure');
         }
         const pids = (await fs.readFile(marker, 'utf8')).trim().split('\n').map(Number);
         expect(pids).toHaveLength(failure === 'none' || failure === 'shutdown-during-startup' ? 2 : 4);

package/server/lib/opencode/lifecycle.js

@@ -1,9 +1,11 @@
+import { readOpenCodeInfo, isSupportedOpenCodeVersion, requireOpenCodeV2, UnsupportedOpenCodeVersionError } from './compatibility.js';
 import { spawn, spawnSync } from 'node:child_process';
 import net from 'node:net';
 import { stripAppImageArgv0Leak } from '../inherited-env.js';
 import { registerManagedProcess, unregisterManagedProcess, reapOrphanedProcesses } from './managed-process-registry.js';
 import { applyProviderEnvAliases } from './provider-env-aliases.js';
 import { recordStartupPerformance } from './startup-performance.js';
+import { topUpV1Migration } from './v1-migration-topup.js';
 
 const parsePositiveInt = (value, fallback) => {
   const parsed = Number.parseInt(String(value ?? ''), 10);
@@ -17,7 +19,35 @@ const HEALTH_CHECK_MAX_CONSECUTIVE_FAILURES = parsePositiveInt(
 );
 const HEALTH_CHECK_INTERVAL_OVERRIDE_MS = parsePositiveInt(process.env.OPENCHAMBER_OPENCODE_HEALTH_INTERVAL_MS, 0);
 const HEALTH_CHECK_RESULT_CACHE_MS = parsePositiveInt(process.env.OPENCHAMBER_OPENCODE_HEALTH_CACHE_MS, 750);
-const OPENCODE_HEALTH_PATH = '/global/health';
+const OPENCODE_HEALTH_PATH = '/api/info';
+const OPENCODE_REQUIRED_MAJOR_VERSION = 2;
+
+/**
+ * OpenChamber talks to OpenCode 2.x only. v1 serves its routes without the
+ * `/api` prefix, publishes a different event vocabulary and has no `plugins`
+ * config key, so an older binary fails in a hundred small ways instead of one
+ * clear one.
+ *
+ * The version comes from the health payload rather than from `opencode
+ * --version`: it costs no extra process, and it also covers an external
+ * OpenCode the user started themselves. `/api/info` only exists in 2.x (2.0.8
+ * removed the older `/api/health`), so a 404 there is the same answer by
+ * another route. A 200 is the readiness signal; the payload has no `healthy`
+ * field, only `{ version, pid, urls, paths }`.
+ */
+const OPENCODE_VERSION_REQUIREMENT_DETAIL =
+  `OpenChamber requires OpenCode ${OPENCODE_REQUIRED_MAJOR_VERSION}.x`;
+
+const classifyOpenCodeVersion = (version) => {
+  if (typeof version !== 'string') return { ok: true };
+  const match = version.match(/v?(\d+)\./);
+  if (!match) return { ok: true };
+  if (Number(match[1]) >= OPENCODE_REQUIRED_MAJOR_VERSION) return { ok: true };
+  return {
+    ok: false,
+    detail: `${OPENCODE_VERSION_REQUIREMENT_DETAIL}, found ${version.trim()}. Update OpenCode and start OpenChamber again.`,
+  };
+};
 // Last-used directory plus the three most recently opened projects — deeper
 // tails are unlikely to be the user's first click and just add background work.
 const WARMUP_DIRECTORY_LIMIT = 4;
@@ -111,8 +141,12 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     onOpenCodeRestarted = null,
     managedStartupTimeoutMs = 30_000,
     now = Date.now,
+    topUpV1SessionMigration = topUpV1Migration,
+    checkOpenCodeBinary = requireOpenCodeV2,
   } = deps;
 
+  let managedPreflight = null;
+
   const killProcessOnPortWin32 = (port) => {
     try {
       // Get-NetTCPConnection reads the same locale-independent WinNT API
@@ -472,12 +506,10 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         stdout += chunk.toString();
         const lines = stdout.split('\n');
         for (const line of lines) {
-          if (!line.startsWith('opencode server listening')) continue;
-          const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
-          if (!match) {
-            finish(reject, new Error(`Failed to parse server url from output: ${line}`));
-            return;
-          }
+          // OpenCode 2.x prints `server listening on http://host:port` with no
+          // "opencode" prefix.
+          const match = line.match(/server listening on\s+(https?:\/\/\S+)/);
+          if (!match) continue;
           attachRuntimeStderrCapture();
           finish(resolve, match[1]);
           return;
@@ -584,7 +616,9 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
           healthy: false,
           failure: {
             class: 'invalid_response',
-            detail: `Health endpoint returned HTTP ${response.status ?? 'unknown'}`,
+            detail: response.status === 404
+              ? `${OPENCODE_VERSION_REQUIREMENT_DETAIL}: this server has no /api/info, which every 2.x server serves.`
+              : `Info endpoint returned HTTP ${response.status ?? 'unknown'}`,
           },
         };
       }
@@ -596,17 +630,15 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
           healthy: false,
           failure: {
             class: 'invalid_response',
-            detail: 'Health endpoint returned invalid JSON',
+            detail: 'Info endpoint returned invalid JSON',
           },
         };
       }
-      if (body?.healthy !== true) {
+      const version = classifyOpenCodeVersion(body?.version);
+      if (!version.ok) {
         return {
           healthy: false,
-          failure: {
-            class: 'invalid_response',
-            detail: 'Health endpoint did not report healthy=true',
-          },
+          failure: { class: 'invalid_response', detail: version.detail },
         };
       }
       return { healthy: true, failure: null };
@@ -638,9 +670,8 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         signal: controller.signal,
       });
       clearTimeout(timeout);
-      if (!response.ok) return false;
-      const body = await response.json().catch(() => null);
-      return body?.healthy === true;
+      const info = await readOpenCodeInfo(response);
+      return info !== null && isSupportedOpenCodeVersion(info.version);
     } catch {
       return false;
     }
@@ -680,6 +711,9 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
 
     await applyOpencodeBinaryFromSettings({ strict: true });
     const resolvedBinary = ensureOpencodeCliEnv();
+    const preflight = checkOpenCodeBinary(resolveManagedOpenCodeLaunchSpec(resolvedBinary));
+    managedPreflight = preflight.then(() => true, () => false);
+    await preflight;
     recordStartupPerformance('opencode.binary.ready', {
       attempt,
       durationMs: performance.now() - phaseStartedAt,
@@ -704,6 +738,18 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     });
     phaseStartedAt = performance.now();
 
+    // Re-arm OpenCode's own V1 -> V2 session import for sessions a bundled
+    // OpenCode 1.x created after the migration already completed. Only for the
+    // managed process, only while it is not running, and never fatal.
+    try {
+      const topUp = topUpV1SessionMigration();
+      if (topUp && topUp.status !== 'skipped') {
+        console.log('[OpenCode] V1 session migration top-up:', topUp);
+      }
+    } catch (error) {
+      console.warn('[OpenCode] V1 session migration top-up failed:', error instanceof Error ? error.message : error);
+    }
+
     let serverInstance;
     try {
       if (state.isShuttingDown) throw new Error('OpenCode startup cancelled during shutdown');
@@ -776,13 +822,14 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
   };
 
   const startOpenCode = async () => {
+    managedPreflight = null;
     let lastError = null;
     for (let attempt = 1; attempt <= START_OPEN_CODE_MAX_ATTEMPTS; attempt += 1) {
       try {
         return await startOpenCodeOnce(attempt);
       } catch (error) {
         lastError = error;
-        if (state.isShuttingDown || error?.code === 'OPENCODE_BINARY_INVALID') {
+        if (state.isShuttingDown || error instanceof UnsupportedOpenCodeVersionError || error?.code === 'OPENCODE_BINARY_INVALID') {
           break;
         }
         if (attempt >= START_OPEN_CODE_MAX_ATTEMPTS) {
@@ -810,6 +857,7 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     }
 
     state.currentRestartPromise = (async () => {
+      managedPreflight = null;
       state.isRestartingOpenCode = true;
       state.isOpenCodeReady = false;
       state.openCodeNotReadySince = Date.now();
@@ -937,18 +985,14 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         timeout = null;
 
         if (!response.ok) {
-          lastError = new Error(`OpenCode health endpoint responded with status ${response.status}`);
-          await new Promise((resolve) => setTimeout(resolve, intervalMs));
-          continue;
-        }
-
-        const body = await response.json().catch(() => null);
-        if (body?.healthy !== true) {
-          lastError = new Error('OpenCode health endpoint returned unhealthy response');
+          lastError = new Error(`OpenCode info endpoint responded with status ${response.status}`);
           await new Promise((resolve) => setTimeout(resolve, intervalMs));
           continue;
         }
 
+        const info = await readOpenCodeInfo(response);
+        if (!info) throw new Error('OpenCode did not return valid version information.');
+        if (!isSupportedOpenCodeVersion(info.version)) throw new UnsupportedOpenCodeVersionError(info.version);
         state.isOpenCodeReady = true;
         state.lastOpenCodeError = null;
         return;
@@ -981,14 +1025,16 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
       try {
-        const response = await fetch(buildOpenCodeUrl('/agent'), {
+        const response = await fetch(buildOpenCodeUrl('/api/agent'), {
           method: 'GET',
           headers: { Accept: 'application/json', ...getOpenCodeAuthHeaders() },
         });
 
         if (response.ok) {
-          const agents = await response.json();
-          if (Array.isArray(agents) && agents.some((agent) => agent?.name === agentName)) {
+          // OpenCode 2.x answers `/api/*` with `{ location, data }`.
+          const body = await response.json();
+          const agents = Array.isArray(body) ? body : body?.data;
+          if (Array.isArray(agents) && agents.some((agent) => agent?.id === agentName)) {
             return;
           }
         }
@@ -1155,7 +1201,10 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
       try {
         const controller = new AbortController();
         timeout = setTimeout(() => controller.abort(), WARMUP_REQUEST_TIMEOUT_MS);
-        const url = `${buildOpenCodeUrl('/session/status', '')}?directory=${encodeURIComponent(directory)}`;
+        // Warming a directory is the point, not the answer: any directory-scoped
+        // read makes OpenCode initialise it. `/api/session` is the cheapest one
+        // that takes a directory (`/api/session/active` is global).
+        const url = `${buildOpenCodeUrl('/api/session', '')}?directory=${encodeURIComponent(directory)}&limit=1`;
         await fetch(url, {
           method: 'GET',
           headers: { Accept: 'application/json', ...getOpenCodeAuthHeaders() },
@@ -1321,6 +1370,12 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
   };
 
   return {
+    getManagedOpenCodePreflight: async () => {
+      const preflight = managedPreflight;
+      if (!preflight || state.isExternalOpenCode || state.isShuttingDown) return false;
+      const compatible = await preflight;
+      return compatible && preflight === managedPreflight && !state.isExternalOpenCode && !state.isShuttingDown;
+    },
     killProcessOnPort,
     startOpenCode,
     restartOpenCode,