@vantran-se/openchamber-web 1.24.3 → 2.0.1

package/server/lib/opencode/v2-install.js

@@ -0,0 +1,158 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { z } from 'zod';
+import { requireOpenCodeV2 } from './compatibility.js';
+
+const INSTALL_TIMEOUT_MS = 5 * 60_000;
+const NPM_REGISTRY = 'https://registry.npmjs.org';
+
+const releaseSchema = z.object({ version: z.string().regex(/^2\.\d+\.\d+$/) });
+const packageDistSchema = z.object({
+  dist: z.object({
+    tarball: z.string().url(),
+    integrity: z.string().regex(/^sha512-[A-Za-z0-9+/]+={0,2}$/),
+  }),
+});
+
+// OpenCode's installer is a bash script, so Windows installs the npm platform
+// package that script downloads. x64-baseline serves arm64 too: the native arm64
+// build fails to load (https://github.com/anomalyco/opencode/issues/19130), the
+// same workaround the desktop bundle uses in packages/electron/scripts/prepare-opencode-cli.mjs.
+const WINDOWS_PACKAGE = '@opencode/cli-windows-x64-baseline';
+
+export const supportsOpenCodeV2Install = (platform = process.platform) =>
+  (platform === 'darwin' || platform === 'linux' || platform === 'win32') && (process.arch === 'x64' || process.arch === 'arm64');
+
+const runInstaller = (script, version, env) => new Promise((resolve, reject) => {
+  const child = spawn('/bin/bash', [script, '--version', version, '--no-modify-path'], {
+    env, cwd: os.tmpdir(), detached: true, stdio: 'ignore',
+  });
+  const terminate = () => {
+    if (!child.pid) return;
+    try { process.kill(-child.pid, 'SIGKILL'); } catch { /* Already exited. */ }
+  };
+  const timer = setTimeout(terminate, INSTALL_TIMEOUT_MS);
+  child.once('error', () => {
+    clearTimeout(timer);
+    reject(new Error('Could not start the OpenCode installer.'));
+  });
+  child.once('close', (code) => {
+    clearTimeout(timer);
+    terminate();
+    // Installer output may contain environment or registry secrets.
+    if (code === 0) resolve();
+    else reject(new Error('OpenCode installation failed. Try the official installation guide.'));
+  });
+});
+
+const extractArchive = (tarCommand, archive, destination) => new Promise((resolve, reject) => {
+  const child = spawn(tarCommand, ['-xzf', archive, '-C', destination], {
+    stdio: 'ignore', windowsHide: true, timeout: INSTALL_TIMEOUT_MS,
+  });
+  child.once('error', () => reject(new Error('Could not unpack the OpenCode package.')));
+  child.once('close', (code) => {
+    if (code === 0) resolve();
+    else reject(new Error('Could not unpack the OpenCode package.'));
+  });
+});
+
+/** Downloads and runs the official installer script. Returns the step that replaces the binary. */
+const prepareInstallerScript = async ({ version, workDirectory, env, fetchImpl }) => {
+  const response = await fetchImpl('https://opencode.ai/v2/install', { signal: AbortSignal.timeout(15_000) });
+  if (!response.ok) throw new Error('Could not download the OpenCode installer.');
+  const script = path.join(workDirectory, 'install.sh');
+  await fs.writeFile(script, await response.text(), { mode: 0o600 });
+  return () => runInstaller(script, version, env);
+};
+
+/**
+ * Downloads the Windows platform package, checks it against the integrity npm
+ * publishes for it, and unpacks it. Returns the step that replaces the binary.
+ */
+const prepareWindowsBinary = async ({ version, directory, workDirectory, fetchImpl, tarCommand }) => {
+  const metadataResponse = await fetchImpl(`${NPM_REGISTRY}/${WINDOWS_PACKAGE.replace('/', '%2F')}/${version}`, { signal: AbortSignal.timeout(15_000) });
+  if (!metadataResponse.ok) throw new Error('Could not resolve the OpenCode v2 package.');
+  const { dist } = packageDistSchema.parse(await metadataResponse.json());
+  if (new URL(dist.tarball).origin !== NPM_REGISTRY) throw new Error('The OpenCode v2 package is not served by the npm registry.');
+  const archiveResponse = await fetchImpl(dist.tarball, { signal: AbortSignal.timeout(INSTALL_TIMEOUT_MS) });
+  if (!archiveResponse.ok) throw new Error('Could not download the OpenCode v2 package.');
+  const archive = Buffer.from(await archiveResponse.arrayBuffer());
+  if (`sha512-${createHash('sha512').update(archive).digest('base64')}` !== dist.integrity) {
+    throw new Error('The downloaded OpenCode v2 package failed its integrity check.');
+  }
+  const archivePath = path.join(workDirectory, 'opencode.tgz');
+  const extractDirectory = path.join(workDirectory, 'extract');
+  await fs.writeFile(archivePath, archive);
+  await fs.mkdir(extractDirectory);
+  await extractArchive(tarCommand, archivePath, extractDirectory);
+  const extracted = path.join(extractDirectory, 'package', 'bin', 'opencode.exe');
+  await fs.access(extracted).catch(() => { throw new Error('The OpenCode v2 package does not contain opencode.exe.'); });
+  return () => fs.copyFile(extracted, path.join(directory, 'opencode.exe'));
+};
+
+// Only host-owned callers supply these options. No request body controls a
+// command, URL, version, destination, or environment.
+export const installOpenCodeV2 = async ({
+  homeDirectory = os.homedir(),
+  env = process.env,
+  fetchImpl = fetch,
+  platform = process.platform,
+  // Windows' own bsdtar. Git Bash's GNU tar on PATH reads `C:\...` as a remote host.
+  tarCommand = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'tar.exe'),
+} = {}) => {
+  if (!supportsOpenCodeV2Install(platform)) throw new Error('Automatic OpenCode v2 installation is unavailable on this platform.');
+  const windows = platform === 'win32';
+  const binaryNames = windows ? ['opencode.exe'] : ['opencode', 'opencode2'];
+  const directory = path.join(homeDirectory, '.opencode', 'bin');
+  await fs.mkdir(directory, { recursive: true });
+  const lock = path.join(directory, '.openchamber-install');
+  // Also serializes separate OpenChamber/VS Code processes sharing this home.
+  await fs.mkdir(lock).catch(() => { throw new Error('Another OpenCode installation is already in progress.'); });
+  const snapshots = [];
+  let started = false;
+  let cleanup = true;
+  try {
+    const releaseResponse = await fetchImpl(`${NPM_REGISTRY}/@opencode%2Fcli/latest`, { signal: AbortSignal.timeout(15_000) });
+    if (!releaseResponse.ok) throw new Error('Could not resolve the OpenCode v2 release.');
+    const { version } = releaseSchema.parse(await releaseResponse.json());
+    const replaceBinary = windows
+      ? await prepareWindowsBinary({ version, directory, workDirectory: lock, fetchImpl, tarCommand })
+      : await prepareInstallerScript({ version, workDirectory: lock, env, fetchImpl });
+    for (const name of binaryNames) {
+      const target = path.join(directory, name);
+      const backup = path.join(lock, name);
+      const exists = await fs.lstat(target).then(() => true, (error) => {
+        if (error.code === 'ENOENT') return false;
+        throw error;
+      });
+      if (exists) await fs.cp(target, backup, { dereference: false, verbatimSymlinks: true });
+      snapshots.push({ target, backup, exists });
+    }
+    started = true;
+    await replaceBinary();
+    const binary = path.join(directory, binaryNames[0]);
+    const installedVersion = await requireOpenCodeV2({ binary, args: [] }, { env });
+    if (installedVersion !== version) throw new Error('The installed OpenCode version does not match the requested release.');
+    return binary;
+  } catch (error) {
+    if (started) {
+      try {
+        for (const { target, backup, exists } of snapshots) {
+          await fs.rm(target, { force: true });
+          if (exists) await fs.rename(backup, target);
+        }
+      } catch {
+        // Keep any remaining backups for manual recovery; never delete them
+        // after a failed rollback or allow another installer to overwrite them.
+        cleanup = false;
+        throw new Error('Could not restore the previous OpenCode installation. The backup remains in .opencode/bin/.openchamber-install.');
+      }
+    }
+    throw error;
+  } finally {
+    if (cleanup) await fs.rm(lock, { recursive: true, force: true });
+  }
+};

