@vantran-se/openchamber-web 1.24.4 → 2.0.2

package/server/lib/opencode/proxy-agent-wiring.test.js

@@ -79,12 +79,14 @@ describe('OpenCode API proxy agent wiring', () => {
     }
   });
 
-  it('shares one agent instance across the API and OAuth proxies', () => {
+  it('resolves an agent for the API proxy', () => {
+    // v1 also built a long-deadline proxy for the interactive provider/MCP
+    // OAuth callbacks; v2 has neither route, so there is one proxy left.
     registerOpenCodeProxy(createStubApp(), createStubDeps(managedState()));
 
     const agents = agentsFromCalls();
 
-    expect(agents.length).toBeGreaterThan(1);
+    expect(agents.length).toBeGreaterThan(0);
     expect(agents.every(Boolean)).toBe(true);
     expect(new Set(agents).size).toBe(1);
   });

package/server/lib/opencode/proxy.js

@@ -210,24 +210,30 @@ export const createSseBoundaryTracker = () => {
   };
 };
 
+/**
+ * Fields a session list is allowed to carry to the browser.
+ *
+ * The list is an allowlist, not a blocklist: OpenCode keeps adding to
+ * `SessionInfo`, and a session list is fetched constantly, so anything heavy
+ * that appears later must not silently start crossing the wire. `revert.files`
+ * and `revert.snapshot` are the expensive parts and are dropped below;
+ * `permissions` is a per-session ruleset the list view never reads.
+ */
 const SESSION_LIST_ALLOWED_FIELDS = [
   'id',
-  'slug',
-  'projectID',
-  'workspaceID',
-  'directory',
-  'path',
   'parentID',
+  'projectID',
+  'location',
+  'subpath',
   'title',
   'agent',
   'model',
-  'version',
-  'time',
   'cost',
   'tokens',
-  'share',
+  'outcome',
+  'time',
   'metadata',
-  'project',
+  'fork',
 ];
 
 const sanitizeSessionListItem = (session) => {
@@ -242,13 +248,8 @@ const sanitizeSessionListItem = (session) => {
     }
   }
 
-  const summary = session.summary;
-  if (summary && typeof summary === 'object' && !Array.isArray(summary)) {
-    const summaryWithoutDiffs = { ...summary };
-    delete summaryWithoutDiffs.diffs;
-    sanitized.summary = summaryWithoutDiffs;
-  }
-
+  // Only the revert marker: the staged file list and its snapshot are what make
+  // a reverted session's record large.
   const revert = session.revert;
   if (revert && typeof revert === 'object' && !Array.isArray(revert)) {
     const revertMarker = {};
@@ -266,18 +267,28 @@ const sanitizeSessionListItem = (session) => {
   return sanitized;
 };
 
+/**
+ * Preserve the V2 pagination envelope while sanitizing session records.
+ */
 const sanitizeSessionListPayload = (payload) => {
-  if (!Array.isArray(payload)) {
-    return payload;
+  if (Array.isArray(payload)) {
+    return payload.map((session) => sanitizeSessionListItem(session));
   }
-  return payload.map((session) => sanitizeSessionListItem(session));
+  if (payload && typeof payload === 'object' && Array.isArray(payload.data)) {
+    return { ...payload, data: payload.data.map((session) => sanitizeSessionListItem(session)) };
+  }
+  return payload;
+};
+
+const sessionListRecords = (payload) => {
+  if (Array.isArray(payload)) return payload;
+  if (payload && typeof payload === 'object' && Array.isArray(payload.data)) return payload.data;
+  return null;
 };
 
 export const registerOpenCodeProxy = (app, deps) => {
   const {
     fs,
-    os,
-    path,
     OPEN_CODE_READY_GRACE_MS,
     LONG_REQUEST_TIMEOUT_MS,
     getRuntime,
@@ -289,8 +300,91 @@ export const registerOpenCodeProxy = (app, deps) => {
     getSseUpstreamStallTimeoutMs = () => SSE_UPSTREAM_STALL_TIMEOUT_MS,
     readWorktreeBootstrapStatus = getWorktreeBootstrapStatus,
     WORKTREE_READY_TIMEOUT_MS = 5 * 60 * 1000,
+    // OpenCode 2.x has no archive route, so archive state is OpenChamber's own
+    // and the proxy folds it onto the sessions it serves (`time.archived`).
+    // Session metadata lives on OpenCode's record; the proxy lays over only
+    // the entries an older OpenChamber left in the legacy file until they are
+    // migrated.
+    getArchivedSessions = null,
+    getStoredSessionMetadata = null,
   } = deps;
 
+  /**
+   * `{ [sessionID]: archivedAt }` for the current instance, or `null` when the
+   * store cannot answer. `null` means "unknown", and an unknown answer leaves
+   * the upstream record untouched — never rewrites a session as un-archived.
+   */
+  const readArchivedSessions = async () => {
+    if (typeof getArchivedSessions !== 'function') return null;
+    try {
+      const archived = await getArchivedSessions();
+      return archived && typeof archived === 'object' ? archived : null;
+    } catch (error) {
+      console.warn('[proxy] archive state unavailable:', error?.message ?? error);
+      return null;
+    }
+  };
+
+  /**
+   * `{ [sessionID]: metadata }` still waiting to be migrated to OpenCode, or
+   * `null` when the store cannot answer. `null` means "unknown", and an
+   * unknown answer leaves the upstream record untouched.
+   */
+  const readStoredSessionMetadata = async () => {
+    if (typeof getStoredSessionMetadata !== 'function') return null;
+    try {
+      const stored = await getStoredSessionMetadata();
+      // Nothing left to migrate is the normal state: skip the rewrite entirely.
+      return stored && typeof stored === 'object' && Object.keys(stored).length > 0 ? stored : null;
+    } catch (error) {
+      console.warn('[proxy] session metadata unavailable:', error?.message ?? error);
+      return null;
+    }
+  };
+
+  // A number archives, `null` is an explicit unarchive (drops the stamp OpenCode
+  // still carries for a session migrated from v1), and a session the file does
+  // not mention keeps whatever OpenCode says.
+  const withArchivedAt = (session, archived) => {
+    if (!session || typeof session !== 'object' || typeof session.id !== 'string') return session;
+    if (!Object.prototype.hasOwnProperty.call(archived, session.id)) return session;
+    const archivedAt = archived[session.id];
+    const time = session.time && typeof session.time === 'object' ? session.time : {};
+    if (typeof archivedAt === 'number') {
+      return { ...session, time: { ...time, archived: archivedAt } };
+    }
+    if (!('archived' in time)) return session;
+    const { archived: _dropped, ...rest } = time;
+    return { ...session, time: rest };
+  };
+
+  /**
+   * A legacy entry is the newest metadata its session has, including {}, so it
+   * replaces the upstream record until migration pushes it there.
+   */
+  const withStoredMetadata = (session, stored) => {
+    if (!session || typeof session !== 'object' || typeof session.id !== 'string') return session;
+    const ours = stored[session.id];
+    if (!ours || typeof ours !== 'object' || Array.isArray(ours)) return session;
+    return { ...session, metadata: ours };
+  };
+
+  const overlaySession = (session, archived, stored) => {
+    let result = session;
+    if (archived) result = withArchivedAt(result, archived);
+    if (stored) result = withStoredMetadata(result, stored);
+    return result;
+  };
+
+  const overlayOwnedStateOnList = async (payload) => {
+    const records = sessionListRecords(payload);
+    if (!records) return payload;
+    const [archived, stored] = await Promise.all([readArchivedSessions(), readStoredSessionMetadata()]);
+    if (!archived && !stored) return payload;
+    const overlaid = records.map((session) => overlaySession(session, archived, stored));
+    return Array.isArray(payload) ? overlaid : { ...payload, data: overlaid };
+  };
+
   if (app.get('opencodeProxyConfigured')) {
     return;
   }
@@ -412,15 +506,9 @@ export const registerOpenCodeProxy = (app, deps) => {
   const PROXY_REQUEST_TIMEOUT_MS = normalizeProxyTimeout(LONG_REQUEST_TIMEOUT_MS);
   const PROXY_TIMEOUT_MARKER = Symbol('openchamberProxyTimedOut');
 
-  // A provider OAuth callback blocks upstream for as long as the user takes to
-  // sign in in their browser (device-code polling, or a loopback redirect), so
-  // it cannot share the ordinary request deadline. Bounded by the shortest
-  // upstream expiry we know of — GitHub device codes last ~15 minutes.
-  const INTERACTIVE_OAUTH_TIMEOUT_MS = 15 * 60 * 1000;
-  const INTERACTIVE_OAUTH_PATH = /^\/provider\/[^/]+\/oauth\/callback\/?$/;
-
-  const isInteractiveOAuthCallback = (req) =>
-    req.method === 'POST' && INTERACTIVE_OAUTH_PATH.test(req.path);
+  // OpenCode 2.x runs provider connection through `/api/integration/*`, whose
+  // OAuth steps return immediately and are polled, so no route needs a deadline
+  // longer than the ordinary one any more.
 
   const isProxyTimeoutError = (error) => {
     const code = typeof error?.code === 'string' ? error.code : '';
@@ -440,10 +528,6 @@ export const registerOpenCodeProxy = (app, deps) => {
   };
 
   const applyProxyResponseDeadline = (req, res, next) => {
-    if (isInteractiveOAuthCallback(req)) {
-      return next();
-    }
-
     const timeout = setTimeout(() => {
       req[PROXY_TIMEOUT_MARKER] = true;
       if (sendProxyErrorResponse(res, 504)) {
@@ -475,7 +559,7 @@ export const registerOpenCodeProxy = (app, deps) => {
       const requestUrl = typeof req.originalUrl === 'string' && req.originalUrl.length > 0
         ? req.originalUrl
         : (typeof req.url === 'string' ? req.url : '');
-      const upstreamPath = requestUrl.startsWith('/api') ? requestUrl.slice(4) || '/' : requestUrl;
+      const upstreamPath = requestUrl;
       const headers = normalizeForwardedDirectoryHeaders(
         collectForwardProxyHeaders(req.headers, getOpenCodeAuthHeaders())
       );
@@ -653,8 +737,9 @@ export const registerOpenCodeProxy = (app, deps) => {
     const requestUrl = typeof req.originalUrl === 'string' && req.originalUrl.length > 0
       ? req.originalUrl
       : (typeof req.url === 'string' ? req.url : '');
-    const upstreamPathRaw = requestUrl.startsWith('/api') ? requestUrl.slice(4) || '/' : requestUrl;
-    return canonicalizeDirectoryQuery(upstreamPathRaw);
+    // OpenCode 2.x serves everything under `/api/*` itself, so the upstream
+    // path is the request path — nothing is stripped.
+    return canonicalizeDirectoryQuery(requestUrl);
   };
 
   const forwardSanitizedSessionListRequest = async (req, res, next, logLabel) => {
@@ -671,14 +756,14 @@ export const registerOpenCodeProxy = (app, deps) => {
         return;
       }
 
-      if (result.parseError || !Array.isArray(result.payload)) {
+      if (result.parseError || !sessionListRecords(result.payload)) {
         res.setHeader('content-type', result.contentType);
         res.end(result.bodyText);
         return;
       }
 
       res.setHeader('content-type', result.contentType);
-      res.json(sanitizeSessionListPayload(result.payload));
+      res.json(await overlayOwnedStateOnList(sanitizeSessionListPayload(result.payload)));
     } catch (error) {
       if (isAbortError(error)) {
         return;
@@ -719,7 +804,7 @@ export const registerOpenCodeProxy = (app, deps) => {
   const classifyReadinessRoute = (requestPath) => {
     if (/^\/session\/[^/]+\/message(?:\/|$)/.test(requestPath)) return 'session-messages';
     if (requestPath === '/session' || requestPath.startsWith('/session/')) return 'session';
-    if (requestPath === '/event' || requestPath === '/global/event') return 'events';
+    if (requestPath === '/event') return 'events';
     return 'other';
   };
 
@@ -808,103 +893,68 @@ export const registerOpenCodeProxy = (app, deps) => {
     }
   });
 
-  // Windows: session merge for cross-directory session listing
-  if (process.platform === 'win32') {
-    app.get('/api/session', async (req, res, next) => {
-      const rawUrl = req.originalUrl || req.url || '';
-      if (rawUrl.includes('directory=')) return next();
-
-      const fetchWindowsSessionList = async (sessionPath) => {
-        const result = await fetchSessionListPayload(sessionPath, { req, timeoutMs: 10000 });
-        if (!result.upstream.ok || !Array.isArray(result.payload)) return null;
-        return sanitizeSessionListPayload(result.payload);
-      };
-
-      try {
-        const globalSessions = await fetchWindowsSessionList('/session').catch((error) => {
-          console.log(`[SessionMerge] Global session list failed: ${error.message}`);
-          return null;
-        });
+  // V2 lists sessions across directories on every platform and owns pagination.
+  app.get('/api/session', (req, res, next) => {
+    return forwardSanitizedSessionListRequest(req, res, next, 'session.list');
+  });
 
-        const settingsPath = path.join(os.homedir(), '.config', 'openchamber', 'settings.json');
-        let projectDirs = [];
-        try {
-          const settingsRaw = fs.readFileSync(settingsPath, 'utf8');
-          const settings = JSON.parse(settingsRaw);
-          projectDirs = (settings.projects || [])
-            .map((project) => (typeof project?.path === 'string' ? project.path.trim() : ''))
-            .filter(Boolean);
-        } catch {
-        }
+  // One session: the same overlay, so a detail read agrees with the list it
+  // came from. Everything else about the record is forwarded untouched.
+  app.get('/api/session/:sessionID', async (req, res, next) => {
+    if (typeof getArchivedSessions !== 'function' && typeof getStoredSessionMetadata !== 'function') return next();
+    try {
+      const upstreamPath = await getRequestUpstreamPath(req);
+      const result = await fetchSessionListPayload(upstreamPath, { req });
 
-        const seen = new Set(
-          (globalSessions || [])
-            .map((session) => (session && typeof session.id === 'string' ? session.id : null))
-            .filter((id) => typeof id === 'string')
-        );
-        const extraSessions = [];
-        let successfulProjectReads = 0;
-        for (const dir of projectDirs) {
-          const candidates = Array.from(new Set([
-            dir,
-            dir.replace(/\\/g, '/'),
-            dir.replace(/\//g, '\\'),
-          ]));
-          for (const candidateDir of candidates) {
-            const encoded = encodeURIComponent(candidateDir);
-            try {
-              const dirSessions = await fetchWindowsSessionList(`/session?directory=${encoded}`);
-              if (dirSessions) {
-                successfulProjectReads += 1;
-              }
-              for (const session of dirSessions || []) {
-                const id = session && typeof session.id === 'string' ? session.id : null;
-                if (id && !seen.has(id)) {
-                  seen.add(id);
-                  extraSessions.push(session);
-                }
-              }
-            } catch {
-            }
-          }
-        }
+      res.status(result.upstream.status);
+      applyForwardProxyResponseHeaders(result.upstream.headers, res);
+      res.setHeader('content-type', result.contentType);
 
-        if (!globalSessions && successfulProjectReads === 0) {
-          return res.status(504).json({ error: 'OpenCode session list timed out' });
-        }
+      const record = result.isJson && !result.parseError ? result.payload : null;
+      const session = record && typeof record === 'object' && !Array.isArray(record)
+        ? (record.data && typeof record.data === 'object' ? record.data : record)
+        : null;
+      if (!session || typeof session.id !== 'string') {
+        res.end(result.bodyText);
+        return;
+      }
 
-        const merged = [...(globalSessions || []), ...extraSessions];
-        merged.sort((a, b) => {
-          const aTime = a && typeof a.time_updated === 'number' ? a.time_updated : 0;
-          const bTime = b && typeof b.time_updated === 'number' ? b.time_updated : 0;
-          return bTime - aTime;
-        });
-        console.log(`[SessionMerge] ${globalSessions?.length || 0} global + ${extraSessions.length} extra = ${merged.length} total`);
-        return res.json(sanitizeSessionListPayload(merged));
-      } catch (error) {
-        console.log(`[SessionMerge] Error: ${error.message}`);
-        return res.status(500).json({ error: error.message || 'Failed to merge Windows sessions' });
+      const [archived, stored] = await Promise.all([readArchivedSessions(), readStoredSessionMetadata()]);
+      if (!archived && !stored) {
+        res.end(result.bodyText);
+        return;
       }
-    });
-  }
 
-  app.get('/api/session', (req, res, next) => {
-    return forwardSanitizedSessionListRequest(req, res, next, 'session.list');
+      const overlaid = overlaySession(session, archived, stored);
+      res.json(record.data && typeof record.data === 'object' ? { ...record, data: overlaid } : overlaid);
+    } catch (error) {
+      if (isAbortError(error)) return;
+      console.error('[proxy] OpenCode session.get proxy error:', error?.message ?? error);
+      if (!res.headersSent) {
+        res.status(503).json({ error: 'OpenCode service unavailable' });
+        return;
+      }
+      next(error);
+    }
   });
 
-  app.get('/api/global/event', forwardSseRequest);
-  app.get('/api/event', forwardSseRequest);
-
-  app.get('/api/experimental/session', (req, res, next) => {
-    return forwardSanitizedSessionListRequest(req, res, next, 'experimental.session');
+  // v2 has one event stream. `/api/global/event` stays as an alias so a client
+  // that has not reloaded yet keeps working; both reach upstream `/api/event`.
+  app.get('/api/global/event', (req, res, next) => {
+    req.url = req.url.replace('/api/global/event', '/api/event');
+    if (typeof req.originalUrl === 'string') {
+      req.originalUrl = req.originalUrl.replace('/api/global/event', '/api/event');
+    }
+    return forwardSseRequest(req, res, next);
   });
+  app.get('/api/event', forwardSseRequest);
 
   // Generic proxy for non-SSE OpenCode API routes.
   // The agent is exposed as a getter so its class is resolved per request, not
   // at registration: the proxy is registered before OpenCode bootstraps, so an
   // https target configured via OPENCODE_HOST is not yet visible here. Agents
   // are memoized per scheme, so this is still one shared pool per scheme across
-  // `apiProxy` and `interactiveOAuthProxy`.
+  // `apiProxy`.
   const resolveOpenCodeProxyAgent = createOpenCodeProxyAgentResolver(resolveProxyTarget);
 
   const createApiProxy = (timeoutMs) => createProxyMiddleware({
@@ -913,9 +963,12 @@ export const registerOpenCodeProxy = (app, deps) => {
       return resolveOpenCodeProxyAgent();
     },
     changeOrigin: true,
-    pathRewrite: { '^/api': '' },
     timeout: timeoutMs,
     proxyTimeout: timeoutMs,
+    // The proxy is mounted on `/api`, so Express has already stripped that
+    // prefix by the time the middleware sees the request. OpenCode 2.x serves
+    // everything under `/api/*` itself, so put it back.
+    pathRewrite: (proxiedPath) => `/api${proxiedPath === '/' ? '' : proxiedPath}`,
     // Dynamic target — port can change after restart
     router: () => resolveProxyTarget(),
     on: {
@@ -963,7 +1016,6 @@ export const registerOpenCodeProxy = (app, deps) => {
   });
 
   const apiProxy = createApiProxy(PROXY_REQUEST_TIMEOUT_MS);
-  const interactiveOAuthProxy = createApiProxy(INTERACTIVE_OAUTH_TIMEOUT_MS);
 
   // Best-effort fallback for stale clients still sending symlink paths.
   // Settings and project selection normalize at source; this cached async path
@@ -981,10 +1033,8 @@ export const registerOpenCodeProxy = (app, deps) => {
   });
 
   app.use('/api', applyProxyResponseDeadline);
-  app.post('/api/provider/:providerID/oauth/callback', interactiveOAuthProxy);
-  // OpenCode's native MCP OAuth flow: the request blocks until the user
-  // finishes authorization in the browser (up to OpenCode's 5-minute callback
-  // timeout), so it needs the interactive-OAuth deadline, not the default one.
-  app.post('/api/mcp/:name/auth/authenticate', interactiveOAuthProxy);
+  // v1's interactive provider/MCP OAuth callbacks are gone: v2 runs provider
+  // connection through `/api/integration/*`, which answers immediately and
+  // needs no special deadline.
   app.use('/api', apiProxy);
 };

package/server/lib/opencode/pwa-manifest-routes.js

@@ -101,7 +101,7 @@ export const registerPwaManifestRoute = (app, dependencies) => {
         return `?directory=${encodeURIComponent(preparedDirectory)}`;
       })();
 
-      const response = await fetch(buildOpenCodeUrl(`/session${query}`, ''), {
+      const response = await fetch(buildOpenCodeUrl(`/api/session${query}`, ''), {
         method: 'GET',
         headers: {
           Accept: 'application/json',
@@ -114,7 +114,9 @@ export const registerPwaManifestRoute = (app, dependencies) => {
         return [];
       }
 
-      const payload = await response.json().catch(() => null);
+      // v2 pages the session list as `{ data, cursor }`.
+      const body = await response.json().catch(() => null);
+      const payload = Array.isArray(body) ? body : body?.data;
       return Array.isArray(payload) ? payload : [];
     };
 

package/server/lib/opencode/pwa-manifest-routes.test.js

@@ -41,9 +41,10 @@ describe('PWA manifest route', () => {
               time: { updated: 2 },
             },
           ];
+      // v2 pages the session list as `{ data, cursor }`.
       return {
         ok: true,
-        json: async () => sessions,
+        json: async () => ({ data: sessions, cursor: {} }),
       };
     };
 
@@ -118,7 +119,7 @@ describe('PWA manifest route', () => {
       await handler({ query: {} }, res);
 
       const manifest = JSON.parse(res.body);
-      expect(fetchCalls).toEqual(['/session?directory=%2F']);
+      expect(fetchCalls).toEqual(['/api/session?directory=%2F']);
       expect(manifest.shortcuts).toContainEqual({
         name: 'Root child',
         short_name: 'Root child',

package/server/lib/opencode/response-envelope.js

@@ -0,0 +1,14 @@
+/**
+ * OpenCode 2.x wraps `/api/*` answers in an envelope, and not always the same
+ * one: a single record (`GET /api/session/:id`, one message) comes back as
+ * `{ data }`, some routes (`/api/command`) as `{ location, data }`, and pages
+ * as `{ data, cursor }`. Records and plain lists are unwrapped; a page keeps
+ * its envelope because callers read its cursor.
+ *
+ * Unwrapping only when `location` was present left record envelopes in place,
+ * so a session's `parentID` and a message's `id` read as missing.
+ */
+export const unwrapOpenCodeResponse = (body) => {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return body;
+  return 'data' in body && !('cursor' in body) ? body.data : body;
+};

package/server/lib/opencode/response-envelope.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+
+import { unwrapOpenCodeResponse } from './response-envelope.js';
+
+describe('unwrapOpenCodeResponse', () => {
+  it('unwraps a single record sent as { data } alone', () => {
+    expect(unwrapOpenCodeResponse({ data: { id: 'ses_1', parentID: 'ses_0' } })).toEqual({ id: 'ses_1', parentID: 'ses_0' });
+  });
+
+  it('unwraps a { location, data } answer', () => {
+    expect(unwrapOpenCodeResponse({ location: { directory: '/repo' }, data: [{ name: 'review' }] })).toEqual([{ name: 'review' }]);
+  });
+
+  it('keeps a page envelope so its cursor stays readable', () => {
+    const page = { data: [{ id: 'ses_1' }], cursor: { next: 'c1' } };
+    expect(unwrapOpenCodeResponse(page)).toBe(page);
+  });
+
+  it('passes through what is not an envelope', () => {
+    expect(unwrapOpenCodeResponse(null)).toBe(null);
+    expect(unwrapOpenCodeResponse([1])).toEqual([1]);
+  });
+});