context-mode 1.0.135 → 1.0.137

package/build/adapters/pi/mcp-bridge.js

@@ -96,6 +96,87 @@ const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
 // Tools/call may run shell commands or fetch URLs — wider window than
 // initialize/list, but still bounded so a hung server can't block Pi.
 const DEFAULT_CALL_TIMEOUT_MS = 120_000;
+class PiTextComponent {
+    text;
+    constructor(text = "") {
+        this.text = text;
+    }
+    setText(text) {
+        this.text = text;
+    }
+    invalidate() {
+        // Stateless renderer: no cached layout to invalidate.
+    }
+    render(width) {
+        if (!this.text || this.text.trim() === "")
+            return [];
+        return this.text
+            .replace(/\t/g, "   ")
+            .split(/\r?\n/)
+            .map((line) => truncateAnsiLine(line, Math.max(1, width)));
+    }
+}
+const ANSI_PATTERN = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07]*(?:\x07|\x1b\\)/g;
+function truncateAnsiLine(line, maxWidth) {
+    if (maxWidth <= 0)
+        return "";
+    let output = "";
+    let visible = 0;
+    let index = 0;
+    ANSI_PATTERN.lastIndex = 0;
+    for (;;) {
+        const match = ANSI_PATTERN.exec(line);
+        const end = match?.index ?? line.length;
+        const chunk = line.slice(index, end);
+        for (const char of chunk) {
+            if (visible >= maxWidth)
+                return output;
+            output += char;
+            visible++;
+        }
+        if (!match)
+            return output;
+        output += match[0];
+        index = ANSI_PATTERN.lastIndex;
+    }
+}
+function createContextModeCallRenderer(toolName) {
+    return (_args, theme, context) => {
+        const text = context.lastComponent instanceof PiTextComponent
+            ? context.lastComponent
+            : new PiTextComponent();
+        text.setText(theme.fg("toolTitle", theme.bold(toolName)));
+        return text;
+    };
+}
+function createContextModeResultRenderer(toolName) {
+    return (result, { expanded, isPartial }, theme, context) => {
+        const text = context.lastComponent instanceof PiTextComponent
+            ? context.lastComponent
+            : new PiTextComponent();
+        if (isPartial) {
+            text.setText(theme.fg("warning", "indexing/searching..."));
+            return text;
+        }
+        const output = (result.content ?? [])
+            .filter((c) => c?.type === "text" && typeof c.text === "string")
+            .map((c) => c.text)
+            .join("\n");
+        if (expanded) {
+            text.setText(theme.fg("toolOutput", output));
+            return text;
+        }
+        const firstLine = output
+            .split(/\r?\n/)
+            .find((line) => line.trim().length > 0)
+            ?.trim();
+        const status = firstLine && firstLine.length <= 180
+            ? firstLine
+            : `${toolName} completed`;
+        text.setText(theme.fg("toolOutput", status));
+        return text;
+    };
+}
 /**
  * Minimal stdio JSON-RPC client targeting the context-mode MCP server.
  *
@@ -118,6 +199,15 @@ export class MCPStdioClient {
     buffer = "";
     initialized = false;
     exited = false;
+    /**
+     * In-flight respawn promise — set while {@link respawn} runs so
+     * concurrent callers awaiting `request()` after an idle exit observe
+     * the SAME respawn, not N parallel ones. Without this guard, two
+     * simultaneous `callTool` calls would each see `this.exited === true`,
+     * each fire their own `respawn()`, and the loser leaks an orphaned
+     * child process the GC cannot reach (no `.kill()` reference).
+     */
+    respawnPromise = null;
     /**
      * Live env passed to the spawned child — exposed (read-only intent)
      * so tests can pin the fork-bomb-prevention env counter (#516)
@@ -232,11 +322,31 @@ export class MCPStdioClient {
                 handler.resolve(msg.result);
         }
     }
-    request(method, params, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+    async request(method, params, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+        // Respawn-on-idle-exit (#583, #583-followup).
+        //
+        // Initial #583 fix patched callTool() only. The structural location is
+        // here: `request()` is the single chokepoint for `initialize`,
+        // `tools/list`, `tools/call`, and any future method. Patching at this
+        // layer means listTools / re-initialize paths after an idle exit also
+        // self-heal, not just the registered-tool happy path.
+        //
+        // Sequencing is critical: respawn() resets `exited`, `child`, and
+        // `buffer` BEFORE start() + initialize(). The initialize() call inside
+        // respawn() goes through this same request() — recursion is safe
+        // because by the time we re-enter, `exited` is false again. We use a
+        // single-flight `respawnPromise` so concurrent callers share the same
+        // respawn (orphan-child guard, see field comment).
+        if (this.exited) {
+            if (!this.respawnPromise) {
+                this.respawnPromise = this.respawn().finally(() => {
+                    this.respawnPromise = null;
+                });
+            }
+            await this.respawnPromise;
+        }
         if (!this.child)
             throw new Error("MCP client not started");
-        if (this.exited)
-            return Promise.reject(new Error("MCP server has exited"));
         const id = ++this.requestId;
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
@@ -256,14 +366,60 @@ export class MCPStdioClient {
                 },
             });
             const frame = JSON.stringify({ jsonrpc: "2.0", id, method, params });
-            this.child.stdin?.write(frame + "\n");
+            const rejectWrite = (err) => {
+                const handler = this.pending.get(id);
+                if (handler) {
+                    this.pending.delete(id);
+                    handler.reject(err);
+                    return;
+                }
+                reject(err);
+            };
+            this.writeFrame(frame, rejectWrite);
         });
     }
+    writeFrame(frame, onError) {
+        if (!this.child || this.exited) {
+            onError?.(new Error("MCP server exited"));
+            return false;
+        }
+        const stdin = this.child.stdin;
+        if (!stdin || stdin.destroyed || stdin.writableEnded || stdin.closed) {
+            this.onExit();
+            onError?.(new Error("MCP server stdin unavailable"));
+            return false;
+        }
+        try {
+            stdin.write(frame + "\n", (err) => {
+                if (!err)
+                    return;
+                const code = err.code;
+                if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+                    this.onExit();
+                    onError?.(err);
+                    return;
+                }
+                onError?.(err);
+            });
+            return true;
+        }
+        catch (err) {
+            const code = err && typeof err === "object" && "code" in err
+                ? err.code
+                : undefined;
+            if (err instanceof Error && (code === "EPIPE" || code === "ERR_STREAM_DESTROYED")) {
+                this.onExit();
+                onError?.(err);
+                return false;
+            }
+            throw err;
+        }
+    }
     notify(method, params) {
         if (!this.child)
             return;
         const frame = JSON.stringify({ jsonrpc: "2.0", method, params });
-        this.child.stdin?.write(frame + "\n");
+        this.writeFrame(frame);
     }
     async initialize() {
         if (this.initialized)
@@ -284,33 +440,35 @@ export class MCPStdioClient {
         return Array.isArray(result.tools) ? result.tools : [];
     }
     async callTool(name, args) {
-        // Respawn-on-idle-exit (#583). The MCP server gained an idle
-        // self-shutdown in 1.0.132 (#565/#568, src/lifecycle.ts). When the
-        // Pi-spawned child exits cleanly after the idle window, Pi keeps the
-        // tool handles registered, but the bridge client is `exited=true`
-        // and every subsequent request would reject with
-        // "MCP server has exited" — leaving Pi's ctx_* tools permanently
-        // broken until the user restarts Pi.
-        //
-        // The structural fix is here, not in lifecycle.ts: the bridge owns
-        // the child lifecycle, so it transparently respawns + re-initialises
-        // the server on the next call. Restores parity with adapters whose
-        // host MCP client respawns on EOF (Claude Code, Codex, etc.).
-        if (this.exited)
-            await this.respawn();
+        // Respawn-on-idle-exit is now handled centrally in `request()`
+        // (#583 follow-up). Originally patched here in #583 — moving it up
+        // one layer covers `listTools` / `initialize` paths too, with a
+        // single-flight guard against orphan child processes from
+        // concurrent callers.
         return this.request("tools/call", { name, arguments: args ?? {} }, DEFAULT_CALL_TIMEOUT_MS);
     }
     /**
-     * Respawn the MCP child after an exit (clean idle shutdown or crash).
+     * Respawn the MCP child after an exit (clean shutdown or crash).
      * Resets state so a fresh `start()` + `initialize()` cycle runs, then
      * the caller's pending request flows through the new child.
      *
-     * Internal — exposed only via the public `callTool()` happy path.
+     * Single-flight — concurrent callers share one in-flight respawn via
+     * {@link respawnPromise}. Internal — only entered via {@link request}.
+     *
+     * Sequencing pinned (do not reorder without updating the regression
+     * test in tests/adapters/pi-mcp-bridge.test.ts):
+     *   1. `this.child = null`     — drop stale handle
+     *   2. `this.buffer = ""`       — discard leftover bytes from old child
+     *   3. `this.exited = false`    — must precede `start()` + `initialize()`,
+     *                                 because `request("initialize", …)`
+     *                                 inside `initialize()` re-checks this
+     *                                 flag and would otherwise re-enter
+     *                                 respawn in an infinite loop
+     *   4. `this.initialized = false`
+     *   5. `this.start()`
+     *   6. `await this.initialize()` — flows through `request()` recursively
      */
     async respawn() {
-        // Drop the dead child handle and clear stream buffer so leftover
-        // bytes from the previous incarnation don't get parsed as JSON-RPC
-        // for the new one. Pending map is already cleared by onExit().
         this.child = null;
         this.buffer = "";
         this.exited = false;
@@ -398,6 +556,8 @@ export async function bootstrapMCPTools(pi, serverScript, options = {}) {
             // for type inference). Empty-object fallback keeps tools that
             // declare no parameters callable.
             parameters: tool.inputSchema ?? { type: "object", properties: {} },
+            renderCall: createContextModeCallRenderer(tool.name),
+            renderResult: createContextModeResultRenderer(tool.name),
             async execute(_toolCallId, params) {
                 const result = await client.callTool(tool.name, params ?? {});
                 const text = (result.content ?? [])

package/build/lifecycle.d.ts

@@ -20,54 +20,7 @@ export interface LifecycleGuardOptions {
     onShutdown: () => void;
     /** Injectable parent-alive check (for testing). Default: ppid-based check. */
     isParentAlive?: () => boolean;
-    /**
-     * Idle shutdown threshold in ms (#565). When the server has handled no
-     * MCP activity for this long, `onShutdown` fires. `0` disables.
-     * Default: env `CONTEXT_MODE_IDLE_TIMEOUT_MS`, else 15 minutes.
-     * Skipped on TTY stdin (interactive dev / OpenCode ts-plugin standalone).
-     *
-     * Pair with the returned `recordActivity()` callback — call it on every
-     * MCP request the server handles so genuinely busy servers never trip.
-     */
-    idleTimeoutMs?: number;
-    /** Test injection — defaults to `Date.now`. */
-    now?: () => number;
 }
-/**
- * Hybrid return type: callable like the original `() => void` cleanup (kept
- * for backwards compatibility with #103/#236/#311/#388/#534 test suites),
- * and additionally exposes `recordActivity` for the idle-timeout path (#565)
- * and `stop` as an explicit alias.
- */
-export interface LifecycleGuardHandle {
-    /** Stop the guard. Calling the handle directly is equivalent. */
-    (): void;
-    /** Bumps the "last activity" timestamp so the idle timer doesn't fire. */
-    recordActivity: () => void;
-    /** Stop the guard. Alias for invoking the handle. */
-    stop: () => void;
-}
-/**
- * Resolve the idle-shutdown threshold (#565).
- *
- * OpenCode + KiloCode open a fresh MCP client per session AND per subagent
- * task, but never tear them down for the host's lifetime. A host alive for
- * a working day accumulates one stdio child per session — observed live at
- * 26 children / 1.6 GB RSS under a single `opencode serve` parent.
- *
- * None of the existing exit paths (ppid poll, grandparent reparent, stdin
- * EOF, SIGTERM) fire while the host stays alive. Idle shutdown is the
- * structural fix: a server with no work to do should release its memory.
- *
- * Default 15 min strikes a balance — long enough that a paused
- * conversation does not pay a cold-start on every resume, short enough
- * that 8 hours of unused sessions do not pin GB of RAM.
- *
- * Set env to `0` to disable entirely.
- *
- * Exported for unit-testing.
- */
-export declare function idleTimeoutForEnv(env?: NodeJS.ProcessEnv): number;
 /** Injectable dependencies for {@link makeDefaultIsParentAlive}. */
 export interface IsParentAliveDeps {
     /** Read the current ppid. Default: `() => process.ppid`. */
@@ -107,9 +60,7 @@ export declare function makeDefaultIsParentAlive(deps?: IsParentAliveDeps): () =
  */
 export declare function lifecycleGuardIntervalForEnv(env?: NodeJS.ProcessEnv): number;
 /**
- * Start the lifecycle guard. Returns a handle with `recordActivity` (call
- * on every MCP request to keep idle timer from firing) and `stop`.
- *
+ * Start the lifecycle guard. Returns a cleanup function.
  * Skipped automatically when stdin is a TTY (e.g. OpenCode ts-plugin).
  */
-export declare function startLifecycleGuard(opts: LifecycleGuardOptions): LifecycleGuardHandle;
+export declare function startLifecycleGuard(opts: LifecycleGuardOptions): () => void;

package/build/lifecycle.js

@@ -14,35 +14,6 @@
  * Cross-platform: macOS, Linux, Windows.
  */
 import { execFileSync } from "node:child_process";
-/**
- * Resolve the idle-shutdown threshold (#565).
- *
- * OpenCode + KiloCode open a fresh MCP client per session AND per subagent
- * task, but never tear them down for the host's lifetime. A host alive for
- * a working day accumulates one stdio child per session — observed live at
- * 26 children / 1.6 GB RSS under a single `opencode serve` parent.
- *
- * None of the existing exit paths (ppid poll, grandparent reparent, stdin
- * EOF, SIGTERM) fire while the host stays alive. Idle shutdown is the
- * structural fix: a server with no work to do should release its memory.
- *
- * Default 15 min strikes a balance — long enough that a paused
- * conversation does not pay a cold-start on every resume, short enough
- * that 8 hours of unused sessions do not pin GB of RAM.
- *
- * Set env to `0` to disable entirely.
- *
- * Exported for unit-testing.
- */
-export function idleTimeoutForEnv(env = process.env) {
-    const raw = env.CONTEXT_MODE_IDLE_TIMEOUT_MS;
-    if (raw === undefined)
-        return 15 * 60 * 1000;
-    const n = Number.parseInt(raw, 10);
-    if (!Number.isFinite(n) || n < 0)
-        return 15 * 60 * 1000;
-    return n;
-}
 /** Read grandparent PID via `ps -o ppid= -p $PPID`. Returns NaN on failure or Windows. */
 function readGrandparentPpidImpl() {
     if (process.platform === "win32")
@@ -124,52 +95,25 @@ export function lifecycleGuardIntervalForEnv(env = process.env) {
     return 1000;
 }
 /**
- * Start the lifecycle guard. Returns a handle with `recordActivity` (call
- * on every MCP request to keep idle timer from firing) and `stop`.
- *
+ * Start the lifecycle guard. Returns a cleanup function.
  * Skipped automatically when stdin is a TTY (e.g. OpenCode ts-plugin).
  */
 export function startLifecycleGuard(opts) {
     const interval = opts.checkIntervalMs ?? lifecycleGuardIntervalForEnv();
     const check = opts.isParentAlive ?? defaultIsParentAlive;
-    const idleTimeoutMs = opts.idleTimeoutMs ?? idleTimeoutForEnv();
-    const now = opts.now ?? Date.now;
     let stopped = false;
-    let lastActivity = now();
     const shutdown = () => {
         if (stopped)
             return;
         stopped = true;
         opts.onShutdown();
     };
-    const recordActivity = () => {
-        lastActivity = now();
-    };
-    // P0: Periodic parent liveness check.
+    // P0: Periodic parent liveness check
     const timer = setInterval(() => {
         if (!check())
             shutdown();
     }, interval);
     timer.unref();
-    // P0+: Idle shutdown (#565). Runs on its OWN tick — distinct from the
-    // 30 s parent-liveness poll — so a 15 min idle timeout actually reacts
-    // close to 15 min instead of "next 30 s tick after 15 min". Pick the
-    // tick as min(idleTimeoutMs / 6, 30 s) so a short timeout (e.g. 3 s in
-    // e2e tests, 60 s in dev) reacts within ~16 % of its window while a
-    // production 15 min timeout still polls every 30 s (cheap).
-    //
-    // Skipped on TTY because interactive dev sessions are expected to
-    // sit idle between commands, and also when idleTimeoutMs is 0 (env
-    // opt-out via CONTEXT_MODE_IDLE_TIMEOUT_MS=0).
-    let idleTimer = null;
-    if (idleTimeoutMs > 0 && !process.stdin.isTTY) {
-        const idleTick = Math.max(50, Math.min(Math.floor(idleTimeoutMs / 6), 30_000));
-        idleTimer = setInterval(() => {
-            if (now() - lastActivity > idleTimeoutMs)
-                shutdown();
-        }, idleTick);
-        idleTimer.unref();
-    }
     // P0: OS signals — terminal close, kill, ctrl+c
     const signals = ["SIGTERM", "SIGINT"];
     if (process.platform !== "win32")
@@ -198,19 +142,11 @@ export function startLifecycleGuard(opts) {
     if (!process.stdin.isTTY) {
         process.stdin.on("end", onStdinEnd);
     }
-    const cleanup = () => {
+    return () => {
         stopped = true;
         clearInterval(timer);
-        if (idleTimer)
-            clearInterval(idleTimer);
         for (const sig of signals)
             process.removeListener(sig, shutdown);
         process.stdin.removeListener("end", onStdinEnd);
     };
-    // Hybrid: callable for legacy `const cleanup = startLifecycleGuard(...)`
-    // sites, with `.recordActivity` / `.stop` properties for the new contract.
-    const handle = cleanup;
-    handle.recordActivity = recordActivity;
-    handle.stop = cleanup;
-    return handle;
 }

package/build/server.d.ts

@@ -1,6 +1,25 @@
 #!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { type SpawnSyncOptions, type SpawnSyncReturns } from "node:child_process";
 import { ContentStore } from "./store.js";
+import { type PlatformId } from "./adapters/types.js";
+export declare const server: McpServer;
+export interface RegisteredCtxTool {
+    name: string;
+    config: Record<string, unknown>;
+    handler: (args: Record<string, unknown>) => Promise<unknown> | unknown;
+}
+export declare const REGISTERED_CTX_TOOLS: RegisteredCtxTool[];
+export declare function shouldSuppressMcpToolsForNativePluginHost(opts?: {
+    embedded?: string;
+    platform?: PlatformId;
+    settings?: Record<string, unknown> | null;
+}): boolean;
+type ToolContextOverride = {
+    projectDir: string;
+    sessionId?: string;
+};
+export declare function withProjectDirOverride<T>(projectDir: string | ToolContextOverride, fn: () => Promise<T>): Promise<T>;
 /**
  * Build the FK-attribution object passed to every ContentStore.index*() call
  * in this process. CLAUDE_SESSION_ID is the only MCP-side handle we have on