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

package/server/lib/opencode/managed-capabilities-runtime.js

@@ -122,15 +122,28 @@ export const createManagedCapabilitiesRuntime = ({
     bridgeOrigin = parsed.origin;
   };
 
+  const publishHostShim = async () => {
+    const sourceDir = pathLike.join(pathLike.dirname(fileURLToPath(import.meta.url)), 'v2-plugin-host-shim');
+    const target = pathLike.join(dataDir, 'managed-opencode-capabilities', 'v2-plugin-host-shim');
+    await fsLike.mkdir(target, { recursive: true });
+    await Promise.all(['package.json', 'index.mjs'].map((name) => fsLike.copyFile(pathLike.join(sourceDir, name), pathLike.join(target, name))));
+    return target;
+  };
+
   const prepareManagedChildEnv = async (baseEnv = {}) => {
     if (!bridgeOrigin) throw new Error('Managed scheduled-task bridge origin is unavailable');
-    const { pluginPath, instructionsPath } = await publishResources();
+    const [{ pluginPath, instructionsPath }, shimDirectory] = await Promise.all([
+      publishResources(),
+      publishHostShim(),
+    ]);
     const token = cryptoLike.randomBytes(32).toString('hex');
     const pluginUrl = pathToFileURL(pluginPath).href;
     identity = { version: materialVersion, origin: bridgeOrigin, token, childPid: null };
+    const merged = JSON.parse(mergeManagedOpenCodeConfig({ configContent: baseEnv.OPENCODE_CONFIG_CONTENT, pluginUrl, instructionsUrl: instructionsPath }));
+    merged.plugin = stableDedupe([...(Array.isArray(merged.plugin) ? merged.plugin : []), shimDirectory]);
     return {
       ...baseEnv,
-      OPENCODE_CONFIG_CONTENT: mergeManagedOpenCodeConfig({ configContent: baseEnv.OPENCODE_CONFIG_CONTENT, pluginUrl, instructionsUrl: instructionsPath }),
+      OPENCODE_CONFIG_CONTENT: JSON.stringify(merged),
       OPENCHAMBER_SCHEDULED_TASK_BRIDGE_ORIGIN: bridgeOrigin,
       OPENCHAMBER_SCHEDULED_TASK_BRIDGE_PATH: MANAGED_SCHEDULED_TASK_TOOL_PATH,
       OPENCHAMBER_SCHEDULED_TASK_TOKEN_HEADER: MANAGED_SCHEDULED_TASK_TOKEN_HEADER,

package/server/lib/opencode/managed-capabilities-runtime.test.js

@@ -24,6 +24,7 @@ describe('managed OpenCode capabilities runtime', () => {
       runtime.recordManagedChildPid(44);
       const identity = runtime.getCapabilityIdentity();
       expect(childEnv.OPENCODE_CONFIG_CONTENT).toContain('scheduled-task.mjs');
+      expect(JSON.parse(childEnv.OPENCODE_CONFIG_CONTENT).plugin).toContain(path.join(dataDir, 'managed-opencode-capabilities', 'v2-plugin-host-shim'));
       expect(JSON.parse(childEnv.OPENCODE_CONFIG_CONTENT).instructions[0]).toMatch(/^\//);
       expect(childEnv.OPENCHAMBER_SCHEDULED_TASK_BRIDGE_PATH).toBe(MANAGED_SCHEDULED_TASK_TOOL_PATH);
       expect(childEnv.OPENCHAMBER_SCHEDULED_TASK_TOKEN_HEADER).toBe(MANAGED_SCHEDULED_TASK_TOKEN_HEADER);

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

@@ -1,3 +1,5 @@
+import { evaluateOpenCodeHealthBody } from './opencode2-pin.js';
+
 export const createOpenCodeNetworkRuntime = (deps) => {
   const {
     state,
@@ -41,26 +43,29 @@ export const createOpenCodeNetworkRuntime = (deps) => {
 
   const waitForReady = async (url, timeoutMs = 10000) => {
     const start = Date.now();
+    const baseUrl = url.replace(/\/+$/, '');
     while (Date.now() - start < timeoutMs) {
       let timeout = null;
       try {
         const controller = new AbortController();
         timeout = setTimeout(() => controller.abort(), 3000);
-        const response = await fetch(`${url.replace(/\/+$/, '')}/global/health`, {
-          method: 'GET',
-          headers: {
-            Accept: 'application/json',
-            ...getOpenCodeAuthHeaders(),
-          },
-          signal: controller.signal,
-        });
-        clearTimeout(timeout);
-        timeout = null;
-
-        if (response.ok) {
-          const body = await response.json().catch(() => null);
-          if (body?.healthy === true) {
-            return true;
+        const headers = {
+          Accept: 'application/json',
+          ...getOpenCodeAuthHeaders(),
+        };
+        for (const healthPath of ['/api/info', '/global/health']) {
+          const response = await fetch(`${baseUrl}${healthPath}`, {
+            method: 'GET',
+            headers,
+            signal: controller.signal,
+          });
+          if (response.ok) {
+            const body = await response.json().catch(() => null);
+            // Official 2.x /api/info is ServerInfo (version, no healthy);
+            // /global/health may still return { healthy, version }.
+            if (evaluateOpenCodeHealthBody(body).ok) {
+              return true;
+            }
           }
         }
       } catch {
@@ -88,8 +93,15 @@ export const createOpenCodeNetworkRuntime = (deps) => {
       throw new Error('OpenCode port is not available');
     }
     const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    // v2 protocol mounts every route under `/api` (`@opencode-ai/protocol`).
+    // Callers pass unprefixed API paths (`/session`, `/event`, …); the bare
+    // upstream path falls through to the v2 Web UI HTML fallback. `/` stays the
+    // upstream origin for SDK base URLs, and already-prefixed paths are kept.
+    const apiPath = normalizedPath === '/' || normalizedPath.startsWith('/api')
+      ? normalizedPath
+      : `/api${normalizedPath}`;
     const prefix = normalizeApiPrefix(prefixOverride !== undefined ? prefixOverride : '');
-    const fullPath = `${prefix}${normalizedPath}`;
+    const fullPath = `${prefix}${apiPath}`;
     const base = state.openCodeBaseUrl ?? `http://${resolveConnectHostname()}:${state.openCodePort}`;
     return `${base}${fullPath}`;
   };

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

@@ -23,6 +23,63 @@ describe('OpenCode network runtime', () => {
     globalThis.fetch = originalFetch;
   });
 
+  it('probes /api/info with Authorization and treats healthy true as ready', async () => {
+    const fetchMock = vi.fn(async (url, options) => {
+      expect(String(url)).toContain('/api/info');
+      expect(options.headers.Authorization).toMatch(/^Basic /);
+      return new Response(JSON.stringify({ version: '2.0.12', pid: 1, urls: [], paths: { tmp: '/tmp' } }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      });
+    });
+    globalThis.fetch = fetchMock;
+
+    const runtime = createOpenCodeNetworkRuntime({
+      state: {
+        openCodePort: 4096,
+        openCodeBaseUrl: null,
+        openCodeApiPrefix: '',
+        openCodeApiPrefixDetected: false,
+        openCodeApiDetectionTimer: null,
+      },
+      getOpenCodeAuthHeaders: () => ({ Authorization: 'Basic Zml4dHVyZQ==' }),
+    });
+
+    await expect(runtime.waitForReady('http://127.0.0.1:4096', 1000)).resolves.toBe(true);
+    expect(String(fetchMock.mock.calls[0][0])).toContain('/api/info');
+  });
+
+  it('falls back to /global/health when /api/info is not healthy', async () => {
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('/api/info')) {
+        return new Response('not found', { status: 404 });
+      }
+      if (String(url).includes('/global/health')) {
+        return new Response(JSON.stringify({ healthy: true, version: '2.0.12' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        });
+      }
+      return new Response('no', { status: 500 });
+    });
+    globalThis.fetch = fetchMock;
+
+    const runtime = createOpenCodeNetworkRuntime({
+      state: {
+        openCodePort: 4096,
+        openCodeBaseUrl: null,
+        openCodeApiPrefix: '',
+        openCodeApiPrefixDetected: false,
+        openCodeApiDetectionTimer: null,
+      },
+      getOpenCodeAuthHeaders: () => ({ Authorization: 'Basic Zml4dHVyZQ==' }),
+    });
+
+    await expect(runtime.waitForReady('http://127.0.0.1:4096', 1000)).resolves.toBe(true);
+    expect(String(fetchMock.mock.calls[0][0])).toContain('/api/info');
+    expect(String(fetchMock.mock.calls[1][0])).toContain('/global/health');
+  });
+
   it('returns false when readiness fetch rejects', async () => {
     globalThis.fetch = vi.fn(async () => {
       throw new Error('offline');
@@ -37,7 +94,7 @@ describe('OpenCode network runtime', () => {
   it('builds managed OpenCode URLs against IPv4 loopback by default', () => {
     const runtime = createRuntime();
 
-    expect(runtime.buildOpenCodeUrl('/provider')).toBe('http://127.0.0.1:4096/provider');
+    expect(runtime.buildOpenCodeUrl('/provider')).toBe('http://127.0.0.1:4096/api/provider');
   });
 
   it('keeps external OpenCode base URLs authoritative', () => {
@@ -45,13 +102,20 @@ describe('OpenCode network runtime', () => {
       state: { openCodeBaseUrl: 'http://remote.example:4096' },
     });
 
-    expect(runtime.buildOpenCodeUrl('/provider')).toBe('http://remote.example:4096/provider');
+    expect(runtime.buildOpenCodeUrl('/provider')).toBe('http://remote.example:4096/api/provider');
+  });
+
+  it('keeps SDK base URLs (/) and already-prefixed paths untouched', () => {
+    const runtime = createRuntime();
+
+    expect(runtime.buildOpenCodeUrl('/')).toBe('http://127.0.0.1:4096/');
+    expect(runtime.buildOpenCodeUrl('/api/info')).toBe('http://127.0.0.1:4096/api/info');
   });
 
   it('normalizes wildcard and IPv6 OpenCode bind hosts for local connects', () => {
     expect(createRuntime({ configuredOpenCodeHostname: '0.0.0.0' }).buildOpenCodeUrl('/provider'))
-      .toBe('http://127.0.0.1:4096/provider');
+      .toBe('http://127.0.0.1:4096/api/provider');
     expect(createRuntime({ configuredOpenCodeHostname: '::1' }).buildOpenCodeUrl('/provider'))
-      .toBe('http://[::1]:4096/provider');
+      .toBe('http://[::1]:4096/api/provider');
   });
 });

package/server/lib/opencode/openchamber-routes.js

@@ -14,11 +14,17 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
     getCachedZenModels,
     sessionIndexService,
     sessionIndexSyncRuntime,
+    /** Production: committed Host metadata for archive-aware snapshot/lookup. */
+    getCommittedHostMetadata = null,
     transcriptCacheService,
     express,
   } = dependencies;
 
-  registerSessionIndexRoutes(app, { sessionIndexService, sessionIndexSyncRuntime });
+  registerSessionIndexRoutes(app, {
+    sessionIndexService,
+    sessionIndexSyncRuntime,
+    getCommittedHostMetadata,
+  });
   registerTranscriptCacheRoutes(app, { transcriptCacheService });
   registerConfigSyncRoutes(app, { express });
 

package/server/lib/opencode/opencode2-pin.js

@@ -0,0 +1,139 @@
+// Pinned desktop/runtime opencode2. Upgrade and prepare must not fall back to 1.18.x.
+export const PINNED_OPENCODE2_VERSION = '2.0.12';
+
+// Global npm/bun package that installs the opencode v2 binary (not 1.x opencode-ai).
+export const OPENCODE2_NPM_PACKAGE = '@opencode/cli';
+
+export function isOpenCode1xVersion(value) {
+  if (typeof value !== 'string') return false;
+  const normalized = value.trim().replace(/^v/i, '');
+  if (!normalized) return false;
+  return /^1(?:\.|$)/.test(normalized);
+}
+
+/**
+ * Health admission for managed/external opencode2.
+ * healthy alone is not enough: reject 1.x and missing/unknown version strings.
+ */
+export function isAcceptableOpenCode2HealthVersion(value) {
+  if (typeof value !== 'string') return false;
+  const normalized = value.trim().replace(/^v/i, '');
+  if (!normalized) return false;
+  // Official CLI is 2.x. 1.x and pre-2 names like `opencode2 v0.0.0-beta-*` are not it.
+  if (!/^2(?:\.|$)/.test(normalized)) return false;
+  return /^\d+(?:\.\d+)*(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(normalized);
+}
+
+/**
+ * Pure health/info body gate used by lifecycle and VS Code sidecar.
+ * Accepts classic `{ healthy: true, version }` and official 2.x `ServerInfo`
+ * (`GET /api/info` → `{ version, pid, urls, paths }` without `healthy`).
+ * @param {{ healthy?: unknown, version?: unknown } | null | undefined} body
+ * @returns {{ ok: boolean, version: string | null, reason?: string }}
+ */
+export function evaluateOpenCodeHealthBody(body) {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    return { ok: false, version: null, reason: 'invalid-body' };
+  }
+  // Classic /api/health required healthy:true; /api/info omits healthy entirely.
+  if (Object.prototype.hasOwnProperty.call(body, 'healthy') && body.healthy !== true) {
+    return { ok: false, version: null, reason: 'unhealthy' };
+  }
+  const raw = typeof body.version === 'string' ? body.version.trim() : '';
+  const version = raw ? raw.replace(/^v/i, '') : null;
+  if (!isAcceptableOpenCode2HealthVersion(version)) {
+    if (isOpenCode1xVersion(version)) {
+      return { ok: false, version, reason: '1x-version' };
+    }
+    return { ok: false, version, reason: 'unknown-version' };
+  }
+  return { ok: true, version };
+}
+
+export function rejectOpenCode1xUpgradeTarget(target) {
+  if (isOpenCode1xVersion(target)) {
+    const error = new Error(`OpenCode upgrade refuses 1.x target: ${target}`);
+    error.code = 'OPENCODE_UPGRADE_1X_REFUSED';
+    throw error;
+  }
+  return target;
+}
+
+export function resolveOpenCode2UpgradeTarget(target) {
+  const trimmed = typeof target === 'string' ? target.trim() : '';
+  if (trimmed) {
+    rejectOpenCode1xUpgradeTarget(trimmed);
+    return trimmed;
+  }
+  return PINNED_OPENCODE2_VERSION;
+}
+
+/**
+ * Parse `opencode2 --version` / `opencode --version` stdout.
+ * v2: `opencode2 v2.0.12` (name then version). 1.x: `1.18.18`.
+ */
+export function parseOpenCode2VersionOutput(stdout) {
+  const tokens = String(stdout || '').trim().split(/\s+/);
+  const versionToken = tokens.find((token) => /^v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(token));
+  if (!versionToken) return '';
+  return versionToken.replace(/^v/, '');
+}
+
+export function openCodeBinaryName(platform = process.platform) {
+  return platform === 'win32' ? 'opencode.exe' : 'opencode';
+}
+
+/** @deprecated Packaging leftover. Runtime install uses `openCodeBinaryName`. */
+export function openCode2BinaryName(platform = process.platform) {
+  return openCodeBinaryName(platform);
+}
+
+export function resolveOpenCode2NpmArchitecture(arch = process.arch) {
+  const normalized = String(arch || '').trim().toLowerCase();
+  if (normalized === 'x64' || normalized === 'amd64' || normalized === 'x86_64') return 'x64';
+  if (normalized === 'arm64' || normalized === 'aarch64') return 'arm64';
+  throw new Error(`Unsupported OpenCode architecture ${JSON.stringify(arch)}`);
+}
+
+/**
+ * Official 2.x ships as `@opencode/cli-<os>-<arch>[-baseline]`.
+ * `targetArchitecture` may be `{ opencode }` (Electron prepare) or an arch string.
+ */
+export function npmPackageForOpenCode2(platform = process.platform, targetArchitecture = process.arch) {
+  const rawArch = targetArchitecture && typeof targetArchitecture === 'object'
+    ? (targetArchitecture.opencode ?? targetArchitecture.node)
+    : targetArchitecture;
+  const arch = resolveOpenCode2NpmArchitecture(rawArch);
+  const os = { darwin: 'darwin', win32: 'windows', linux: 'linux' }[platform];
+  if (!os) throw new Error(`No opencode2 npm package mapping for platform ${platform}`);
+  const suffix = arch === 'x64' ? '-baseline' : '';
+  return `@opencode/cli-${os}-${arch}${suffix}`;
+}
+
+function parseVersionForComparison(value) {
+  const normalized = String(value || '').replace(/^v/i, '').split('+')[0];
+  const prereleaseIndex = normalized.indexOf('-');
+  const core = prereleaseIndex >= 0 ? normalized.slice(0, prereleaseIndex) : normalized;
+  const parts = core.split('.').map((part) => {
+    const parsed = Number.parseInt(part || '0', 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+  });
+  return { parts, prerelease: prereleaseIndex >= 0 };
+}
+
+export function compareOpenCode2Versions(left, right) {
+  const a = parseVersionForComparison(left);
+  const b = parseVersionForComparison(right);
+  const length = Math.max(a.parts.length, b.parts.length);
+  for (let index = 0; index < length; index += 1) {
+    const diff = (a.parts[index] || 0) - (b.parts[index] || 0);
+    if (diff !== 0) return diff;
+  }
+  if (a.prerelease !== b.prerelease) return a.prerelease ? -1 : 1;
+  return 0;
+}
+
+export function isOpenCode2VersionAtLeast(version, minimum = PINNED_OPENCODE2_VERSION) {
+  if (!isAcceptableOpenCode2HealthVersion(version)) return false;
+  return compareOpenCode2Versions(version, minimum) >= 0;
+}

package/server/lib/opencode/opencode2-pin.test.js

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+import {
+  OPENCODE2_NPM_PACKAGE,
+  PINNED_OPENCODE2_VERSION,
+  compareOpenCode2Versions,
+  evaluateOpenCodeHealthBody,
+  isAcceptableOpenCode2HealthVersion,
+  isOpenCode1xVersion,
+  isOpenCode2VersionAtLeast,
+  npmPackageForOpenCode2,
+  parseOpenCode2VersionOutput,
+  rejectOpenCode1xUpgradeTarget,
+  resolveOpenCode2UpgradeTarget,
+} from './opencode2-pin.js';
+
+describe('opencode2 pin (ticket 12)', () => {
+  it('rejects 1.x version strings and accepts the pinned v2', () => {
+    expect(isOpenCode1xVersion('1.18.4')).toBe(true);
+    expect(isOpenCode1xVersion('v1.18.18')).toBe(true);
+    expect(isOpenCode1xVersion('1.18.x')).toBe(true);
+    expect(isOpenCode1xVersion('1')).toBe(true);
+    expect(isOpenCode1xVersion(PINNED_OPENCODE2_VERSION)).toBe(false);
+    expect(isOpenCode1xVersion('2.0.12')).toBe(false);
+    expect(isOpenCode1xVersion('')).toBe(false);
+    expect(isOpenCode1xVersion(null)).toBe(false);
+  });
+
+  it('throws on 1.x upgrade targets and defaults empty to the pin', () => {
+    expect(() => rejectOpenCode1xUpgradeTarget('1.18.4')).toThrow(/1\.x/);
+    expect(() => rejectOpenCode1xUpgradeTarget('1.18.4')).toThrow(expect.objectContaining({ code: 'OPENCODE_UPGRADE_1X_REFUSED' }));
+    expect(resolveOpenCode2UpgradeTarget(undefined)).toBe(PINNED_OPENCODE2_VERSION);
+    expect(resolveOpenCode2UpgradeTarget('')).toBe(PINNED_OPENCODE2_VERSION);
+    expect(resolveOpenCode2UpgradeTarget(PINNED_OPENCODE2_VERSION)).toBe(PINNED_OPENCODE2_VERSION);
+    expect(() => resolveOpenCode2UpgradeTarget('1.18.18')).toThrow(/1\.x/);
+  });
+
+  it('pins the opencode2 npm package name (not 1.x opencode-ai)', () => {
+    expect(OPENCODE2_NPM_PACKAGE).toBe('@opencode/cli');
+    expect(OPENCODE2_NPM_PACKAGE).not.toBe('opencode-ai');
+    expect(OPENCODE2_NPM_PACKAGE).not.toBe('@opencode-ai/cli');
+  });
+
+  it('accepts authoritative v2 health/info versions and rejects 1.x / missing / noise', () => {
+    expect(isAcceptableOpenCode2HealthVersion(PINNED_OPENCODE2_VERSION)).toBe(true);
+    expect(isAcceptableOpenCode2HealthVersion('v2.0.12')).toBe(true);
+    expect(isAcceptableOpenCode2HealthVersion('0.0.0-beta-18155')).toBe(false);
+    expect(isAcceptableOpenCode2HealthVersion('1.15.0')).toBe(false);
+    expect(isAcceptableOpenCode2HealthVersion('v1.18.18')).toBe(false);
+    expect(isAcceptableOpenCode2HealthVersion('')).toBe(false);
+    expect(isAcceptableOpenCode2HealthVersion(null)).toBe(false);
+    expect(isAcceptableOpenCode2HealthVersion('not-a-version')).toBe(false);
+
+    expect(evaluateOpenCodeHealthBody({ healthy: true, version: PINNED_OPENCODE2_VERSION })).toEqual({
+      ok: true,
+      version: PINNED_OPENCODE2_VERSION,
+    });
+    // Official 2.x ServerInfo from GET /api/info has version without healthy.
+    expect(evaluateOpenCodeHealthBody({ version: PINNED_OPENCODE2_VERSION, pid: 1 })).toEqual({
+      ok: true,
+      version: PINNED_OPENCODE2_VERSION,
+    });
+    expect(evaluateOpenCodeHealthBody({ healthy: true, version: '1.15.0' })).toMatchObject({
+      ok: false,
+      version: '1.15.0',
+      reason: '1x-version',
+    });
+    expect(evaluateOpenCodeHealthBody({ healthy: true })).toMatchObject({
+      ok: false,
+      reason: 'unknown-version',
+    });
+    expect(evaluateOpenCodeHealthBody({ healthy: false, version: PINNED_OPENCODE2_VERSION })).toMatchObject({
+      ok: false,
+      reason: 'unhealthy',
+    });
+    expect(evaluateOpenCodeHealthBody(null)).toMatchObject({ ok: false, reason: 'invalid-body' });
+  });
+
+  it('parses --version output and compares against the pin', () => {
+    expect(parseOpenCode2VersionOutput('opencode2 v2.0.12\n')).toBe('2.0.12');
+    expect(parseOpenCode2VersionOutput('1.18.18\n')).toBe('1.18.18');
+    expect(compareOpenCode2Versions('2.0.12', '2.0.1')).toBeGreaterThan(0);
+    expect(isOpenCode2VersionAtLeast('2.0.12', '2.0.12')).toBe(true);
+    expect(isOpenCode2VersionAtLeast('2.0.1', '2.0.12')).toBe(false);
+    expect(isOpenCode2VersionAtLeast('1.18.18', '2.0.12')).toBe(false);
+    expect(npmPackageForOpenCode2('darwin', 'arm64')).toBe('@opencode/cli-darwin-arm64');
+    expect(npmPackageForOpenCode2('darwin', { opencode: 'x64' })).toBe('@opencode/cli-darwin-x64-baseline');
+  });
+});