@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.3

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

@@ -3,6 +3,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { mergePathValues } from './path-utils.js';
+import { PINNED_OPENCODE2_VERSION, isAcceptableOpenCode2HealthVersion, isOpenCode1xVersion } from './opencode2-pin.js';
+import { ensurePinnedOpenCode2Cli, installedOpenCode2BinaryPath, readOpenCode2BinaryVersion } from './ensure-cli.js';
 
 export const createOpenCodeEnvRuntime = (deps) => {
   const {
@@ -12,6 +14,9 @@ export const createOpenCodeEnvRuntime = (deps) => {
   } = deps;
   const runSpawnSync = typeof deps.spawnSync === 'function' ? deps.spawnSync : spawnSync;
   const resolveHomeDir = typeof deps.homedir === 'function' ? deps.homedir : () => os.homedir();
+  const ensurePinnedCli = typeof deps.ensurePinnedOpenCode2Cli === 'function'
+    ? deps.ensurePinnedOpenCode2Cli
+    : ensurePinnedOpenCode2Cli;
 
   const parseNullSeparatedEnvSnapshot = (raw) => {
     if (typeof raw !== 'string' || raw.length === 0) {
@@ -275,41 +280,20 @@ export const createOpenCodeEnvRuntime = (deps) => {
     return normalized.endsWith(`${path.sep}programs${path.sep}opencode${path.sep}opencode.exe`);
   };
 
-  const bundledOpenCodeCliCandidates = () => {
-    const names = process.platform === 'win32' ? ['opencode.exe'] : ['opencode'];
-    const roots = [
-      process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR,
-      typeof process.resourcesPath === 'string' ? path.join(process.resourcesPath, 'opencode-cli') : null,
-    ]
-      .map((value) => (typeof value === 'string' ? value.trim() : ''))
-      .filter(Boolean);
-
-    const candidates = [];
-    for (const root of roots) {
-      for (const name of names) {
-        candidates.push(path.join(root, name));
-      }
-    }
-    return candidates;
-  };
-
-  const resolveBundledOpenCodeCliPath = () => {
-    for (const candidate of bundledOpenCodeCliCandidates()) {
-      if (isExecutable(candidate) && !isWindowsOpenCodeDesktopAppPath(candidate)) {
-        return candidate;
-      }
+  const resolveInstalledOpenCodeCliPath = () => {
+    const installed = installedOpenCode2BinaryPath(PINNED_OPENCODE2_VERSION, {
+      env: process.env,
+      homedir: resolveHomeDir,
+      platform: process.platform,
+    });
+    if (isExecutable(installed) && !isWindowsOpenCodeDesktopAppPath(installed)) {
+      clearWslOpencodeResolution();
+      state.resolvedOpencodeBinarySource = 'installed';
+      return installed;
     }
     return null;
   };
 
-  const bundledOpenCodeCliFallback = () => {
-    const bundled = resolveBundledOpenCodeCliPath();
-    if (!bundled) return null;
-    clearWslOpencodeResolution();
-    state.resolvedOpencodeBinarySource = 'bundled';
-    return bundled;
-  };
-
   const clearWslOpencodeResolution = () => {
     state.useWslForOpencode = false;
     state.resolvedWslBinary = null;
@@ -330,6 +314,20 @@ export const createOpenCodeEnvRuntime = (deps) => {
     return trimmed;
   };
 
+  const acceptOpenCodeV2Candidate = (candidate, source) => {
+    if (typeof candidate !== 'string' || !candidate.trim()) return null;
+    if (!isExecutable(candidate) || isWindowsOpenCodeDesktopAppPath(candidate) || isMacOpenCodeAppBundlePath(candidate)) {
+      return null;
+    }
+    const version = readOpenCode2BinaryVersion(candidate);
+    if (!isAcceptableOpenCode2HealthVersion(version)) {
+      return null;
+    }
+    clearWslOpencodeResolution();
+    state.resolvedOpencodeBinarySource = source;
+    return candidate;
+  };
+
   const resolveOpencodeCliPath = () => {
     const explicit = [
       process.env.OPENCODE_BINARY,
@@ -341,118 +339,114 @@ export const createOpenCodeEnvRuntime = (deps) => {
       .filter(Boolean);
 
     for (const candidate of explicit) {
-      if (isExecutable(candidate) && !isWindowsOpenCodeDesktopAppPath(candidate)) {
-        clearWslOpencodeResolution();
-        state.resolvedOpencodeBinarySource = 'env';
-        return candidate;
+      if (isWindowsOpenCodeDesktopAppPath(candidate) || isMacOpenCodeAppBundlePath(candidate)) {
+        continue;
       }
+      if (!isExecutable(candidate)) continue;
+      const version = readOpenCode2BinaryVersion(candidate);
+      if (isOpenCode1xVersion(version)) {
+        // Inherited OPENCODE_BINARY often points at a still-installed 1.x.
+        // Skip it and keep looking; never overwrite that binary.
+        console.warn(`Skipping OpenCode 1.x at ${candidate} (${version}); looking for v2.`);
+        continue;
+      }
+      const accepted = acceptOpenCodeV2Candidate(candidate, 'env');
+      if (accepted) return accepted;
     }
 
-    // The bundled CLI is the LAST resort (see bundledOpenCodeCliFallback at the
-    // exit points below): a user's own OpenCode install — PATH, known install
-    // locations, or shell-resolved — must win over the pinned bundled copy.
-    const resolvedFromPath = searchPathFor('opencode');
-    if (resolvedFromPath) {
-      clearWslOpencodeResolution();
-      state.resolvedOpencodeBinarySource = 'path';
-      return resolvedFromPath;
+    // Match master: reuse a globally installed CLI. Official v2 is `opencode`;
+    // Skip 1.x binaries by version; auto-discovery uses only the official name.
+    for (const name of ['opencode']) {
+      const resolvedFromPath = searchPathFor(name);
+      const accepted = acceptOpenCodeV2Candidate(resolvedFromPath, 'path');
+      if (accepted) return accepted;
     }
 
     const home = resolveHomeDir();
-    const unixFallbacks = [
-      path.join(home, '.opencode', 'bin', 'opencode'),
-      path.join(home, '.bun', 'bin', 'opencode'),
-      path.join(home, '.local', 'bin', 'opencode'),
-      path.join(home, 'bin', 'opencode'),
-      '/opt/homebrew/bin/opencode',
-      '/usr/local/bin/opencode',
-      '/home/linuxbrew/.linuxbrew/bin/opencode',
-      '/usr/bin/opencode',
-      '/bin/opencode',
-    ];
+    const unixFallbacks = ['opencode'].flatMap((name) => [
+      path.join(home, '.opencode', 'bin', name),
+      path.join(home, '.bun', 'bin', name),
+      path.join(home, '.local', 'bin', name),
+      path.join(home, 'bin', name),
+      `/opt/homebrew/bin/${name}`,
+      `/usr/local/bin/${name}`,
+      `/home/linuxbrew/.linuxbrew/bin/${name}`,
+      `/usr/bin/${name}`,
+      `/bin/${name}`,
+    ]);
 
     const winFallbacks = (() => {
       const userProfile = process.env.USERPROFILE || home;
       const appData = process.env.APPDATA || '';
       const localAppData = process.env.LOCALAPPDATA || '';
       const programData = process.env.ProgramData || 'C:\\ProgramData';
-
       const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
-
-      return [
-        path.join(userProfile, '.opencode', 'bin', 'opencode.exe'),
-        path.join(userProfile, '.opencode', 'bin', 'opencode.cmd'),
-        path.join(appData, 'npm', 'opencode.cmd'),
-        // System-wide Node installer keeps the global npm prefix here
-        // (npm i -g opencode-ai → opencode.cmd shim).
-        path.join(programFiles, 'nodejs', 'opencode.cmd'),
-        path.join(userProfile, 'scoop', 'shims', 'opencode.exe'),
-        path.join(userProfile, 'scoop', 'shims', 'opencode.cmd'),
-        path.join(programData, 'chocolatey', 'bin', 'opencode.exe'),
-        path.join(programData, 'chocolatey', 'bin', 'opencode.cmd'),
-        path.join(userProfile, '.bun', 'bin', 'opencode.exe'),
-        path.join(userProfile, '.bun', 'bin', 'opencode.cmd'),
-      ].filter(Boolean);
+      const names = ['opencode.exe', 'opencode.cmd'];
+      const dirs = [
+        path.join(userProfile, '.opencode', 'bin'),
+        path.join(appData, 'npm'),
+        path.join(programFiles, 'nodejs'),
+        path.join(userProfile, 'scoop', 'shims'),
+        path.join(programData, 'chocolatey', 'bin'),
+        path.join(userProfile, '.bun', 'bin'),
+      ];
+      return dirs.flatMap((dir) => names.map((name) => path.join(dir, name))).filter(Boolean);
     })();
 
     const fallbacks = process.platform === 'win32' ? winFallbacks : unixFallbacks;
     for (const candidate of fallbacks) {
-      if (isExecutable(candidate)) {
-        clearWslOpencodeResolution();
-        state.resolvedOpencodeBinarySource = 'fallback';
-        return candidate;
-      }
+      const accepted = acceptOpenCodeV2Candidate(candidate, 'fallback');
+      if (accepted) return accepted;
     }
 
     if (process.platform === 'win32') {
-      try {
-        const result = runSpawnSync('where', ['opencode'], {
-          encoding: 'utf8',
-          stdio: ['ignore', 'pipe', 'pipe'],
-          windowsHide: true,
-        });
-        if (result.status === 0) {
-          const lines = (result.stdout || '')
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter(Boolean);
-          const found = lines.find((line) => isExecutable(line) && !isWindowsOpenCodeDesktopAppPath(line));
-          if (found) {
-            clearWslOpencodeResolution();
-            state.resolvedOpencodeBinarySource = 'where';
-            return found;
+      for (const name of ['opencode']) {
+        try {
+          const result = runSpawnSync('where', [name], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+          });
+          if (result.status === 0) {
+            const lines = (result.stdout || '')
+              .split(/\r?\n/)
+              .map((line) => line.trim())
+              .filter(Boolean);
+            for (const line of lines) {
+              const accepted = acceptOpenCodeV2Candidate(line, 'where');
+              if (accepted) return accepted;
+            }
           }
+        } catch {
         }
-      } catch {
       }
       // Do not auto-detect OpenCode from WSL. OpenCode sessions are keyed by
       // server-visible directories, and mixing Windows paths with WSL paths
       // creates duplicate/missing project state in the desktop app.
-      return bundledOpenCodeCliFallback();
+      return resolveInstalledOpenCodeCliPath();
     }
 
     const shells = [process.env.SHELL, '/bin/zsh', '/bin/bash', '/bin/sh'].filter(Boolean);
-    for (const shell of shells) {
-      if (!isExecutable(shell)) continue;
-      try {
-        const result = runSpawnSync(shell, ['-lic', 'command -v opencode'], {
-          encoding: 'utf8',
-          stdio: ['ignore', 'pipe', 'pipe'],
-          windowsHide: true,
-        });
-        if (result.status === 0) {
-          const found = (result.stdout || '').trim().split(/\s+/).pop() || '';
-          if (found && isExecutable(found)) {
-            clearWslOpencodeResolution();
-            state.resolvedOpencodeBinarySource = 'shell';
-            return found;
+    for (const name of ['opencode']) {
+      for (const shell of shells) {
+        if (!isExecutable(shell)) continue;
+        try {
+          const result = runSpawnSync(shell, ['-lic', `command -v ${name}`], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+          });
+          if (result.status === 0) {
+            const found = (result.stdout || '').trim().split(/\s+/).pop() || '';
+            const accepted = acceptOpenCodeV2Candidate(found, 'shell');
+            if (accepted) return accepted;
           }
+        } catch {
         }
-      } catch {
       }
     }
 
-    return bundledOpenCodeCliFallback();
+    return resolveInstalledOpenCodeCliPath();
   };
 
   const resolveNodeCliPath = () => {
@@ -912,7 +906,7 @@ export const createOpenCodeEnvRuntime = (deps) => {
   const createConfiguredOpencodeBinaryError = (raw, normalized) => {
     const configured = typeof raw === 'string' ? raw.trim() : '';
     const candidate = typeof normalized === 'string' && normalized.trim().length > 0 ? normalized.trim() : configured;
-    const messageSuffix = 'OpenChamber needs the standalone opencode CLI. Install it and set settings.opencodeBinary to the CLI path, for example ~/.opencode/bin/opencode, or leave the setting empty to use PATH lookup.';
+    const messageSuffix = 'OpenChamber needs the standalone OpenCode v2 CLI (`opencode`). Install it and set settings.opencodeBinary to the CLI path, for example ~/.opencode/bin/opencode, or leave the setting empty to use PATH lookup.';
     const error = (() => {
       if (isKnownOpenCodeDesktopAppPath(candidate) || isKnownOpenCodeDesktopAppPath(configured)) {
         const platformName = process.platform === 'win32' ? 'Windows desktop app install' : 'macOS desktop app bundle';
@@ -1013,6 +1007,22 @@ export const createOpenCodeEnvRuntime = (deps) => {
         return null;
       }
 
+      if (normalized && isKnownOpenCodeDesktopAppPath(normalized)) {
+        if (strict) {
+          throw createConfiguredOpencodeBinaryError(raw, normalized);
+        }
+        console.warn(`Configured settings.opencodeBinary points at a desktop app, not the CLI: ${normalized}`);
+        return null;
+      }
+
+      if (normalized && isExecutable(normalized)) {
+        const version = readOpenCode2BinaryVersion(normalized);
+        if (isOpenCode1xVersion(version)) {
+          console.warn(`Skipping configured OpenCode 1.x at ${normalized} (${version}); looking for v2.`);
+          return null;
+        }
+      }
+
       if (normalized && isExecutable(normalized) && !isKnownOpenCodeDesktopAppPath(normalized)) {
         clearWslOpencodeResolution();
         process.env.OPENCODE_BINARY = normalized;
@@ -1043,12 +1053,16 @@ export const createOpenCodeEnvRuntime = (deps) => {
       if (state.useWslForOpencode) {
         return state.resolvedOpencodeBinary;
       }
+      process.env.OPENCODE_BINARY = state.resolvedOpencodeBinary;
       ensureOpencodeShimRuntime(state.resolvedOpencodeBinary);
       return state.resolvedOpencodeBinary;
     }
 
     const existing = typeof process.env.OPENCODE_BINARY === 'string' ? process.env.OPENCODE_BINARY.trim() : '';
-    if (existing && isExecutable(existing)) {
+    if (existing && isExecutable(existing) && isOpenCode1xVersion(readOpenCode2BinaryVersion(existing))) {
+      console.warn(`Ignoring OpenCode 1.x OPENCODE_BINARY at ${existing}; looking for v2.`);
+      delete process.env.OPENCODE_BINARY;
+    } else if (existing && isExecutable(existing)) {
       clearWslOpencodeResolution();
       state.resolvedOpencodeBinary = existing;
       state.resolvedOpencodeBinarySource = state.resolvedOpencodeBinarySource || 'env';
@@ -1079,6 +1093,67 @@ export const createOpenCodeEnvRuntime = (deps) => {
     return null;
   };
 
+  // Last-resort only: used after pin install fails. Never consulted by resolveOpencodeCliPath.
+  const resolveBundledOpenCodeCliPath = () => {
+    const dirs = [];
+    const envDir = typeof process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR === 'string'
+      ? process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR.trim()
+      : '';
+    if (envDir) {
+      dirs.push(envDir);
+    }
+    if (typeof process.resourcesPath === 'string' && process.resourcesPath.trim()) {
+      dirs.push(path.join(process.resourcesPath, 'opencode-cli'));
+    }
+
+    // Runtime and packaging use the official v2 executable name.
+    const names = ['opencode', 'opencode.exe'];
+    for (const dir of dirs) {
+      for (const name of names) {
+        const accepted = acceptOpenCodeV2Candidate(path.join(dir, name), 'bundled');
+        if (accepted) {
+          return accepted;
+        }
+      }
+    }
+    return null;
+  };
+
+  const ensurePinnedOpenCode2CliEnv = async (options = {}) => {
+    const discovered = state.resolvedOpencodeBinary || resolveOpencodeCliPath();
+    const source = state.resolvedOpencodeBinarySource;
+    const explicit = source === 'env' || source === 'settings';
+    try {
+      const result = await ensurePinnedCli({
+        discoveredPath: discovered,
+        preferDiscovered: explicit,
+        env: process.env,
+        homedir: resolveHomeDir,
+        ...options,
+      });
+      if (!result?.path) {
+        return ensureOpencodeCliEnv();
+      }
+      if (result.path) {
+        clearWslOpencodeResolution();
+        process.env.OPENCODE_BINARY = result.path;
+        state.resolvedOpencodeBinary = result.path;
+        state.resolvedOpencodeBinarySource = result.source === 'installed' ? 'installed' : (state.resolvedOpencodeBinarySource || 'discovered');
+      }
+      return ensureOpencodeCliEnv();
+    } catch (error) {
+      const bundled = resolveBundledOpenCodeCliPath();
+      if (!bundled) {
+        throw error;
+      }
+      clearWslOpencodeResolution();
+      process.env.OPENCODE_BINARY = bundled;
+      state.resolvedOpencodeBinary = bundled;
+      state.resolvedOpencodeBinarySource = 'bundled';
+      return ensureOpencodeCliEnv();
+    }
+  };
+
   const resolveGitBinaryForSpawn = () => {
     if (process.platform !== 'win32') {
       return 'git';
@@ -1159,9 +1234,30 @@ export const createOpenCodeEnvRuntime = (deps) => {
     state.resolvedOpencodeBinary = null;
   };
 
+  /**
+   * Pin managed launch to an explicit binary for the duration of an owned-cache
+   * upgrade (ticket 12). Avoids rediscovery that would re-attach a global CLI.
+   */
+  const forceResolvedOpenCodeBinary = (binaryPath, source = 'installed') => {
+    const trimmed = typeof binaryPath === 'string' ? binaryPath.trim() : '';
+    if (!trimmed) {
+      const error = new Error('forceResolvedOpenCodeBinary requires a binary path');
+      error.code = 'OPENCODE_BINARY_INVALID';
+      throw error;
+    }
+    clearWslOpencodeResolution();
+    process.env.OPENCODE_BINARY = trimmed;
+    state.resolvedOpencodeBinary = trimmed;
+    state.resolvedOpencodeBinarySource = source || 'installed';
+    prependToPath(path.dirname(trimmed));
+    ensureOpencodeShimRuntime(trimmed);
+    return trimmed;
+  };
+
   return {
     applyLoginShellEnvSnapshot,
     ensureOpencodeCliEnv,
+    ensurePinnedOpenCode2CliEnv,
     applyOpencodeBinaryFromSettings,
     getLoginShellEnvSnapshot,
     resolveOpencodeCliPath,
@@ -1170,5 +1266,6 @@ export const createOpenCodeEnvRuntime = (deps) => {
     searchPathFor,
     resolveGitBinaryForSpawn,
     clearResolvedOpenCodeBinary,
+    forceResolvedOpenCodeBinary,
   };
 };