package/server/lib/opencode/v2-install.test.js

@@ -0,0 +1,124 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { installOpenCodeV2 } from './v2-install.js';
+import { readOpenCodeCliVersion } from './compatibility.js';
+
+let homeDirectory;
+let binary;
+const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+const cli = (version) => '#!/bin/sh\nprintf "%s\\n" "opencode v' + version + '"\n';
+const run = (script, version = '2.0.15') => installOpenCodeV2({
+  homeDirectory,
+  fetchImpl: async (url) => url.includes('registry.npmjs.org')
+    ? Response.json({ version })
+    : new Response(script),
+});
+
+beforeEach(async () => {
+  homeDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'oc-install-test-'));
+  binary = path.join(homeDirectory, '.opencode/bin/opencode');
+  await fs.mkdir(path.dirname(binary), { recursive: true });
+  await fs.writeFile(binary, cli('1.18.30'), { mode: 0o755 });
+});
+afterEach(async () => { await fs.rm(homeDirectory, { recursive: true, force: true }); });
+
+describe('OpenCode v2 installation', () => {
+  it('passes the validated release and verifies the actual executable', async () => {
+    const script = `#!/bin/bash
+set -eu
+test "$1" = "--version"
+test "$2" = "2.0.15"
+test "$3" = "--no-modify-path"
+printf %s ${quote(cli('2.0.15'))} > ${quote(binary)}
+chmod 755 ${quote(binary)}
+`;
+    expect(await run(script)).toBe(binary);
+    expect(await readOpenCodeCliVersion({ binary, args: [] })).toBe('2.0.15');
+    await expect(fs.stat(path.join(path.dirname(binary), '.openchamber-install'))).rejects.toMatchObject({ code: 'ENOENT' });
+  });
+
+  it('restores the binary and shim when an installer exits zero but leaves v1', async () => {
+    const shim = path.join(path.dirname(binary), 'opencode2');
+    await fs.symlink('opencode', shim);
+    const script = `printf %s broken > ${quote(shim)}\nexit 0\n`;
+    await expect(run(script)).rejects.toThrow();
+    expect(await readOpenCodeCliVersion({ binary, args: [] })).toBe('1.18.30');
+    expect(await fs.readlink(shim)).toBe('opencode');
+  });
+
+  it('restores v1 after a partial installer failure, and permits a retry', async () => {
+    const script = `printf %s broken > ${quote(binary)}\nexit 1\n`;
+    await expect(run(script)).rejects.toThrow('installation failed');
+    expect(await readOpenCodeCliVersion({ binary, args: [] })).toBe('1.18.30');
+    await expect(run(script)).rejects.toThrow('installation failed');
+  });
+
+  it('rejects a non-v2 registry release before running the installer', async () => {
+    await expect(run(`rm ${quote(binary)}`, '3.0.0')).rejects.toThrow();
+    expect(await readOpenCodeCliVersion({ binary, args: [] })).toBe('1.18.30');
+  });
+
+  describe('on Windows', () => {
+    const TARBALL = 'https://registry.npmjs.org/@opencode/cli-windows-x64-baseline/-/cli-windows-x64-baseline-2.0.15.tgz';
+    let exe;
+    const integrityOf = (bytes) => `sha512-${createHash('sha512').update(bytes).digest('base64')}`;
+    // The platform package keeps its binary at package/bin/opencode.exe. Here it is a
+    // shell script, so the version check runs it on the Linux/macOS test host.
+    const pack = async (version) => {
+      const root = await fs.mkdtemp(path.join(os.tmpdir(), 'oc-package-'));
+      await fs.mkdir(path.join(root, 'package/bin'), { recursive: true });
+      await fs.writeFile(path.join(root, 'package/bin/opencode.exe'), cli(version), { mode: 0o755 });
+      execFileSync('tar', ['-czf', path.join(root, 'package.tgz'), '-C', root, 'package']);
+      const bytes = await fs.readFile(path.join(root, 'package.tgz'));
+      await fs.rm(root, { recursive: true, force: true });
+      return bytes;
+    };
+    const runWindows = (archive, integrity = integrityOf(archive)) => installOpenCodeV2({
+      homeDirectory,
+      platform: 'win32',
+      tarCommand: 'tar',
+      fetchImpl: async (url) => {
+        if (url.endsWith('/@opencode%2Fcli/latest')) return Response.json({ version: '2.0.15' });
+        if (url.endsWith('/@opencode%2Fcli-windows-x64-baseline/2.0.15')) return Response.json({ dist: { tarball: TARBALL, integrity } });
+        if (url === TARBALL) return new Response(archive);
+        return new Response(null, { status: 404 });
+      },
+    });
+
+    beforeEach(async () => {
+      exe = path.join(homeDirectory, '.opencode/bin/opencode.exe');
+      await fs.writeFile(exe, cli('1.18.30'), { mode: 0o755 });
+    });
+
+    it('installs the verified platform package without the bash installer', async () => {
+      expect(await runWindows(await pack('2.0.15'))).toBe(exe);
+      expect(await readOpenCodeCliVersion({ binary: exe, args: [] })).toBe('2.0.15');
+      expect(await readOpenCodeCliVersion({ binary, args: [] })).toBe('1.18.30');
+      await expect(fs.stat(path.join(path.dirname(exe), '.openchamber-install'))).rejects.toMatchObject({ code: 'ENOENT' });
+    });
+
+    it('rejects a package that does not match its published integrity before touching the binary', async () => {
+      const archive = await pack('2.0.15');
+      await expect(runWindows(archive, integrityOf(Buffer.from('other')))).rejects.toThrow('integrity');
+      expect(await readOpenCodeCliVersion({ binary: exe, args: [] })).toBe('1.18.30');
+      await expect(fs.stat(path.join(path.dirname(exe), '.openchamber-install'))).rejects.toMatchObject({ code: 'ENOENT' });
+    });
+
+    it('restores the previous binary when the package holds another release', async () => {
+      await expect(runWindows(await pack('2.0.14'))).rejects.toThrow();
+      expect(await readOpenCodeCliVersion({ binary: exe, args: [] })).toBe('1.18.30');
+    });
+  });
+
+  it('does not overwrite an installation owned by another process', async () => {
+    const lock = path.join(path.dirname(binary), '.openchamber-install');
+    await fs.mkdir(lock);
+    await expect(run('exit 0')).rejects.toThrow('already in progress');
+    expect((await fs.stat(lock)).isDirectory()).toBe(true);
+    expect(await readOpenCodeCliVersion({ binary, args: [] })).toBe('1.18.30');
+  });
+});

