antechamber 1.0.30 → 1.0.32

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.32] - 2026-10-29
+
+### Fixed
+
+- Stop killing the agent when a shell command run from the composer takes longer than a minute, such as an
+  interactive login. A user shell now runs until its command exits or you press Stop; only a shell that OmO still
+  has not answered a minute after Stop stops the agent.
+- Show a shell command's output live in its card while it runs, so a link or code a command prints before it waits
+  (such as a login URL) can be copied. Before, the card stayed empty until the command ended. A command you stop
+  keeps the output it printed.
+
+## [1.0.31] - 2026-10-29
+
+### Fixed
+
+- Show the MCP servers and their count before a session runs. A directory with no running agent used to report no servers,
+  so the sidebar's "MCP servers" count sat at 0 in a new chat, on a dormant project and after the idle reaper stopped the
+  last agent. The servers are now read by a short-lived agent started for that read alone.
+- Keep that list current: antechamber announces `mcp.status.changed` when an agent starts, stops or reports new MCP state,
+  so OpenChamber re-reads instead of keeping a stale count (it treats an answer as fresh for a minute).
+- Stop a sign-in from failing with "pi process disposed" when OmO answers `auth-start` only while `auth-complete` is
+  already running. The agent started for the sign-in was stopped mid-command; the completion now owns it until it ends.
+
 ## [1.0.30] - 2026-10-28
 
 - update

package/dist/mcp.d.ts

@@ -72,6 +72,11 @@ export declare function v2McpStatus(server: OmoMcpServer): V2McpStatus;
  * all connected within about a second, each change announced by `loaded_surfaces_changed`.
  */
 export declare function waitForMcpServers(pi: PiRpcClient, budgetMs: number, signal?: AbortSignal): Promise<void>;
+/**
+ * An agent started, stopped or reported new MCP state. Every directory a client read is told to read
+ * again: with the cross-directory fallback, one agent can change the answer for all of them.
+ */
+export declare function mcpSurfacesChanged(broadcast: RouteServices["broadcast"]): void;
 /** The URL OmO prints on its own line after naming the server (`auth` and `auth-start` both do). */
 export declare function authorizationUrl(text: string, name: string): string | undefined;
 /**
@@ -80,7 +85,7 @@ 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. */
+/** Stops the agents spawned for sign-ins and inventories; 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>;

package/dist/mcp.js

@@ -39,8 +39,18 @@ const SERVER_NAME = /^[^\s"'\\]+$/;
 const INTEGRATION_PREFIX = "mcp_";
 const OAUTH_METHOD_ID = "oauth";
 const BUILTIN_MCP_PATH = "<builtin:mcp>";
+/** How long an inventory read without a running agent is reused. */
+const MCP_INVENTORY_TTL_MS = 30_000;
+/** A fresh agent answers `get_state` once its extensions loaded, about 1.3 s on a typical install. */
+const MCP_INVENTORY_START_MS = 15_000;
+/** OmO reports each server settling separately at startup; one announcement covers the burst. */
+const MCP_CHANGE_DEBOUNCE_MS = 250;
 const flows = new Map();
 const admissions = new Map();
