@openchambery/web 1.19.20 → 2.0.0-beta.1

package/server/lib/opencode/lifecycle.js

@@ -1,6 +1,8 @@
 import { spawn, spawnSync } from 'node:child_process';
 import net from 'node:net';
 import { registerManagedProcess, unregisterManagedProcess, reapOrphanedProcesses } from './managed-process-registry.js';
+import { evaluateOpenCodeHealthBody } from './opencode2-pin.js';
+import { OPENCODE_V1_MIGRATION_PATH, fetchV1MigrationGate } from './v1-migration-gate.js';
 
 const parsePositiveInt = (value, fallback) => {
   const parsed = Number.parseInt(String(value ?? ''), 10);
@@ -14,7 +16,14 @@ 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';
+// Official OpenCode 2.x exposes ServerInfo at GET /api/info (client.server.info).
+const OPENCODE_HEALTH_PATH = '/api/info';
+const OPENCODE_HEALTH_FALLBACK_PATH = '/global/health';
+const DEFAULT_OPENCODE_SERVE_PORT = 4096;
+// Last-used directory plus recently opened projects — deeper tails are unlikely
+// to be the user's first click and just add background work.
+const WARMUP_DIRECTORY_LIMIT = 4;
+const WARMUP_REQUEST_TIMEOUT_MS = 30000;
 
 export const createOpenCodeLifecycleRuntime = (deps) => {
   const {
@@ -28,6 +37,7 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     normalizeApiPrefix,
     applyOpencodeBinaryFromSettings,
     ensureOpencodeCliEnv,
+    ensurePinnedOpenCode2CliEnv,
     ensureLocalOpenCodeServerPassword,
     resolveManagedOpenCodeLaunchSpec,
     setOpenCodePort,
@@ -40,6 +50,7 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     getManagedOpenCodeShellEnvSnapshot,
     managedCapabilitiesRuntime = null,
     getActiveSessionCount = () => 0,
+    getWarmupDirectories = async () => [],
   } = deps;
 
   const killProcessOnPort = (port) => {
@@ -306,8 +317,11 @@ 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]+)/);
+            const trimmed = line.trim();
+            // v2 prints `server listening on http://...` without the `opencode `
+            // prefix; 1.x still prints `opencode server listening on ...`.
+            if (!trimmed.startsWith('opencode server listening') && !trimmed.startsWith('server listening')) continue;
+            const match = trimmed.match(/on\s+(https?:\/\/[^\s]+)/);
             if (!match) {
               finish(reject, new Error(`Failed to parse server url from output: ${line}`));
               return;
@@ -403,23 +417,72 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     });
   };
 
+  // Official v2 only publishes GET /api/experimental/migration/v1. Backfill
+  // runs inside opencode2; we poll status and never POST.
+  const probeV1MigrationGate = async (signal) => fetchV1MigrationGate({
+    url: buildOpenCodeUrl(OPENCODE_V1_MIGRATION_PATH, ''),
+    headers: getOpenCodeAuthHeaders(),
+    signal,
+  });
+
+  // Health ok is not enough to pull session messages. required/running/error
+  // keep isOpenCodeReady false so the proxy ready gate still blocks transcript.
+  const applyV1MigrationGate = (gate) => {
+    state.v1Migration = gate;
+    if (gate.admitTranscript) {
+      state.isOpenCodeReady = true;
+      state.openCodeNotReadySince = 0;
+      return true;
+    }
+    state.isOpenCodeReady = false;
+    if (!state.openCodeNotReadySince) {
+      state.openCodeNotReadySince = Date.now();
+    }
+    if (gate.phase === 'error' && gate.error) {
+      state.lastOpenCodeError = gate.error;
+    }
+    return false;
+  };
+
+  // v2 readiness lives at /api/info (ServerInfo.version); /global/health remains
+  // a probe fallback for older sidecars. Both require Basic auth from
+  // getOpenCodeAuthHeaders(). Version admission rejects 1.x / missing / noise.
+  const fetchOpenCodeHealthOk = async (urlForPath, signal, options = {}) => {
+    const headerCandidates = [
+      { Accept: 'application/json', ...getOpenCodeAuthHeaders() },
+    ];
+    if (options.allowUnauthenticated) {
+      headerCandidates.push({ Accept: 'application/json' });
+    }
+    for (const headers of headerCandidates) {
+      for (const healthPath of [OPENCODE_HEALTH_PATH, OPENCODE_HEALTH_FALLBACK_PATH]) {
+        try {
+          const response = await fetch(urlForPath(healthPath), {
+            method: 'GET',
+            headers,
+            signal,
+          });
+          if (!response.ok) continue;
+          const body = await response.json().catch(() => null);
+          const gate = evaluateOpenCodeHealthBody(body);
+          if (gate.ok) return true;
+        } catch {
+        }
+      }
+    }
+    return false;
+  };
+
   const isOpenCodeProcessHealthy = async () => {
     if (!state.openCodeProcess || !state.openCodePort) {
       return false;
     }
 
     try {
-      const response = await fetch(buildOpenCodeUrl(OPENCODE_HEALTH_PATH, ''), {
-        method: 'GET',
-        headers: {
-          Accept: 'application/json',
-          ...getOpenCodeAuthHeaders(),
-        },
-        signal: AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS),
-      });
-      if (!response.ok) return false;
-      const body = await response.json().catch(() => null);
-      return body?.healthy === true;
+      return await fetchOpenCodeHealthOk(
+        (healthPath) => buildOpenCodeUrl(healthPath, ''),
+        AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS)
+      );
     } catch {
       return false;
     }
