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

package/server/lib/opencode/routes.js

@@ -1,5 +1,24 @@
 import { createProjectIdFromPath } from '../projects/project-id.js';
 import { projectBootstrapSettingsResponse } from './settings-helpers.js';
+import {
+  PINNED_OPENCODE2_VERSION,
+  evaluateOpenCodeHealthBody,
+  isOpenCode1xVersion,
+  resolveOpenCode2UpgradeTarget,
+} from './opencode2-pin.js';
+import {
+  installPinnedOpenCode2Cli,
+  readOpenCode2BinaryVersion,
+  resolveOpenChamberDataDir,
+} from './ensure-cli.js';
+import { evaluateRuntimeContract } from './runtime-contract.js';
+import {
+  buildUpgradeStatusSnapshot,
+  classifyRuntimeOwnership,
+  createUpgradeOperationState,
+  evaluateOwnedUpgradeResult,
+  resolveOwnedCacheBinaryPath,
+} from './owned-runtime-upgrade.js';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -22,8 +41,23 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
     buildOpenCodeUrl,
     getOpenCodeAuthHeaders,
     onSettingsPersisted,
+    getIsExternalOpenCode = () => false,
+    getIsSharedOpenCodeService = () => false,
+    forceResolvedOpenCodeBinary = null,
+    restartOpenCode = null,
+    waitForOpenCodeReady = null,
+    getRuntimeContract = () => null,
+    getOpenCodeServeVersion = () => null,
+    getOpenCodeCliVersion = () => null,
+    getResolvedOpenCodeBinary = () => null,
+    getResolvedOpenCodeBinarySource = () => null,
+    getActiveSessionCount = () => 0,
+    openchamberDataDir = null,
   } = dependencies;
 
+  const upgradeOperation = createUpgradeOperationState();
+  const resolveDataDir = () => openchamberDataDir || resolveOpenChamberDataDir();
+
   let authLibrary = null;
   const pendingMcpAuthContextByState = new Map();
   const PENDING_MCP_AUTH_TTL_MS = 30 * 60 * 1000;
