@fitchmultz/pi-mcp-adapter 7.1.1 → 8.0.0

package/dist/ui-message-history.js

@@ -0,0 +1,81 @@
+import { appendFileSync, createReadStream, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { randomBytes } from "node:crypto";
+import { createInterface } from "node:readline";
+/** Private append-only history; failed writes stay owned in memory, never silently discarded. */
+export function createUiMessageHistory(outputDirectory) {
+    const messages = { prompts: [], intents: [], notifications: [], contexts: [] };
+    let failed = false;
+    return {
+        messages,
+        append(category, value) {
+            try {
+                if (failed)
+                    throw new Error(messages.historyError);
+                if (!messages.historyRef) {
+                    const root = outputDirectory === undefined ? tmpdir() : resolve(outputDirectory);
+                    if (outputDirectory !== undefined)
+                        mkdirSync(root, { recursive: true, mode: 0o700 });
+                    const dir = mkdtempSync(join(root, "pi-mcp-output-"));
+                    const ref = join(dir, `output-${randomBytes(4).toString("hex")}.txt`);
+                    writeFileSync(ref, "", { mode: 0o600 });
+                    messages.historyRef = ref;
+                    messages.historyBytes = 0;
+                    messages.historyCount = 0;
+                }
+                const line = JSON.stringify({ category, value }) + "\n";
+                // ponytail: synchronous append owns acceptance order; upgrade to an awaited serial writer if local disk latency becomes material.
+                appendFileSync(messages.historyRef, line, { flush: true });
+                messages.historyBytes += Buffer.byteLength(line);
+                messages.historyCount++;
+                return undefined;
+            }
+            catch (error) {
+                failed = true;
+                messages.historyError = error instanceof Error ? error.message : String(error);
+                if (category === "intents")
+                    messages.intents.push(value);
+                else
+                    messages[category].push(value);
+                return `UI history could not be saved; messages remain in memory for recovery: ${messages.historyError}. Unsaved messages will be lost on reload or process exit.`;
+            }
+        },
+    };
+}
+export async function* uiMessages(messages, category) {
+    if (messages.historyRef && messages.historyBytes) {
+        // A failed partial append is not an accepted event; the in-memory tail owns it instead.
+        const input = createReadStream(messages.historyRef, { encoding: "utf8", end: messages.historyBytes - 1 });
+        let bytes = 0, count = 0;
+        input.on("data", chunk => { bytes += Buffer.byteLength(chunk); });
+        const lines = createInterface({ input, crlfDelay: Infinity });
+        try {
+            for await (const line of lines) {
+                const record = JSON.parse(line);
+                count++;
+                if (record.category === category)
+                    yield record.value;
+            }
+            if (bytes !== messages.historyBytes || (messages.historyCount !== undefined && count !== messages.historyCount)) {
+                throw new Error("UI history is incomplete; accepted messages remain pending recovery");
+            }
+        }
+        finally {
+            lines.close();
+            input.destroy();
+        }
+    }
+    for (const value of messages[category])
+        yield value;
+}
+export async function materializeUiMessages(messages) {
+    const result = { prompts: [], intents: [], notifications: [], contexts: messages.contexts };
+    for await (const value of uiMessages(messages, "prompts"))
+        result.prompts.push(value);
+    for await (const value of uiMessages(messages, "intents"))
+        result.intents.push(value);
+    for await (const value of uiMessages(messages, "notifications"))
+        result.notifications.push(value);
+    return result;
+}

package/dist/ui-server.js

@@ -10,6 +10,7 @@ import { logger } from "./logger.js";
 import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.js";
 import { extractUiToolVisibility, isUiToolCallableByApp } from "./ui-tool-visibility.js";
+import { createUiMessageHistory } from "./ui-message-history.js";
 import { createUiModelContextUpdate, extractUiPromptText, getVisualizationStreamEnvelope, isServerDisabled, isToolAllowed, resolveToolPrefix, } from "./types.js";
 const MAX_BODY_SIZE = 2 * 1024 * 1024;
 const ABANDONED_GRACE_MS = 60_000;
@@ -38,12 +39,8 @@ export async function startUiServer(options) {
     const eventLog = [];
     let streamSummary;
     // Track messages from UI for retrieval
-    const sessionMessages = {
-        prompts: [],
-        notifications: [],
-        intents: [],
-        contexts: [],
-    };
+    const history = createUiMessageHistory(options.state?.outputDirectory);
+    const sessionMessages = history.messages;
     const hostContext = {
         displayMode: currentDisplayMode,
         availableDisplayModes: ["inline", "fullscreen", "pip"],
@@ -281,6 +278,11 @@ export async function startUiServer(options) {
                 return;
             if (!validateTokenBody(body, sessionToken, res))
                 return;
+            // A partial upload is not accepted until its authenticated body is complete.
+            if (completed && (url.pathname === "/proxy/ui/message" || url.pathname === "/proxy/ui/context")) {
+                sendJson(res, 409, { ok: false, error: "UI session is complete; message was not accepted" });
+                return;
+            }
             const params = body.params ?? {};
             touchHeartbeat();
             if (url.pathname === "/proxy/tools/call") {
@@ -376,14 +378,15 @@ export async function startUiServer(options) {
                 const promptText = extractUiPromptText(msgParams);
                 // Track messages by type (order: prompt → intent → notify)
                 // Must match the order in index.ts onMessage handler
+                let warning;
                 if (promptText) {
-                    sessionMessages.prompts.push(promptText);
+                    warning = history.append("prompts", promptText);
                     log.debug("UI prompt received", { prompt: promptText.slice(0, 100) });
                 }
                 else if (msgParams.type === "intent" || msgParams.intent) {
                     const intentName = msgParams.intent ?? "";
                     if (intentName) {
-                        sessionMessages.intents.push({
+                        warning = history.append("intents", {
                             intent: intentName,
                             ...(msgParams.params !== undefined ? { params: msgParams.params } : {}),
                         });
@@ -393,12 +396,16 @@ export async function startUiServer(options) {
                 else if (msgParams.type === "notify" || msgParams.message) {
                     const notifyText = msgParams.message ?? "";
                     if (notifyText) {
-                        sessionMessages.notifications.push(notifyText);
+                        warning = history.append("notifications", notifyText);
                         log.debug("UI notification", { message: notifyText.slice(0, 100) });
                     }
                 }
                 await options.onMessage?.(msgParams);
-                sendJson(res, 200, { ok: true, result: {} });
+                if (warning) {
+                    log.warn(warning);
+                    options.state?.ui?.notify(warning, "warning");
+                }
+                sendJson(res, 200, { ok: true, result: {}, ...(warning ? { warning } : {}) });
                 return;
             }
             if (url.pathname === "/proxy/ui/context") {

package/dist/ui-session.js

@@ -297,7 +297,8 @@ export async function maybeStartUiSession(state, request) {
                 if (state.uiServer === handle) {
                     const messages = handle.getSessionMessages();
                     const stream = handle.getStreamSummary();
-                    const hasContent = messages.prompts.length > 0 ||
+                    const hasContent = !!messages.historyCount ||
+                        messages.prompts.length > 0 ||
                         messages.intents.length > 0 ||
                         messages.notifications.length > 0 ||
                         messages.contexts.length > 0 ||
@@ -316,7 +317,7 @@ export async function maybeStartUiSession(state, request) {
                         }
                         log.debug("Session completed", {
                             reason,
-                            prompts: messages.prompts.length,
+                            prompts: messages.historyCount ?? messages.prompts.length,
                             intents: messages.intents.length,
                             notifications: messages.notifications.length,
                             contexts: messages.contexts.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitchmultz/pi-mcp-adapter",
-  "version": "7.1.1",
+  "version": "8.0.0",
   "description": "Fitch's independently maintained MCP adapter for Pi coding agent",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -108,9 +108,9 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.99.2",
-    "@earendil-works/pi-coding-agent": "0.99.2",
-    "@earendil-works/pi-tui": "0.99.2",
+    "@earendil-works/pi-ai": "1.0.0",
+    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-tui": "1.0.0",
     "@modelcontextprotocol/server": "2.2.0",
     "@types/cross-spawn": "6.0.6",
     "@types/node": "24.19.0",

package/dist/checkpoint.d.ts

@@ -1,18 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { McpExtensionState } from "./state.ts";
-/** Optional host event. Published Pi hosts without this event simply never emit it.
- * Keep its structural typing local; do not require a private host package/version. */
-export interface McpCheckpointEvent {
-    readonly boundary: "turn" | "settled";
-    readonly signal: AbortSignal;
-    invalidate(): void;
-}
-export type McpCheckpointResult = {
-    sleepReady: true;
-} | {
-    sleepReady: false;
-    reason: string;
-};
-export declare function onSessionCheckpoint(pi: ExtensionAPI, handler: (event: McpCheckpointEvent) => Promise<McpCheckpointResult>): void;
-/** No shutdown, credential copying, connection replay or permanent owner cancellation. */
-export declare function prepareMcpCheckpoint(state: McpExtensionState, event: McpCheckpointEvent): Promise<McpCheckpointResult>;

package/dist/checkpoint.js

@@ -1,53 +0,0 @@
-import { flushMetadataCache } from "./init.js";
-import { getOAuthCheckpointBlocker, holdOAuthCheckpoint } from "./mcp-auth-flow.js";
-import { isServerDisabled } from "./types.js";
-export function onSessionCheckpoint(pi, handler) {
-    pi.on("session_checkpoint", handler);
-}
-/** No shutdown, credential copying, connection replay or permanent owner cancellation. */
-export async function prepareMcpCheckpoint(state, event) {
-    event.signal.throwIfAborted();
-    const releases = [];
-    const release = () => { for (const undo of releases.splice(0).reverse())
-        undo(); };
-    // Fence all owned sources synchronously, before the first await (including trace flush).
-    event.signal.addEventListener("abort", release, { once: true });
-    const undo = () => { release(); event.signal.removeEventListener("abort", release); };
-    const blocked = (reason) => { undo(); return { sleepReady: false, reason }; };
-    try {
-        releases.push(state.owner.holdCheckpoint(event));
-        releases.push(state.manager.holdCheckpoint(event));
-        releases.push(holdOAuthCheckpoint(state.oauthRuntime, event));
-        releases.push(state.lifecycle.pauseForCheckpoint());
-        if (state.lifecycle.hasActiveHealthCheck())
-            return blocked("MCP health check is active");
-        for (const [name, definition] of Object.entries(state.config.mcpServers)) {
-            if (!isServerDisabled(definition) && !definition.url)
-                return blocked(`MCP ${name}: stdio/Unix server state is not reconstructible`);
-        }
-        const callback = state.owner.getCheckpointBlocker();
-        if (callback)
-            return blocked(callback);
-        if (state.activeScripts)
-            return blocked("MCP script is active");
-        if (state.uiServer || state.completedUiSessions.length)
-            return blocked("MCP UI session/messages require the running runtime");
-        if (state.approvedToolCalls.size || state.consentManager.hasDecisions())
-            return blocked("MCP session approvals are not persisted");
-        const oauth = getOAuthCheckpointBlocker(state.oauthRuntime);
-        if (oauth)
-            return blocked(oauth);
-        const manager = state.manager.getCheckpointBlocker();
-        if (manager)
-            return blocked(manager);
-        flushMetadataCache(state);
-        await state.manager.flushForCheckpoint();
-        event.signal.throwIfAborted();
-        // Release/cancellation is host-owned. Existing clients/timers remain usable afterwards.
-        return { sleepReady: true };
-    }
-    catch (error) {
-        undo();
-        throw error;
-    }
-}