+const watchedDirectories = new Set();
+const inventories = new Map();
+const inventoryAgents = new Set();
+let changeTimer;
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -141,11 +151,58 @@ export async function waitForMcpServers(pi, budgetMs, signal) {
     }
 }
 async function directoryServers(sessions, directory) {
-    // A directory whose sessions are all dormant would list nothing. Its servers are mostly
-    // the user's global and built-in ones, so any running session gives a better answer.
-    const fallback = sessions.liveSessions()[0]?.pi;
-    const live = liveSession(sessions, directory) ?? (fallback === undefined ? undefined : { pi: fallback });
-    return live === undefined ? [] : loadedServers(live.pi).catch(() => []);
+    watchedDirectories.add(directory);
+    // A directory whose sessions are all dormant reads a running session elsewhere: its servers are
+    // mostly the user's global and built-in ones. An agent that just exited is skipped.
+    const agents = new Set([liveSession(sessions, directory)?.pi, ...sessions.liveSessions().map((s) => s.pi)]);
+    for (const pi of agents) {
+        if (pi === undefined)
+            continue;
+        try {
+            return await loadedServers(pi);
+        }
+        catch { }
+    }
+    return inventory(directory);
+}
+/** With no running agent, a short-lived `--no-session` agent reads the inventory, shared for a while. */
+function inventory(directory) {
+    const cached = inventories.get(directory);
+    if (cached !== undefined && Date.now() - cached.at < MCP_INVENTORY_TTL_MS)
+        return cached.servers;
+    const servers = readInventory(directory).catch((error) => {
+        if (inventories.get(directory)?.servers === servers)
+            inventories.delete(directory);
+        console.error(`[mcp] listing servers for ${directory} failed: ${errorMessage(error)}`);
+        return [];
+    });
+    inventories.set(directory, { at: Date.now(), servers });
+    return servers;
+}
+async function readInventory(directory) {
+    const pi = new PiRpcClient({ cwd: directory, args: ["--no-session"] });
+    inventoryAgents.add(pi);
+    try {
+        await pi.command({ type: "get_state" }, MCP_INVENTORY_START_MS);
+        return await loadedServers(pi);
+    }
+    finally {
+        inventoryAgents.delete(pi);
+        await pi.dispose();
+    }
+}
+/**
+ * An agent started, stopped or reported new MCP state. Every directory a client read is told to read
+ * again: with the cross-directory fallback, one agent can change the answer for all of them.
+ */
+export function mcpSurfacesChanged(broadcast) {
+    inventories.clear();
+    clearTimeout(changeTimer);
+    changeTimer = setTimeout(() => {
+        for (const directory of watchedDirectories)
+            broadcast(directory, { type: "mcp.tools.changed", properties: { server: "" } });
+    }, MCP_CHANGE_DEBOUNCE_MS);
+    changeTimer.unref();
 }
 /** The builtin MCP command's name in this agent; builds without `sourceInfo` only know it as `mcp`. */
 async function mcpCommandName(pi) {
@@ -279,14 +336,16 @@ function release(flow) {
         .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. */
+/** Stops the agents spawned for sign-ins and inventories; live sessions are stopped by their own manager. */
 export async function disposeMcpAgents() {
+    clearTimeout(changeTimer);
+    inventories.clear();
     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()));
+    await Promise.all([...dedicated.map((flow) => flow.pi.dispose()), ...[...inventoryAgents].map((pi) => pi.dispose())]);
 }
 async function flowStatus(flow, name) {
     if (flow.server !== undefined || !agentCurrent(flow))
@@ -359,6 +418,7 @@ async function startFlow(services, directory, name, command) {
         done: Promise.resolve(),
         running: true,
         authorized: false,
+        completing: false,
         released: false,
     };
     if (live === undefined) {
@@ -380,7 +440,8 @@ async function startFlow(services, directory, name, command) {
         .then(async () => {
         if (!flow.authorized)
             return;
-        if (live === undefined) {
+        // A completion in flight set `authorized` and owns the agent: stopping it now would kill its command.
+        if (live === undefined && !flow.completing) {
             const server = await currentStatus(pi, name).catch(() => undefined);
             if (server !== undefined)
                 flow.server = server;
@@ -448,6 +509,7 @@ async function completeFlow(services, directory, name, input) {
     // OmO consumes the pending state on any answer, so a dedicated agent has nothing left to wait for.
     let attempted = false;
     let server;
+    flow.completing = true;
     try {
         if (flow.running && flow.command === "auth") {
             const target = new URL(redirect);
@@ -483,6 +545,7 @@ async function completeFlow(services, directory, name, input) {
         return fail(400, "McpAuthError", flow.error);
     }
     finally {
+        flow.completing = false;
         if (attempted)
             release(flow);
     }

package/dist/pi-rpc.d.ts

@@ -137,6 +137,8 @@ export declare class PiRpcClient extends EventEmitter {
     probe<T = unknown>(cmd: Omit<PiRpcCommand, "id">, timeoutMs?: number, signal?: AbortSignal): Promise<PiRpcResponse<T>>;
     /** Send a command and wait for its correlated response. A timeout stops the agent unless `stopOnTimeout` is false. */
     command<T = unknown>(cmd: Omit<PiRpcCommand, "id">, timeoutMs?: number, signal?: AbortSignal, onDispatch?: () => void, stopOnTimeout?: boolean): Promise<PiRpcResponse<T>>;
+    /** Asks OmO to stop the user shell; a pending `bash` still unanswered after the ordinary deadline means a hung agent. */
+    abortBash(): void;
     /** Fire-and-forget command (no response correlation). */
     notify(cmd: Omit<PiRpcCommand, "id">): void;
     dispose(): Promise<void>;

package/dist/pi-rpc.js

@@ -403,6 +403,10 @@ export class PiRpcClient extends EventEmitter {
         const expectedCommand = String(cmd.type);
         const deadlineMs = timeoutMs ?? RPC_COMMAND_TIMEOUT_MS;
         const waitsForWork = expectedCommand === "prompt" && timeoutMs === undefined;
+        // A user `bash` answers when its command exits: OmO awaits `executeBash` with no time limit (senpi
+        // 2026.10.25-2, dist/modes/rpc/connection-handler.js `case "bash"`), and an interactive command such as a
+        // login waits on the user. Without a caller deadline it gets one only once `abortBash` asks OmO to stop it.
+        const waitsForShell = expectedCommand === "bash" && timeoutMs === undefined;
         return new Promise((resolve, reject) => {
             let timer;
             let admissionTimer;
@@ -431,7 +435,8 @@ export class PiRpcClient extends EventEmitter {
                 if (!waitsForWork || !(this.agentActive || this.compacting))
                     timer = setTimeout(() => expire(deadlineMs), deadlineMs);
             };
-            armDeadline();
+            if (!waitsForShell)
+                armDeadline();
             if (waitsForWork)
                 admissionTimer = setTimeout(() => expire(PROMPT_ADMISSION_TIMEOUT_MS), PROMPT_ADMISSION_TIMEOUT_MS);
             this.pending.set(id, {
@@ -443,12 +448,19 @@ export class PiRpcClient extends EventEmitter {
                 },
                 reject: rejectCommand,
                 ...(waitsForWork ? { onWorkState: armDeadline } : {}),
+                ...(waitsForShell ? { onAbortBash: () => timer === undefined && armDeadline() } : {}),
             });
             signal?.addEventListener("abort", onAbort, { once: true });
             this.write({ ...cmd, id });
             onDispatch?.();
         });
     }
+    /** Asks OmO to stop the user shell; a pending `bash` still unanswered after the ordinary deadline means a hung agent. */
+    abortBash() {
+        this.write({ type: "abort_bash" });
+        for (const request of this.pending.values())
+            request.onAbortBash?.();
+    }
     /** Fire-and-forget command (no response correlation). */
     notify(cmd) {
         this.write(cmd);

package/dist/server.js

@@ -1,7 +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 { disposeMcpAgents, mcpSurfacesChanged } from "./mcp.js";
 import { debugLog } from "./misc-routes.js";
 import { SessionManager } from "./sessions.js";
 import { loadCatalog } from "./catalog.js";
@@ -30,6 +30,7 @@ export class AdapterServer {
         this.options = options;
         this.sse = new SSE(options, this.sseClients, (id) => this.sessions.monitors.owns(id));
         this.sessions = new SessionManager((directory, event) => this.broadcast(directory, event), undefined, options.defaultDirectory);
+        this.sessions.onMcpSurfacesChanged = () => mcpSurfacesChanged((directory, event) => this.broadcast(directory, event));
         this.server = createServer((req, res) => void this.route(req, res));
         this.server.on("upgrade", (req, socket, head) => this.handleUpgrade(req, socket, head));
     }

package/dist/session-commands.d.ts

@@ -54,6 +54,8 @@ type CompactResult = {
     kind: "error";
     message: string;
 };
+/** Appends a chunk and keeps the newest `limit` chars, starting at a line boundary when one leaves anything. */
+export declare function appendLiveOutput(previous: string, delta: string, limit?: number): string;
 export declare const unsupportedShare: {
     readonly name: "UnsupportedError";
     readonly data: {

package/dist/session-commands.js

@@ -2,6 +2,22 @@ import { randomUUID } from "node:crypto";
 import { PiRpcClient, UpstreamProtocolError } from "./pi-rpc.js";
 import { getAgentName } from "./agent-name.js";
 import { nativePromptInput, parsePromptParts } from "./prompt-parts.js";
+/**
+ * Live output kept on a running shell card: the newest part. Every snapshot carries all of it, so it is kept small;
+ * the finished card gets OmO's full output.
+ */
+const LIVE_SHELL_OUTPUT_CHARS = 64 * 1024;
+/** Output chunks arriving within this window reach clients as one card snapshot. */
+const LIVE_SHELL_OUTPUT_FLUSH_MS = 100;
+/** Appends a chunk and keeps the newest `limit` chars, starting at a line boundary when one leaves anything. */
+export function appendLiveOutput(previous, delta, limit = LIVE_SHELL_OUTPUT_CHARS) {
+    const output = previous + delta;
+    if (output.length <= limit)
+        return output;
+    const tail = output.slice(output.length - limit);
+    const lineStart = tail.indexOf("\n") + 1;
+    return lineStart > 0 && lineStart < tail.length ? tail.slice(lineStart) : tail;
+}
 // OpenChamber drops rejected Share actions, so emit a visible session notice too.
 export const unsupportedShare = {
     name: "UnsupportedError",
@@ -311,13 +327,35 @@ export async function runShellCommand(context) {
     const afterEntryId = session.tree.leafId ?? null;
     const controller = new AbortController();
     let interrupted = false;
+    // OmO streams user bash output as `bash_execution_update {id: executionId, delta}` frames before its reply
+    // (agent-session.js `executeBash`; real RPC probe on 2026-10-28). Showing them live lets the user act on
+    // output while the command waits, such as a login link.
+    let streaming;
+    let liveOutput = "";
+    let flush;
+    const onOutput = (event) => {
+        const [part] = message.parts;
+        if (event.type !== "bash_execution_update" || event.id !== part.callID || typeof event.delta !== "string")
+            return;
+        if (part.state.status !== "running")
+            return;
+        liveOutput = appendLiveOutput(liveOutput, event.delta);
+        part.state.metadata = { ...part.state.metadata, output: liveOutput };
+        flush ??= setTimeout(() => {
+            flush = undefined;
+            if (part.state.status === "running")
+                shellEvent(context, { type: "message.part.updated", properties: { part } });
+        }, LIVE_SHELL_OUTPUT_FLUSH_MS);
+    };
+    // A stopped card keeps what the command printed, such as a link the user still needs.
+    const streamed = () => (liveOutput === "" ? {} : { output: liveOutput });
     session.cancelShell = (byRestart = false) => {
         interrupted = byRestart;
         delete session.cancelShell;
         // Agent abort does not stop user bash. Dispatch the dedicated RPC first,
         // then release our waiter; a correlated late response is discarded.
         if (dispatch[message.info.id])
-            session.pi?.notify({ type: "abort_bash" });
+            session.pi?.abortBash();
         controller.abort();
     };
     sessions.appendMessage(session.info.id, user);
@@ -332,8 +370,10 @@ export async function runShellCommand(context) {
     });
     try {
         await sessions.update(session.info.id, {});
-        const response = await sessions.sessionRpc(session.info.id, { type: "bash", command }, controller.signal, () => {
+        const response = await sessions.sessionRpc(session.info.id, { type: "bash", command, executionId: message.parts[0].callID }, controller.signal, () => {
             dispatch[message.info.id] = true;
+            streaming = session.pi;
+            streaming?.onEvent(onOutput);
             // Only actual dispatch admissions are durable; queued attempts stay in the live cache.
             (session.tree.localShellTurns ??= []).push({ afterEntryId, messages: [user, message] });
             // A native result can land beyond the last synchronized leaf.
@@ -351,7 +391,11 @@ export async function runShellCommand(context) {
         }
         const result = parseShellResult(response.data);
         if (result.cancelled) {
-            failShellMessage(message, command, "Command cancelled", { cancelled: true, exitCode: result.exitCode });
+            failShellMessage(message, command, "Command cancelled", {
+                ...streamed(),
+                cancelled: true,
+                exitCode: result.exitCode,
+            });
         }
         else {
             completeShellMessage(message, command, result);
@@ -361,7 +405,10 @@ export async function runShellCommand(context) {
     }
     catch (error) {
         if (controller.signal.aborted) {
-            failShellMessage(message, command, interrupted ? "Interrupted by restart" : "Command cancelled", interrupted ? { interrupted: true } : { cancelled: true });
+            failShellMessage(message, command, interrupted ? "Interrupted by restart" : "Command cancelled", {
+                ...streamed(),
+                ...(interrupted ? { interrupted: true } : { cancelled: true }),
+            });
             emitShellMessage(context, message);
             return { kind: "completed", message };
         }
@@ -370,6 +417,8 @@ export async function runShellCommand(context) {
         throw error;
     }
     finally {
+        streaming?.off("event", onOutput);
+        clearTimeout(flush);
         delete session.cancelShell;
         const state = message.parts[0].state;
         const metadata = state.status === "pending" ? undefined : state.metadata;

package/dist/sessions.d.ts

@@ -116,6 +116,8 @@ export declare class SessionManager {
     private scanCache;
     /** freshness of the all-directories scan (see listAll). */
     private scanAllCache;
+    /** Called when an agent starts, stops or reports a change to its MCP servers. */
+    onMcpSurfacesChanged: (() => void) | undefined;
     constructor(emit: EventSink, store?: SessionStore, defaultDirectory?: string | undefined, lifecycleOptions?: LifecycleOptions);
     create(directory: string, title?: string, parentID?: string, options?: {
         id?: string;

package/dist/sessions.js

@@ -75,6 +75,8 @@ export class SessionManager {
     scanCache = new Map();
     /** freshness of the all-directories scan (see listAll). */
     scanAllCache;
+    /** Called when an agent starts, stops or reports a change to its MCP servers. */
+    onMcpSurfacesChanged;
     constructor(emit, store, defaultDirectory, lifecycleOptions = {}) {
         this.emit = emit;
         this.defaultDirectory = defaultDirectory;
@@ -258,6 +260,8 @@ export class SessionManager {
         const onEvent = (payload) => {
             if (s.pi !== pi)
                 return;
+            if (payload.type === "loaded_surfaces_changed")
+                this.onMcpSurfacesChanged?.();
             this.lifecycle.touch(s);
             s.approvals?.observeQuestion(payload);
             try {
@@ -278,6 +282,7 @@ export class SessionManager {
         const onExit = (code, signal) => {
             if (s.pi !== pi)
                 return;
+            this.onMcpSurfacesChanged?.();
             // An agent that stopped on its own (timeout, broken pipe, crash) must say why: a notice card in the
             // transcript, the same error on the reply it interrupted, and a replay after an adapter restart.
             // Pending commands reject with the same PiStoppedError; prompt admission leaves it to this handler.
@@ -315,6 +320,7 @@ export class SessionManager {
         pi.onEvent(onEvent);
         pi.onExtensionUI(onExtensionUI);
         pi.onExit(onExit);
+        this.onMcpSurfacesChanged?.();
         s.unwirePi = () => {
             pi.off("event", onEvent);
             pi.off("extension_ui_request", onExtensionUI);
@@ -833,7 +839,12 @@ export class SessionManager {
             if (pi === undefined)
                 throw new Error(`session cannot be resumed: ${sessionId}`);
             this.lifecycle.touch(s);
-            const timeout = command.type === "compact" ? COMPACT_RPC_TIMEOUT_MS : RPC_COMMAND_TIMEOUT_MS;
+            // A user shell runs until its command exits or the user stops it (`PiRpcClient.abortBash`).
+            const timeout = command.type === "compact"
+                ? COMPACT_RPC_TIMEOUT_MS
+                : command.type === "bash"
+                    ? undefined
+                    : RPC_COMMAND_TIMEOUT_MS;
             // OmO cancels a compaction whenever an MCP server's tools register, which a freshly revived agent
             // does for about a second; start it once they have. The retries below remain the backstop.
             if (command.type === "compact")

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "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.30",
+  "version": "1.0.32",
   "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.30",
+  "version": "1.0.32",
   "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.30",
+  "version": "1.0.32",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",