@@ -50,16 +84,87 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
   };
 
   const readOpenCodeCurrentVersion = async () => {
-    const healthResponse = await fetch(buildOpenCodeUrl('/global/health', ''), {
+    const healthResponse = await fetch(buildOpenCodeUrl('/api/info', ''), {
       method: 'GET',
       headers: { Accept: 'application/json', ...getOpenCodeAuthHeaders() },
     });
     const health = await healthResponse.json().catch(() => null);
     if (!healthResponse.ok) {
-      return { ok: false, status: healthResponse.status, error: health?.error || healthResponse.statusText };
+      return {
+        ok: false,
+        status: healthResponse.status,
+        error: health?.error || healthResponse.statusText,
+        authenticated: healthResponse.status === 401 || healthResponse.status === 403 ? false : null,
+      };
+    }
+    const gate = evaluateOpenCodeHealthBody(health);
+    const currentVersion = gate.version
+      || (typeof health?.version === 'string' ? health.version.replace(/^v/, '') : null);
+    return { ok: gate.ok, currentVersion, healthOk: gate.ok, authenticated: true };
+  };
+
+  const resolveOwnershipContext = async () => {
+    const isExternal = getIsExternalOpenCode() === true;
+    let binarySource = typeof getResolvedOpenCodeBinarySource === 'function'
+      ? getResolvedOpenCodeBinarySource()
+      : null;
+    let binaryPath = typeof getResolvedOpenCodeBinary === 'function'
+      ? getResolvedOpenCodeBinary()
+      : null;
+    try {
+      const settings = await readSettingsFromDiskMigrated();
+      const resolution = await getOpenCodeResolutionSnapshot(settings);
+      binarySource = binarySource || resolution?.source || resolution?.detectedSourceNow || null;
+      binaryPath = binaryPath || resolution?.resolved || null;
+      if (resolution?.source === 'bundled' || resolution?.detectedSourceNow === 'bundled') {
+        binarySource = 'bundled';
+      }
+    } catch {
+      // Resolution failures still allow ownership classification from runtime flags.
     }
-    const currentVersion = typeof health?.version === 'string' ? health.version.replace(/^v/, '') : null;
-    return { ok: true, currentVersion };
+    return classifyRuntimeOwnership({
+      isExternal,
+      isSharedService: getIsSharedOpenCodeService() === true,
+      binarySource,
+      binaryPath,
+      dataDir: resolveDataDir(),
+    });
+  };
+
+  const buildLiveContract = async ({ fresh = false } = {}) => {
+    const cached = typeof getRuntimeContract === 'function' ? getRuntimeContract() : null;
+    const serveProbe = await readOpenCodeCurrentVersion().catch(() => ({ ok: false, currentVersion: null }));
+    const serveVersion = serveProbe.currentVersion
+      || (!fresh && typeof getOpenCodeServeVersion === 'function' ? getOpenCodeServeVersion() : null);
+    const binaryPath = typeof getResolvedOpenCodeBinary === 'function' ? getResolvedOpenCodeBinary() : null;
+    const cliVersion = (typeof getOpenCodeCliVersion === 'function' ? getOpenCodeCliVersion() : null)
+      || (binaryPath ? readOpenCode2BinaryVersion(binaryPath) : null)
+      || null;
+    return evaluateRuntimeContract({
+      serveVersion,
+      cliVersion,
+      reachable: fresh ? serveProbe.ok === true : serveProbe.ok === true || Boolean(serveVersion) || Boolean(cached?.reachable),
+      authenticated: serveProbe.authenticated ?? (fresh ? null : cached?.authenticated) ?? null,
+      healthOk: serveProbe.healthOk ?? serveProbe.ok ?? (fresh ? false : cached?.healthOk) ?? null,
+      migrationAdmitTranscript: cached?.migrationExecutable ?? null,
+      migrationPhase: cached?.migrationPhase ?? null,
+      migrationError: cached?.migrationError ?? null,
+    });
+  };
+
+  const buildUpgradeStatus = async () => {
+    const ownership = await resolveOwnershipContext();
+    const contract = await buildLiveContract();
+    const activeCount = typeof getActiveSessionCount === 'function' ? Number(getActiveSessionCount()) || 0 : 0;
+    return buildUpgradeStatusSnapshot({
+      ownership,
+      serveVersion: contract.serveVersion,
+      cliVersion: contract.cliVersion,
+      targetVersion: PINNED_OPENCODE2_VERSION,
+      contract,
+      operation: upgradeOperation.getState(),
+      hasActiveTasks: activeCount > 0,
+    });
   };
 
   const parseVersionForComparison = (value) => {
@@ -183,51 +288,157 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
 
   app.post('/api/opencode/upgrade', async (req, res) => {
     try {
-      if (await isBundledOpenCodeBinaryActive()) {
-        return res.status(409).json({
+      const ownership = await resolveOwnershipContext();
+      if (!ownership.canUpgradeInApp) {
+        const status = ownership.ownership === 'external-serve' || ownership.ownership === 'bundled' ? 409 : 409;
+        return res.status(status).json({
           success: false,
-          error: 'OpenCode is bundled with OpenChamber Desktop and cannot be upgraded separately.',
+          error: ownership.guidance
+            || 'OpenChamber can only upgrade its owned OpenCode cache in-app.',
+          errorCode: ownership.reason || 'UPGRADE_NOT_MANAGED',
+          ownership: ownership.ownership,
+          management: ownership.management,
+          guidance: ownership.guidance,
         });
       }
 
-      const target = normalizeOpenCodeUpgradeTarget(req.body?.target);
-      if (!target) {
+      const rawTarget = typeof req.body?.target === 'string' && req.body.target.trim().length > 0
+        ? req.body.target.trim()
+        : undefined;
+      if (isOpenCode1xVersion(rawTarget)) {
         return res.status(400).json({
           success: false,
-          error: 'OpenCode upgrade requires a semantic version target',
+          error: 'OpenCode upgrade refuses 1.x targets. Only pinned opencode2 is allowed.',
+          errorCode: 'OPENCODE_UPGRADE_1X_REFUSED',
         });
       }
-
-      const response = await fetch(buildOpenCodeUrl('/global/upgrade', ''), {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Accept: 'application/json',
-          ...getOpenCodeAuthHeaders(),
-        },
-        body: JSON.stringify({ target }),
-      });
-      const payload = await response.json().catch(() => null);
-      if (!response.ok) {
-        return res.status(response.status).json({
+      const target = resolveOpenCode2UpgradeTarget(rawTarget);
+      const confirmActive = req.body?.confirmActiveTasks === true || req.body?.force === true;
+      const activeCount = typeof getActiveSessionCount === 'function' ? Number(getActiveSessionCount()) || 0 : 0;
+      if (activeCount > 0 && !confirmActive) {
+        return res.status(409).json({
           success: false,
-          error: readOpenCodeUpgradeError(payload, response.statusText || 'Failed to upgrade OpenCode'),
+          error: 'OpenCode has active sessions. Confirm upgrade to interrupt them, or wait until idle.',
+          errorCode: 'UPGRADE_ACTIVE_TASKS',
+          hasActiveTasks: true,
+          activeSessionCount: activeCount,
         });
       }
 
+      const begin = upgradeOperation.begin(target);
+      if (!begin.ok) {
+        return res.status(begin.status).json(begin.body);
+      }
+
+      const expectedBinaryPath = resolveOwnedCacheBinaryPath(target, { dataDir: resolveDataDir() });
+      let installedPath = expectedBinaryPath;
+      const previousBinary = getResolvedOpenCodeBinary();
+      const previousSource = getResolvedOpenCodeBinarySource();
+
       try {
-        await refreshOpenCodeAfterConfigChange('OpenCode upgrade');
-      } catch (restartError) {
+        upgradeOperation.setPhase('download');
+        installedPath = await installPinnedOpenCode2Cli({
+          version: target,
+          dataDir: resolveDataDir(),
+        });
+        const diskVersion = readOpenCode2BinaryVersion(installedPath);
+        if (diskVersion !== target) {
+          const error = new Error(
+            `Owned-cache binary version mismatch after install: expected ${target}, got ${diskVersion || 'unknown'}`,
+          );
+          error.code = 'UPGRADE_BINARY_VERSION_MISMATCH';
+          throw error;
+        }
+
+        upgradeOperation.setPhase('pin-binary', { binaryPath: installedPath });
+        if (typeof forceResolvedOpenCodeBinary !== 'function') {
+          const error = new Error('Owned-cache upgrade requires forceResolvedOpenCodeBinary');
+          error.code = 'UPGRADE_FORCE_BINARY_UNAVAILABLE';
+          throw error;
+        }
+        // Keep target identity through restart — do not rediscover global CLI.
+        forceResolvedOpenCodeBinary(installedPath, 'installed');
+
+        upgradeOperation.setPhase('restart');
+        if (typeof restartOpenCode === 'function') {
+          await restartOpenCode(ownership.ownership === 'shared-service' ? { binaryPath: installedPath } : undefined);
+        } else if (typeof refreshOpenCodeAfterConfigChange === 'function') {
+          // Fallback: still pin binary first so restart prefers owned cache.
+          await refreshOpenCodeAfterConfigChange('OpenCode owned-cache upgrade');
+        } else {
+          const error = new Error('No OpenCode restart path is configured');
+          error.code = 'UPGRADE_RESTART_UNAVAILABLE';
+          throw error;
+        }
+
+        if (typeof waitForOpenCodeReady === 'function') {
+          upgradeOperation.setPhase('wait-ready');
+          await waitForOpenCodeReady();
+        }
+
+        upgradeOperation.setPhase('verify');
+        // Re-pin after restart helpers that may clear resolution.
+        forceResolvedOpenCodeBinary(installedPath, 'installed');
+        const contract = await buildLiveContract({ fresh: true });
+        const verification = evaluateOwnedUpgradeResult({
+          targetVersion: target,
+          serveVersion: contract.serveVersion,
+          cliVersion: contract.cliVersion,
+          binaryPath: typeof getResolvedOpenCodeBinary === 'function'
+            ? getResolvedOpenCodeBinary()
+            : installedPath,
+          expectedBinaryPath: installedPath,
+          contract,
+        });
+        if (!verification.ok) {
+          const error = new Error(verification.error);
+          error.code = verification.errorCode;
+          error.serveVersion = verification.serveVersion;
+          error.contract = verification.contract;
+          throw error;
+        }
+
+        upgradeOperation.succeed({
+          serveVersion: verification.serveVersion,
+          binaryPath: installedPath,
+        });
+        return res.json({
+          success: true,
+          upgraded: true,
+          restarted: true,
+          version: verification.serveVersion,
+          targetVersion: target,
+          pinned: true,
+          supplySource: 'owned-cache',
+          ownership: ownership.ownership === 'shared-service' ? 'shared-service' : 'owned-cache',
+          binaryPath: installedPath,
+          contract: verification.contract,
+          operation: upgradeOperation.getState(),
+        });
+      } catch (upgradeError) {
+        if (previousBinary && typeof forceResolvedOpenCodeBinary === 'function') {
+          forceResolvedOpenCodeBinary(previousBinary, previousSource);
+        }
+        const message = upgradeError instanceof Error ? upgradeError.message : 'Failed to upgrade OpenCode';
+        const errorCode = upgradeError?.code || 'UPGRADE_FAILED';
+        upgradeOperation.fail({
+          error: message,
+          errorCode,
+          phase: upgradeOperation.getState().phase,
+          serveVersion: upgradeError?.serveVersion ?? null,
+          binaryPath: installedPath,
+        });
+        // Preserve previous owned cache on disk; only report failure.
         return res.status(500).json({
           success: false,
-          upgraded: true,
-          error: restartError instanceof Error
-            ? `OpenCode upgraded, but restart failed: ${restartError.message}`
-            : 'OpenCode upgraded, but restart failed',
+          upgraded: false,
+          error: message,
+          errorCode,
+          targetVersion: target,
+          operation: upgradeOperation.getState(),
+          contract: upgradeError?.contract || null,
         });
       }
-
-      return res.json({ ...(payload ?? { success: true }), restarted: true });
     } catch (error) {
       console.error('Failed to upgrade OpenCode:', error);
       return res.status(500).json({
@@ -239,74 +450,88 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
 
   app.get('/api/opencode/upgrade-status', async (_req, res) => {
     try {
-      if (await isBundledOpenCodeBinaryActive()) {
-        const current = await readOpenCodeCurrentVersion().catch(() => ({ ok: false, currentVersion: null }));
-        return res.json({
-          available: false,
-          currentVersion: current.ok ? current.currentVersion : null,
-          latestVersion: null,
-          source: 'bundled',
-        });
-      }
+      const status = await buildUpgradeStatus();
+      return res.json(status);
+    } catch (error) {
+      return res.status(500).json({
+        available: null,
+        error: error instanceof Error ? error.message : 'Failed to check OpenCode upgrade status',
+        operation: upgradeOperation.getState(),
+      });
+    }
+  });
 
-      const [healthResponse, latestVersion] = await Promise.all([
-        fetch(buildOpenCodeUrl('/global/health', ''), {
-          method: 'GET',
-          headers: { Accept: 'application/json', ...getOpenCodeAuthHeaders() },
-        }),
-        fetchLatestOpenCodeVersion(),
-      ]);
-      const health = await healthResponse.json().catch(() => null);
-      if (!healthResponse.ok) {
-        return res.status(healthResponse.status).json({
-          available: null,
-          error: health?.error || healthResponse.statusText || 'Failed to read OpenCode version',
-        });
-      }
-      const currentVersion = typeof health?.version === 'string' ? health.version.replace(/^v/, '') : null;
-      if (!currentVersion || !latestVersion) {
-        return res.json({ available: null, currentVersion, latestVersion: latestVersion || null });
-      }
-      const available = compareVersions(latestVersion, currentVersion) > 0;
+  app.get('/api/opencode/contract', async (_req, res) => {
+    try {
+      const contract = await buildLiveContract();
+      const ownership = await resolveOwnershipContext();
       return res.json({
-        available,
-        currentVersion,
-        latestVersion,
+        ...contract,
+        ownership: ownership.ownership,
+        supplySource: ownership.supplySource,
+        canManageUpgrade: ownership.canUpgradeInApp,
+        management: ownership.management,
+        guidance: ownership.guidance,
       });
     } catch (error) {
       return res.status(500).json({
-        available: null,
-        error: error instanceof Error ? error.message : 'Failed to check OpenCode upgrade status',
+        schemaVersion: 1,
+        phase: 'unknown',
+        executionAllowed: false,
+        error: error instanceof Error ? error.message : 'Failed to evaluate OpenCode runtime contract',
       });
     }
   });
 
   app.get('/api/opencode/health', async (_req, res) => {
     try {
-      const healthResponse = await fetch(buildOpenCodeUrl('/global/health', ''), {
+      const healthResponse = await fetch(buildOpenCodeUrl('/api/info', ''), {
         method: 'GET',
         headers: { Accept: 'application/json', ...getOpenCodeAuthHeaders() },
         signal: AbortSignal.timeout(4_000),
       });
       const health = await healthResponse.json().catch(() => null);
       if (!healthResponse.ok) {
+        const contract = evaluateRuntimeContract({
+          reachable: false,
+          authenticated: healthResponse.status === 401 || healthResponse.status === 403 ? false : null,
+          healthOk: false,
+        });
         return res.status(healthResponse.status).json({
           healthy: false,
           error: health?.error || healthResponse.statusText || 'OpenCode health check failed',
+          contract,
         });
       }
-      return res.json({ healthy: health?.healthy === true });
+      // Reuse lifecycle/sidecar gate: official 2.x ServerInfo omits `healthy`.
+      const gate = evaluateOpenCodeHealthBody(health);
+      const contract = await buildLiveContract().catch(() => evaluateRuntimeContract({
+        serveVersion: gate.version,
+        reachable: gate.ok,
+        authenticated: true,
+        healthOk: gate.ok,
+      }));
+      return res.json({
+        healthy: gate.ok,
+        version: gate.version,
+        // Healthy is reachability/version shape only — not full execution semantics.
+        executionAllowed: contract.executionAllowed === true,
+        protocolCompatible: contract.protocolCompatible === true,
+        contract,
+      });
     } catch (error) {
       return res.status(503).json({
         healthy: false,
         error: error instanceof Error ? error.message : 'OpenCode health check failed',
+        contract: evaluateRuntimeContract({ reachable: false, healthOk: false }),
       });
     }
   });
 
   app.get('/api/opencode/version', async (_req, res) => {
     try {
-      const healthResponse = await fetch(buildOpenCodeUrl('/global/health', ''), {
+      const contract = await buildLiveContract();
+      const healthResponse = await fetch(buildOpenCodeUrl('/api/info', ''), {
         method: 'GET',
         headers: { Accept: 'application/json', ...getOpenCodeAuthHeaders() },
       });
@@ -314,11 +539,20 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
       if (!healthResponse.ok) {
         return res.status(healthResponse.status).json({
           version: null,
+          serveVersion: null,
+          cliVersion: contract.cliVersion,
           error: health?.error || healthResponse.statusText || 'Failed to read OpenCode version',
+          contract,
         });
       }
       const version = typeof health?.version === 'string' ? health.version.replace(/^v/, '') : null;
-      return res.json({ version });
+      return res.json({
+        version,
+        serveVersion: version,
+        cliVersion: contract.cliVersion,
+        versionMismatch: Boolean(version && contract.cliVersion && version !== contract.cliVersion),
+        contract,
+      });
     } catch (error) {
       return res.status(500).json({
         version: null,
@@ -606,13 +840,6 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
 
       await fs.promises.writeFile(AGENTS_MD_PATH, content, 'utf8');
 
-      // Refresh OpenCode so it picks up the new AGENTS.md without a full restart
-      try {
-        await refreshOpenCodeAfterConfigChange('global behavior (AGENTS.md) updated');
-      } catch {
-        // Non-fatal: file was written successfully
-      }
-
       return res.json({ success: true });
     } catch (error) {
       console.error('Failed to write AGENTS.md:', error);