@@ -434,18 +497,13 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
       const controller = new AbortController();
       const timeout = setTimeout(() => controller.abort(), 3000);
       const base = origin ?? `http://127.0.0.1:${port}`;
-      const response = await fetch(`${base}${OPENCODE_HEALTH_PATH}`, {
-        method: 'GET',
-        headers: {
-          Accept: 'application/json',
-          ...getOpenCodeAuthHeaders(),
-        },
-        signal: controller.signal,
-      });
+      const healthy = await fetchOpenCodeHealthOk(
+        (healthPath) => `${base}${healthPath}`,
+        controller.signal,
+        { allowUnauthenticated: true },
+      );
       clearTimeout(timeout);
-      if (!response.ok) return false;
-      const body = await response.json().catch(() => null);
-      return body?.healthy === true;
+      return healthy;
     } catch {
       return false;
     }
@@ -472,7 +530,12 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
   const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
   const startOpenCodeOnce = async () => {
-    const desiredPort = env.ENV_CONFIGURED_OPENCODE_PORT ?? 0;
+    const requestedPort = env.ENV_CONFIGURED_OPENCODE_PORT;
+    const defaultPortFree = requestedPort
+      ? false
+      : await waitForPortRelease(DEFAULT_OPENCODE_SERVE_PORT, 200, env.ENV_CONFIGURED_OPENCODE_HOSTNAME);
+    const desiredPort = requestedPort
+      ?? (defaultPortFree ? DEFAULT_OPENCODE_SERVE_PORT : 0);
     const spawnPort = await resolveManagedOpenCodePort(desiredPort, env.ENV_CONFIGURED_OPENCODE_HOSTNAME);
     console.log(
       desiredPort > 0
@@ -481,6 +544,9 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     );
 
     await applyOpencodeBinaryFromSettings({ strict: true });
+    if (typeof ensurePinnedOpenCode2CliEnv === 'function') {
+      await ensurePinnedOpenCode2CliEnv();
+    }
     ensureOpencodeCliEnv();
     const openCodePassword = await ensureLocalOpenCodeServerPassword({ rotateManaged: true });
     const envPath = typeof buildManagedOpenCodePath === 'function'
@@ -523,9 +589,10 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         setOpenCodePort(port);
         setDetectedOpenCodeApiPrefix(prefix);
 
-        state.isOpenCodeReady = true;
-        state.lastOpenCodeError = null;
-        state.openCodeNotReadySince = 0;
+        const gate = await probeV1MigrationGate(AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS));
+        if (applyV1MigrationGate(gate)) {
+          state.lastOpenCodeError = null;
+        }
 
         return serverInstance;
       }
@@ -593,12 +660,14 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         if (healthy) {
           console.log(`External OpenCode server on port ${probePort} is healthy`);
           setOpenCodePort(probePort);
-          state.isOpenCodeReady = true;
-          state.lastOpenCodeError = null;
-          state.openCodeNotReadySince = 0;
+          const gate = await probeV1MigrationGate(AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS));
+          if (applyV1MigrationGate(gate)) {
+            state.lastOpenCodeError = null;
+          }
           syncToHmrState();
         } else {
           state.lastOpenCodeError = `External OpenCode server on port ${probePort} is not responding`;
+          state.v1Migration = null;
           console.error(state.lastOpenCodeError);
           throw new Error(state.lastOpenCodeError);
         }
