antechamber 1.0.26 → 1.0.28

package/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.28] - 2026-10-28
+
+- fix(mcp): sign in to MCP servers without a running OmO session (#79)
+
+## [1.0.27] - 2026-10-28
+
+### Fixed
+
+- Sign in to an MCP server from OpenChamber without a running OmO session in that directory. The sign-in now runs in
+  an agent started for it alone, which stops once the sign-in completes, is cancelled or expires, and every running
+  session reconnects the server afterwards so it picks up the new token.
+- Find OmO's builtin `/mcp` command when an extension such as `pi-mcp-adapter` also registers `mcp` and OmO renames
+  the builtin to `mcp:1`. MCP sign-in used to fail there with "Unknown command /mcp".
+
 ## [1.0.26] - 2026-10-28
 
 ### Fixed

package/dist/mcp.d.ts

@@ -5,7 +5,10 @@
  * Everything therefore targets the most recently used LIVE session in the directory; a
  * dormant session is never revived just to answer an MCP request. Status reads for a
  * directory without one fall back to the most recently used live session elsewhere.
- * Authorization stays scoped to the directory.
+ * Authorization in a directory without one runs in an agent spawned for that flow alone
+ * (`--no-session`), disposed once the flow completes, fails, is cancelled or expires.
+ * OmO stores tokens globally, so a completed sign-in reconnects the server in every other
+ * live session.
  *
  * Status comes from the read-only `get_loaded_surfaces` RPC. Authorization drives OmO's
  * documented `/mcp` subcommands (docs/mcp.md "Auth"):
@@ -17,6 +20,8 @@
  * Commands are sent straight to the agent, outside the conversation queue: they neither
  * wait behind a running turn nor create a user message, and the session is held active so
  * the reaper cannot stop the process (and its listener or pending state) mid-flow.
+ * An extension that registers its own `mcp` command makes OmO rename the builtin (`mcp:1`),
+ * so the builtin is found by its source, not by name.
  */
 import type { RouteServices } from "./route-services.js";
 type OCMcpStatus = {
@@ -67,6 +72,8 @@ export declare function authorizationUrl(text: string, name: string): string | u
  * authorization request's own `redirect_uri` and `state`.
  */
 export declare function redirectInput(authorization: string, input: string): string | undefined;
+/** Stops the agents spawned for sign-ins; live sessions are stopped by their own manager. */
+export declare function disposeMcpAgents(): Promise<void>;
 export declare function mcpRoute(services: RouteServices, method: string, path: string, directory: string, body: () => Promise<unknown>): Promise<RouteResult | undefined>;
 export declare function mcpRouteV2(services: RouteServices, method: string, path: string, directory: string, body: () => Promise<unknown>): Promise<RouteResult | undefined>;
 export {};

package/dist/mcp.js

@@ -5,7 +5,10 @@
  * Everything therefore targets the most recently used LIVE session in the directory; a
  * dormant session is never revived just to answer an MCP request. Status reads for a
  * directory without one fall back to the most recently used live session elsewhere.
- * Authorization stays scoped to the directory.
+ * Authorization in a directory without one runs in an agent spawned for that flow alone
+ * (`--no-session`), disposed once the flow completes, fails, is cancelled or expires.
+ * OmO stores tokens globally, so a completed sign-in reconnects the server in every other
+ * live session.
  *
  * Status comes from the read-only `get_loaded_surfaces` RPC. Authorization drives OmO's
  * documented `/mcp` subcommands (docs/mcp.md "Auth"):
@@ -17,9 +20,12 @@
  * Commands are sent straight to the agent, outside the conversation queue: they neither
  * wait behind a running turn nor create a user message, and the session is held active so
  * the reaper cannot stop the process (and its listener or pending state) mid-flow.
+ * An extension that registers its own `mcp` command makes OmO rename the builtin (`mcp:1`),
+ * so the builtin is found by its source, not by name.
  */
 import { randomUUID } from "node:crypto";
 import { errorBody } from "./http.js";
+import { PiRpcClient } from "./pi-rpc.js";
 /** Bounds how long an HTTP caller waits on a read-only RPC; the transport keeps its own budget. */
 const MCP_READ_WAIT_MS = 5_000;
 /** OmO announces the authorization URL before it waits for the browser. */
@@ -32,6 +38,7 @@ const MCP_AUTH_ATTEMPT_TTL_MS = 10 * 60_000;
 const SERVER_NAME = /^[^\s"'\\]+$/;
 const INTEGRATION_PREFIX = "mcp_";
 const OAUTH_METHOD_ID = "oauth";
+const BUILTIN_MCP_PATH = "<builtin:mcp>";
 const flows = new Map();
 const admissions = new Map();
 function isRecord(value) {
@@ -95,11 +102,15 @@ async function directoryServers(sessions, directory) {
     const live = liveSession(sessions, directory) ?? (fallback === undefined ? undefined : { pi: fallback });
     return live === undefined ? [] : loadedServers(live.pi).catch(() => []);
 }
-async function hasMcpCommand(pi) {
+/** The builtin MCP command's name in this agent; builds without `sourceInfo` only know it as `mcp`. */
+async function mcpCommandName(pi) {
     const response = await pi.probe({ type: "get_commands" }, undefined, AbortSignal.timeout(MCP_READ_WAIT_MS));
     if (!response.success || !isRecord(response.data) || !Array.isArray(response.data.commands))
-        return false;
-    return response.data.commands.some((command) => isRecord(command) && command.name === "mcp" && command.source === "extension");
+        return undefined;
+    const commands = response.data.commands.flatMap((command) => isRecord(command) && command.source === "extension" && typeof command.name === "string"
+        ? [{ name: command.name, builtin: isRecord(command.sourceInfo) && command.sourceInfo.path === BUILTIN_MCP_PATH }]
+        : []);
+    return (commands.find((command) => command.builtin) ?? commands.find((command) => command.name === "mcp"))?.name;
 }
 /** The URL OmO prints on its own line after naming the server (`auth` and `auth-start` both do). */
 export function authorizationUrl(text, name) {
@@ -151,7 +162,7 @@ function sameCallback(target, authorization) {
     const expected = new URL(announced);
     return target.origin === expected.origin && target.pathname === expected.pathname;
 }
-function runMcpCommand(sessions, s, pi, name, args, observe = {}) {
+function runMcpCommand(sessions, s, pi, name, commandName, args, observe = {}) {
     const errors = [];
     const onEvent = (event) => {
         const entry = event.entry;
@@ -174,8 +185,8 @@ function runMcpCommand(sessions, s, pi, name, args, observe = {}) {
     };
     pi.onEvent(onEvent);
     pi.onExtensionUI(onNotify);
-    return sessions.lifecycle
-        .use(s, () => pi.command({ type: "prompt", message: `/mcp ${args}`, expandPromptTemplates: true }, MCP_AUTH_COMMAND_TIMEOUT_MS))
+    const send = () => pi.command({ type: "prompt", message: `/${commandName} ${args}`, expandPromptTemplates: true }, MCP_AUTH_COMMAND_TIMEOUT_MS);
+    return (s === undefined ? send() : sessions.lifecycle.use(s, send))
         .then((response) => {
         if (!response.success)
             throw new Error(response.error ?? "OmO rejected the /mcp command");
@@ -193,11 +204,57 @@ function runMcpCommand(sessions, s, pi, name, args, observe = {}) {
 function announce(services, directory, name) {
     services.broadcast(directory, { type: "mcp.tools.changed", properties: { server: name } });
 }
+/** Other live sessions keep their own connection, which still lacks the new token until it reconnects. */
+function authorized(services, directory, name, flow) {
+    announce(services, directory, name);
+    const reconnects = services.sessions.liveSessions().flatMap((s) => {
+        const pi = s.pi;
+        if (pi === undefined || pi === flow.pi)
+            return [];
+        return [
+            mcpCommandName(pi)
+                .then((commandName) => commandName === undefined
+                ? undefined
+                : runMcpCommand(services.sessions, s, pi, name, commandName, `reconnect ${name}`))
+                .catch((error) => console.error(`[mcp] reconnecting ${name} in session ${s.info.id} failed: ${errorMessage(error)}`)),
+        ];
+    });
+    if (reconnects.length > 0)
+        void Promise.all(reconnects).then(() => announce(services, directory, name));
+}
+function agentCurrent(flow) {
+    return flow.s === undefined ? !flow.released : flow.s.pi === flow.pi;
+}
+function release(flow) {
+    if (flow.s !== undefined)
+        return;
+    flow.released = true;
+    clearTimeout(flow.expiry);
+    void flow.pi
+        .dispose()
+        .catch((error) => console.error(`[mcp] stopping an auth agent failed: ${errorMessage(error)}`));
+}
+/** Stops the agents spawned for sign-ins; live sessions are stopped by their own manager. */
+export async function disposeMcpAgents() {
+    const dedicated = [...flows.values()].filter((flow) => flow.s === undefined && !flow.released);
+    for (const flow of dedicated) {
+        flow.released = true;
+        clearTimeout(flow.expiry);
+    }
+    await Promise.all(dedicated.map((flow) => flow.pi.dispose()));
+}
+async function flowStatus(flow, name) {
+    if (flow.server !== undefined || !agentCurrent(flow))
+        return flow.server;
+    return currentStatus(flow.pi, name);
+}
 function pruneFlows() {
     const now = Date.now();
     for (const [key, flow] of flows)
-        if (!flow.running && (flow.s.pi !== flow.pi || now - flow.created > MCP_AUTH_ATTEMPT_TTL_MS))
+        if (!flow.running && (!agentCurrent(flow) || now - flow.created > MCP_AUTH_ATTEMPT_TTL_MS)) {
             flows.delete(key);
+            release(flow);
+        }
 }
 /** Concurrent clicks share one admission, so a second `/mcp auth` never races the first. */
 function admitFlow(services, directory, name, command) {
@@ -216,29 +273,40 @@ const inProgress = (name) => ({
 async function startFlow(services, directory, name, command) {
     if (!SERVER_NAME.test(name))
         return { error: { status: 400, body: errorBody("InvalidRequestError", "invalid MCP server name") } };
-    const live = liveSession(services.sessions, directory);
-    if (live === undefined)
-        return {
-            error: {
-                status: 400,
-                body: errorBody("McpUnavailableError", "MCP authorization needs a running OmO session in this directory"),
-            },
-        };
-    const { s, pi } = live;
     const key = flowKey(directory, name);
     pruneFlows();
     const existing = flows.get(key);
-    if (existing?.running && existing.pi === pi)
+    if (existing?.running && agentCurrent(existing))
         return existing.command === command ? { flow: existing } : inProgress(name);
-    const servers = await loadedServers(pi);
+    const live = liveSession(services.sessions, directory);
+    const s = live?.s;
+    const pi = live?.pi ?? new PiRpcClient({ cwd: directory, args: ["--no-session"] });
+    const refuse = async (status, error, message) => {
+        if (live === undefined)
+            await pi.dispose();
+        return { error: { status, body: errorBody(error, message) } };
+    };
+    let servers;
+    let commandName;
+    try {
+        // A spawned agent answers its first RPC only once it has started.
+        if (live === undefined)
+            await pi.command({ type: "get_state" });
+        servers = await loadedServers(pi);
+        commandName = await mcpCommandName(pi);
+    }
+    catch (error) {
+        return refuse(400, "McpUnavailableError", `OmO could not start for MCP authorization: ${errorMessage(error)}`);
+    }
     if (!servers.some((server) => server.name === name))
-        return { error: { status: 404, body: errorBody("McpServerNotFoundError", `MCP server not found: ${name}`) } };
-    if (!(await hasMcpCommand(pi)))
-        return { error: { status: 400, body: errorBody("UnsupportedError", "This OmO build has no /mcp command") } };
+        return refuse(404, "McpServerNotFoundError", `MCP server not found: ${name}`);
+    if (commandName === undefined)
+        return refuse(400, "UnsupportedError", "This OmO build has no /mcp command");
     const url = Promise.withResolvers();
     const flow = {
         s,
         pi,
+        commandName,
         command,
         attemptID: randomUUID(),
         created: Date.now(),
@@ -246,8 +314,16 @@ async function startFlow(services, directory, name, command) {
         done: Promise.resolve(),
         running: true,
         authorized: false,
+        released: false,
     };
-    flow.done = runMcpCommand(services.sessions, s, pi, name, `${command} ${name}`, {
+    if (live === undefined) {
+        pi.onExit(() => {
+            flow.released = true;
+        });
+        flow.expiry = setTimeout(() => release(flow), MCP_AUTH_ATTEMPT_TTL_MS);
+        flow.expiry.unref();
+    }
+    flow.done = runMcpCommand(services.sessions, s, pi, name, commandName, `${command} ${name}`, {
         url: (found) => {
             flow.authorizationUrl ??= found;
             url.resolve(found);
@@ -256,12 +332,20 @@ async function startFlow(services, directory, name, command) {
             flow.authorized = true;
         },
     })
-        .then(() => {
-        if (flow.authorized)
-            announce(services, directory, name);
+        .then(async () => {
+        if (!flow.authorized)
+            return;
+        if (live === undefined) {
+            const server = await currentStatus(pi, name).catch(() => undefined);
+            if (server !== undefined)
+                flow.server = server;
+            release(flow);
+        }
+        authorized(services, directory, name, flow);
     })
         .catch((error) => {
         flow.error = errorMessage(error);
+        release(flow);
         throw error;
     })
         .finally(() => {
@@ -269,6 +353,8 @@ async function startFlow(services, directory, name, command) {
     });
     // The caller that started the flow may already have its URL; a later failure is still reported.
     void flow.done.catch((error) => console.error(`[mcp] authorization of ${name} failed: ${errorMessage(error)}`));
+    if (existing !== undefined)
+        release(existing);
     flows.set(key, flow);
     return { flow };
 }
@@ -301,10 +387,12 @@ async function completeFlow(services, directory, name, input) {
     const fail = (status, name_, message) => ({
         error: { status, body: errorBody(name_, message) },
     });
-    if (flow === undefined || flow.s.pi !== flow.pi || Date.now() - flow.created > MCP_AUTH_ATTEMPT_TTL_MS)
+    if (flow === undefined || Date.now() - flow.created > MCP_AUTH_ATTEMPT_TTL_MS)
         return fail(400, "McpAuthError", `No pending authorization for ${name}; start it again`);
     if (flow.authorized)
-        return { server: await currentStatus(flow.pi, name) };
+        return { server: await flowStatus(flow, name) };
+    if (!agentCurrent(flow))
+        return fail(400, "McpAuthError", `No pending authorization for ${name}; start it again`);
     if (flow.error !== undefined)
         return fail(400, "McpAuthError", `Authorization of ${name} failed (${flow.error}); start it again`);
     if (typeof input !== "string" || flow.authorizationUrl === undefined)
@@ -312,11 +400,15 @@ async function completeFlow(services, directory, name, input) {
     const redirect = redirectInput(flow.authorizationUrl, input);
     if (redirect === undefined)
         return fail(400, "InvalidRequestError", "code must be an authorization code or redirect URL");
+    // OmO consumes the pending state on any answer, so a dedicated agent has nothing left to wait for.
+    let attempted = false;
+    let server;
     try {
         if (flow.running && flow.command === "auth") {
             const target = new URL(redirect);
             if (!sameCallback(target, flow.authorizationUrl))
                 return fail(400, "McpAuthError", `OmO is waiting for ${name} on its loopback callback; paste that redirect`);
+            attempted = true;
             const delivered = await fetch(target, { redirect: "manual", signal: AbortSignal.timeout(MCP_READ_WAIT_MS) });
             if (!delivered.ok) {
                 // OmO ends the flow on a rejected callback; settle it so a retry cannot join the dead flow.
@@ -326,21 +418,30 @@ async function completeFlow(services, directory, name, input) {
             await flow.done;
         }
         else {
-            await runMcpCommand(services.sessions, flow.s, flow.pi, name, `auth-complete ${name} ${redirect}`, {
+            attempted = true;
+            await runMcpCommand(services.sessions, flow.s, flow.pi, name, flow.commandName, `auth-complete ${name} ${redirect}`, {
                 authorized: () => {
                     flow.authorized = true;
                 },
             });
-            announce(services, directory, name);
+            if (flow.authorized)
+                authorized(services, directory, name, flow);
+            else
+                announce(services, directory, name);
         }
+        if (!flow.authorized)
+            return fail(400, "McpAuthError", flow.error ?? `MCP server ${name} did not complete authorization`);
+        server = await flowStatus(flow, name);
     }
     catch (error) {
         flow.error = errorMessage(error);
         return fail(400, "McpAuthError", flow.error);
     }
-    if (!flow.authorized)
-        return fail(400, "McpAuthError", flow.error ?? `MCP server ${name} did not complete authorization`);
-    return { server: await currentStatus(flow.pi, name) };
+    finally {
+        if (attempted)
+            release(flow);
+    }
+    return { server };
 }
 function decodeName(raw) {
     try {
@@ -388,7 +489,7 @@ export async function mcpRoute(services, method, path, directory, body) {
                 status: 400,
                 body: errorBody("McpAuthError", `MCP server ${name} is waiting for its authorization code; paste it to finish`),
             };
-        const server = await currentStatus(flow.pi, name);
+        const server = await flowStatus(flow, name);
         return { status: 200, body: server === undefined ? { status: "disabled" } : openCodeMcpStatus(server) };
     }
     const announced = await awaitAuthorizationUrl(flow, name);
@@ -480,8 +581,10 @@ export async function mcpRouteV2(services, method, path, directory, body) {
         return "error" in result ? result.error : { status: 204 };
     }
     if (method === "DELETE") {
-        if (flow !== undefined)
+        if (flow !== undefined) {
             flows.delete(flowKey(directory, name));
+            release(flow);
+        }
         return { status: 204 };
     }
     if (method !== "GET")

package/dist/server.js

@@ -1,6 +1,7 @@
 /** HTTP/SSE composition root for the OpenCode API backed by pi. */
 import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
+import { disposeMcpAgents } from "./mcp.js";
 import { debugLog } from "./misc-routes.js";
 import { SessionManager } from "./sessions.js";
 import { loadCatalog } from "./catalog.js";
@@ -64,7 +65,7 @@ export class AdapterServer {
             socket.destroy();
         this.webSocketClients.clear();
         try {
-            await this.sessions.disposeAll();
+            await Promise.all([this.sessions.disposeAll(), disposeMcpAgents()]);
         }
         finally {
             // An in-flight HTTP request must not hold shutdown open after teardown.

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "OpenChamber extension: displays OmO tool calls the way OmO means them when OpenChamber runs on antechamber",
   "private": true,
   "type": "module",

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",

package/extensions/omo-work/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-work",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "OpenChamber 2.x Work Status section: OmO todo phases, monitors, eval cells and background work of the current session",
   "private": true,
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",