package/server/lib/opencode/watcher.js

@@ -1,4 +1,5 @@
 import { createUpstreamSseReader } from '../event-stream/upstream-reader.js';
+import { translateWireEvent } from '../event-stream/translate-v2.js';
 
 export const createOpenCodeWatcherRuntime = (deps) => {
   const {
@@ -17,6 +18,12 @@ export const createOpenCodeWatcherRuntime = (deps) => {
   let unsubscribeEvent = null;
   let unsubscribeStatus = null;
 
+  // `onPayload` consumers speak the server's own event vocabulary, so the v2
+  // wire payload is translated here rather than in each consumer.
+  const emitTranslated = (payload) => {
+    for (const translated of translateWireEvent(payload)) onPayload(translated);
+  };
+
   const unwrapGlobalEventPayload = (eventData) => {
     if (!eventData || typeof eventData !== 'object') {
       return null;
@@ -45,7 +52,7 @@ export const createOpenCodeWatcherRuntime = (deps) => {
         if (!payload || typeof payload !== 'object') {
           return;
         }
-        onPayload(payload);
+        emitTranslated(payload);
       });
       unsubscribeStatus = globalEventHub.subscribeStatus((status) => {
         if (signal.aborted) {
@@ -65,7 +72,7 @@ export const createOpenCodeWatcherRuntime = (deps) => {
 
     reader = createUpstreamSseReader({
       signal,
-      buildUrl: () => buildOpenCodeUrl('/global/event', ''),
+      buildUrl: () => buildOpenCodeUrl('/api/event', ''),
       getHeaders: getOpenCodeAuthHeaders,
       fetchImpl,
       stallTimeoutMs: upstreamStallTimeoutMs,
@@ -78,7 +85,7 @@ export const createOpenCodeWatcherRuntime = (deps) => {
         if (!payload || typeof payload !== 'object') {
           return;
         }
-        onPayload(payload);
+        emitTranslated(payload);
       },
       onError(error) {
         if (signal.aborted) {

package/server/lib/opencode/watcher.test.js

@@ -63,7 +63,7 @@ describe('createOpenCodeWatcherRuntime', () => {
         return createSseResponse({
           signal: options.signal,
           blocks: [
-            'id: evt-1\ndata: {"directory":"/tmp/project","payload":{"type":"session.updated","properties":{"sessionID":"ses_1"}}}\n\n',
+            'data: {"directory":"/tmp/project","payload":{"id":"evt-1","type":"session.renamed","location":{"directory":"/tmp/project"},"data":{"sessionID":"ses_1","title":"New"}}}\n\n',
           ],
         });
       },
@@ -74,7 +74,7 @@ describe('createOpenCodeWatcherRuntime', () => {
 
     expect(fetchCalls).toEqual([
       {
-        url: 'http://127.0.0.1:4096/global/event',
+        url: 'http://127.0.0.1:4096/api/event',
         headers: {
           Accept: 'text/event-stream',
           'Cache-Control': 'no-cache',
@@ -83,14 +83,13 @@ describe('createOpenCodeWatcherRuntime', () => {
         },
       },
     ]);
-    expect(payloads).toEqual([
-      {
-        type: 'session.updated',
-        properties: {
-          sessionID: 'ses_1',
-        },
-      },
-    ]);
+    // The watcher hands its consumers the server's own vocabulary, translated
+    // from the v2 wire event.
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0]).toMatchObject({
+      type: 'session.updated',
+      properties: { sessionID: 'ses_1', info: { id: 'ses_1', title: 'New' } },
+    });
   });
 
   it('resumes watcher reconnects with Last-Event-ID after a stalled upstream stream', async () => {
@@ -118,7 +117,7 @@ describe('createOpenCodeWatcherRuntime', () => {
             signal: options.signal,
             holdOpen: true,
             blocks: [
-              'id: evt-1\ndata: {"type":"server.connected","properties":{}}\n\n',
+              'data: {"id":"evt-1","type":"server.connected","data":{}}\n\n',
             ],
           });
         }
@@ -126,7 +125,7 @@ describe('createOpenCodeWatcherRuntime', () => {
         return createSseResponse({
           signal: options.signal,
           blocks: [
-            'id: evt-2\ndata: {"type":"session.updated","properties":{}}\n\n',
+            'data: {"id":"evt-2","type":"session.renamed","location":{"directory":"/tmp/project"},"data":{"sessionID":"ses_1","title":"New"}}\n\n',
           ],
         });
       },
@@ -157,7 +156,7 @@ describe('createOpenCodeWatcherRuntime', () => {
           signal: options.signal,
           holdOpen: true,
           blocks: [
-            'id: evt-1\ndata: {"payload":{"type":"session.updated","properties":{"sessionID":"ses_1"}}}\n\n',
+            'data: {"payload":{"id":"evt-1","type":"session.renamed","location":{"directory":"/tmp/project"},"data":{"sessionID":"ses_1","title":"New"}}}\n\n',
           ],
         });
       },
@@ -183,14 +182,11 @@ describe('createOpenCodeWatcherRuntime', () => {
 
     expect(hubFetchCalls).toBe(1);
     expect(watcherFetchCalls).toBe(0);
-    expect(payloads).toEqual([
-      {
-        type: 'session.updated',
-        properties: {
-          sessionID: 'ses_1',
-        },
-      },
-    ]);
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0]).toMatchObject({
+      type: 'session.updated',
+      properties: { sessionID: 'ses_1', info: { id: 'ses_1', title: 'New' } },
+    });
   });
 
   it('does not stop a shared global event hub when the watcher stops', async () => {

package/server/lib/opencode/websearch-config.js

@@ -0,0 +1,66 @@
+import path from 'path';
+import fs from 'fs';
+import {
+  AGENT_SCOPE,
+  findWorktreeRoot,
+  getAncestors,
+  getJsonWriteTarget,
+  readConfigFile,
+  readConfigLayers,
+  writeConfig,
+} from './shared.js';
+import { findWebSearchProjectOverride, writeWebSearchSelection } from './config-v2.js';
+
+/**
+ * Writes the `websearch` choice into the config OpenCode reads last among the
+ * files OpenChamber owns a write to: `OPENCODE_CONFIG` when the user set one,
+ * else the user's global `opencode.json`. OpenCode watches both, so the choice
+ * applies without a restart. `selection` comes from `parseWebSearchSelection`.
+ * The file is left untouched when the choice is already there.
+ */
+export function setWebSearchSelection(selection) {
+  const layers = readConfigLayers(null);
+  const target = getJsonWriteTarget(layers, AGENT_SCOPE.USER);
+  const changed = writeWebSearchSelection(target.config, selection);
+  if (changed) writeConfig(target.config, target.path);
+  return { path: target.path, changed };
+}
+
+/**
+ * Where the effective `websearch` value for `directory` comes from, as far as
+ * a Settings write is concerned: `projectPath` is the project config that
+ * overrides whatever Settings writes, or `null` when a Settings write applies.
+ */
+export function getWebSearchSource(directory) {
+  return { projectPath: findWebSearchProjectOverride(readConfigLayers(directory), readProjectConfigFiles(directory)) };
+}
+
+const PROJECT_CONFIG_NAMES = [
+  path.join('.opencode', 'opencode.jsonc'),
+  path.join('.opencode', 'opencode.json'),
+  'opencode.jsonc',
+  'opencode.json',
+];
+
+/**
+ * Every existing project config file OpenCode merges for `directory`, deepest
+ * first, from the directory up to its worktree root. An unreadable file is
+ * skipped: it can't be told apart from one without the key.
+ */
+function readProjectConfigFiles(directory) {
+  if (!directory) return [];
+  const root = findWorktreeRoot(directory) || path.resolve(directory);
+  const files = [];
+  for (const base of getAncestors(directory, root)) {
+    for (const name of PROJECT_CONFIG_NAMES) {
+      const filePath = path.join(base, name);
+      if (!fs.existsSync(filePath)) continue;
+      try {
+        files.push({ path: filePath, config: readConfigFile(filePath) });
+      } catch {
+        // Skipped; see above.
+      }
+    }
+  }
+  return files;
+}