@@ -658,12 +727,16 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     } catch (error) {
       console.error(`Failed to restart OpenCode: ${error.message}`);
       state.lastOpenCodeError = error.message;
-      if (!env.ENV_CONFIGURED_OPENCODE_PORT) {
-        state.openCodePort = null;
-        syncToHmrState();
+      // External serve is read-only: never clear its port, flip ownership, or
+      // spawn a managed replacement when a re-probe fails.
+      if (!state.isExternalOpenCode) {
+        if (!env.ENV_CONFIGURED_OPENCODE_PORT) {
+          state.openCodePort = null;
+          syncToHmrState();
+        }
+        state.openCodeApiPrefixDetected = true;
+        state.openCodeApiPrefix = '';
       }
-      state.openCodeApiPrefixDetected = true;
-      state.openCodeApiPrefix = '';
       throw error;
     } finally {
       state.currentRestartPromise = null;
@@ -682,32 +755,31 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     while (Date.now() < deadline) {
       let timeout = null;
       try {
+        // One timer covers health + migration for this attempt. Clearing after
+        // health alone let a hung migration outrun HEALTH_CHECK_TIMEOUT_MS and
+        // the outer deadline when the probe never settled.
         const controller = new AbortController();
         timeout = setTimeout(() => controller.abort(), HEALTH_CHECK_TIMEOUT_MS);
-        const response = await fetch(buildOpenCodeUrl(OPENCODE_HEALTH_PATH, ''), {
-          method: 'GET',
-          headers: { Accept: 'application/json', ...getOpenCodeAuthHeaders() },
-          signal: controller.signal,
-        });
-        clearTimeout(timeout);
-        timeout = null;
+        const healthy = await fetchOpenCodeHealthOk(
+          (healthPath) => buildOpenCodeUrl(healthPath, ''),
+          controller.signal
+        );
 
-        if (!response.ok) {
-          lastError = new Error(`OpenCode health endpoint responded with status ${response.status}`);
+        if (!healthy) {
+          lastError = new Error('OpenCode health endpoint returned unhealthy response');
           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');
-          await new Promise((resolve) => setTimeout(resolve, intervalMs));
-          continue;
+        const gate = await probeV1MigrationGate(controller.signal);
+        if (applyV1MigrationGate(gate)) {
+          state.lastOpenCodeError = null;
+          return;
         }
 
-        state.isOpenCodeReady = true;
-        state.lastOpenCodeError = null;
-        return;
+        lastError = new Error(gate.error || `V1 migration is ${gate.phase}`);
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        continue;
       } catch (error) {
         lastError = error;
       } finally {
@@ -828,35 +900,40 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         console.log(`Using external OpenCode server at ${label} (skip-start mode)`);
         state.openCodeBaseUrl = env.ENV_CONFIGURED_OPENCODE_HOST?.origin ?? null;
         setOpenCodePort(env.ENV_EFFECTIVE_PORT);
-        state.isOpenCodeReady = true;
+        // External attach is not ready until version + V1 migration admit.
+        state.isOpenCodeReady = false;
+        state.openCodeNotReadySince = Date.now();
         state.isExternalOpenCode = true;
         state.lastOpenCodeError = null;
-        state.openCodeNotReadySince = 0;
+        state.v1Migration = null;
         syncToHmrState();
       } else if (await isOpenCodeProcessHealthy() && (managedCapabilitiesRuntime ? managedCapabilitiesRuntime.hasValidIdentity() : true)) {
         console.log(`[HMR] Reusing existing OpenCode process on port ${state.openCodePort}`);
       } else if (state.openCodeProcess && !state.isExternalOpenCode && await isOpenCodeProcessHealthy()) {
         console.log('[HMR] Restarting managed OpenCode because scheduled-task capability identity is stale');
         await restartOpenCode();
-      } else if (env.ENV_EFFECTIVE_PORT && await probeExternalOpenCode(env.ENV_EFFECTIVE_PORT, env.ENV_CONFIGURED_OPENCODE_HOST?.origin)) {
-        const label = env.ENV_CONFIGURED_OPENCODE_HOST ? env.ENV_CONFIGURED_OPENCODE_HOST.origin : `http://localhost:${env.ENV_EFFECTIVE_PORT}`;
-        console.log(`Auto-detected existing OpenCode server at ${label}`);
+      } else if (
+        (env.ENV_EFFECTIVE_PORT || DEFAULT_OPENCODE_SERVE_PORT)
+        && await probeExternalOpenCode(
+          env.ENV_EFFECTIVE_PORT || DEFAULT_OPENCODE_SERVE_PORT,
+          env.ENV_CONFIGURED_OPENCODE_HOST?.origin,
+        )
+      ) {
+        const reusePort = env.ENV_EFFECTIVE_PORT || DEFAULT_OPENCODE_SERVE_PORT;
+        const label = env.ENV_CONFIGURED_OPENCODE_HOST ? env.ENV_CONFIGURED_OPENCODE_HOST.origin : `http://localhost:${reusePort}`;
+        console.log(`Reusing existing OpenCode serve at ${label}`);
         state.openCodeBaseUrl = env.ENV_CONFIGURED_OPENCODE_HOST?.origin ?? null;
-        setOpenCodePort(env.ENV_EFFECTIVE_PORT);
-        state.isOpenCodeReady = true;
+        setOpenCodePort(reusePort);
+        // Health ok is not transcript-ready; waitForOpenCodeReady applies the gate.
+        state.isOpenCodeReady = false;
+        state.openCodeNotReadySince = Date.now();
         state.isExternalOpenCode = true;
         state.lastOpenCodeError = null;
-        state.openCodeNotReadySince = 0;
+        state.v1Migration = null;
         syncToHmrState();
       } else {
-        // We never auto-attach to an arbitrary pre-existing OpenCode instance.
-        // Attaching to an external server requires explicit opt-in via env
-        // (OPENCODE_HOST / OPENCODE_PORT / OPENCODE_SKIP_START), handled by the
-        // branches above. Without that opt-in we always start our OWN managed
-        // instance on a freshly-allocated port. A blind probe of the default
-        // port 4096 used to hijack a user's separately-running OpenCode (e.g.
-        // the OpenCode desktop app), coupling our lifecycle to theirs and
-        // breaking init against an unexpected server version/config.
+        // No healthy v2 serve on the requested/default port. Start a generic
+        // `opencode serve` so OpenChamber and other OpenCode clients can share it.
         state.isExternalOpenCode = false;
         state.openCodeBaseUrl = null;
         if (env.ENV_EFFECTIVE_PORT) {
@@ -874,6 +951,11 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
       await waitForOpenCodePort();
       try {
         await waitForOpenCodeReady();
+        // Warm only after readiness admits; a failed gate must not kick off
+        // directory-scoped traffic against an unready upstream.
+        if (state.isOpenCodeReady) {
+          void warmOpenCodeDirectories();
+        }
       } catch (error) {
         console.error(`OpenCode readiness check failed: ${error.message}`);
       }
@@ -884,6 +966,47 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     }
   };
 
+  // OpenCode initializes each project directory lazily on its first
+  // directory-scoped request, and that initialization takes seconds on large
+  // session stores. Without warming, the user's first session open pays it
+  // interactively. Warm the most recently used directories right after
+  // readiness so the work overlaps UI startup instead. Sequential and
+  // best-effort: a failed or slow directory never blocks the others for long,
+  // and a restart invalidates the pass via the port/readiness guard.
+  const warmOpenCodeDirectories = async () => {
+    let directories = [];
+    try {
+      directories = await getWarmupDirectories();
+    } catch {
+      return;
+    }
+    if (!Array.isArray(directories) || directories.length === 0) return;
+
+    const warmedPort = state.openCodePort;
+    for (const directory of directories.slice(0, WARMUP_DIRECTORY_LIMIT)) {
+      if (typeof directory !== 'string' || !directory) continue;
+      if (!state.isOpenCodeReady || state.openCodePort !== warmedPort) return;
+      let timeout = null;
+      try {
+        const controller = new AbortController();
+        timeout = setTimeout(() => controller.abort(), WARMUP_REQUEST_TIMEOUT_MS);
+        // 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.
+        const url = `${buildOpenCodeUrl('/api/session', '')}?directory=${encodeURIComponent(directory)}&limit=1`;
+        await fetch(url, {
+          method: 'GET',
+          headers: { Accept: 'application/json', ...getOpenCodeAuthHeaders() },
+          signal: controller.signal,
+        });
+      } catch {
+        // Best-effort — the directory stays lazy and the UI's own request warms it.
+      } finally {
+        if (timeout) clearTimeout(timeout);
+      }
+    }
+  };
+
   const bootstrapOpenCodeAtStartup = () => {
     if (!bootstrapOpenCodePromise) {
       bootstrapOpenCodePromise = runBootstrapOpenCodeAtStartup().finally(() => {
@@ -903,6 +1026,9 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
 
         clearResolvedOpenCodeBinary();
         await applyOpencodeBinaryFromSettings({ strict: true });
+        if (typeof ensurePinnedOpenCode2CliEnv === 'function') {
+          await ensurePinnedOpenCode2CliEnv();
+        }
         const resolved = ensureOpencodeCliEnv();
         if (!resolved) {
           const error = new Error('OpenCode CLI could not be resolved');
@@ -992,6 +1118,9 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
   };
 
   const runHealthCheckCycle = async (source) => {
+    // External serve is read-only mount: never restart or spawn a second copy
+    // because the user's instance looks unhealthy from our probe.
+    if (state.isExternalOpenCode) return;
     if (!state.openCodeProcess || state.isShuttingDown || state.isRestartingOpenCode) return;
     if (healthCheckCyclePromise) return healthCheckCyclePromise;
 
@@ -1017,6 +1146,11 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         await restartOpenCode();
       } else {
         resetHealthFailureState();
+        try {
+          const gate = await probeV1MigrationGate(AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS));
+          applyV1MigrationGate(gate);
+        } catch {
+        }
       }
     })().finally(() => {
       healthCheckCyclePromise = null;