@herbertgao/pi-extensions 2026.8.15 → 2026.9.0

package/node_modules/pi-mcp-adapter/ui-server.ts

@@ -12,6 +12,11 @@ import type { ConsentManager } from "./consent-manager.ts";
 import { ServerError, wrapError } from "./errors.ts";
 import { formatAuthRequiredMessage, normalizeToolArguments } from "./utils.ts";
 import { buildHostHtmlTemplate, buildCspMetaContent } from "./host-html-template.ts";
+import {
+  buildSandboxProxyCsp,
+  buildSandboxProxyHtml,
+  SANDBOX_PROXY_PATH,
+} from "./sandbox-proxy-template.ts";
 import { logger } from "./logger.ts";
 import type { McpServerManager } from "./server-manager.ts";
 import type { McpExtensionState } from "./state.ts";
@@ -99,6 +104,11 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
   const eventLog: Array<{ id: number; name: string; payload: unknown }> = [];
   let latestCheckpointEventId: number | undefined;
   let streamSummary: UiStreamSummary | undefined;
+  let server: http.Server | null = null;
+  let sandboxProxyServer: http.Server | null = null;
+  let sandboxProxyUrl: string | null = null;
+  let closeTimer: NodeJS.Timeout | null = null;
+  let listenersClosed = false;
 
   // Track messages from UI for retrieval
   const sessionMessages: UiSessionMessages = {
@@ -266,6 +276,32 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
     watchdog = null;
   };
 
+  const closeListeners = () => {
+    if (listenersClosed) return;
+    listenersClosed = true;
+    stopWatchdog();
+    if (closeTimer) {
+      clearTimeout(closeTimer);
+      closeTimer = null;
+    }
+    try {
+      server?.close();
+    } catch {}
+    try {
+      sandboxProxyServer?.close();
+    } catch {}
+    closeSse();
+  };
+
+  const scheduleListenerClose = () => {
+    if (closeTimer || listenersClosed) return;
+    closeTimer = setTimeout(() => {
+      closeTimer = null;
+      closeListeners();
+    }, 20);
+    closeTimer.unref();
+  };
+
   const markCompleted = (reason: string) => {
     if (completed) return;
     log.debug("Session completed", { reason });
@@ -273,9 +309,10 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
     completed = true;
     stopWatchdog();
     options.onComplete?.(reason);
+    scheduleListenerClose();
   };
 
-  const server = http.createServer(async (req, res) => {
+  const hostServer = http.createServer(async (req, res) => {
     try {
       const method = req.method || "GET";
       const hostHeader = req.headers.host;
@@ -302,6 +339,10 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
         }
         if (!validateTokenQuery(url, sessionToken, res)) return;
         touchHeartbeat();
+        if (!sandboxProxyUrl) {
+          sendText(res, 503, "Sandbox proxy is not ready");
+          return;
+        }
 
         const html = buildHostHtmlTemplate({
           sessionToken,
@@ -314,6 +355,7 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
           requireToolConsent: options.consentManager.requiresPrompt(options.serverName),
           cacheToolConsent: options.consentManager.shouldCacheConsent(),
           hostContext,
+          sandboxProxyUrl,
         });
 
         res.writeHead(200, {
@@ -498,9 +540,15 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
                   ...(options.onNeedsAuth ? { onNeedsAuth: options.onNeedsAuth } : {}),
                 },
                 options.serverName,
-                (conn) => conn.client.callTool(callArgs, options.manager.getRequestOptions?.(options.serverName)),
+                async (conn) => {
+                  await options.manager.ensureListen?.(options.serverName, conn);
+                  return conn.client.callTool(callArgs, options.manager.getRequestOptions?.(options.serverName));
+                },
               )
-            : await connection.client.callTool(callArgs, options.manager.getRequestOptions?.(options.serverName));
+            : await (async () => {
+                await options.manager.ensureListen?.(options.serverName, connection);
+                return connection.client.callTool(callArgs, options.manager.getRequestOptions?.(options.serverName));
+              })();
           sendJson(res, 200, { ok: true, result });
         } finally {
           options.manager.decrementInFlight(options.serverName);
@@ -614,12 +662,6 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
           : "done";
         markCompleted(reason);
         sendJson(res, 200, { ok: true, result: {} });
-        setTimeout(() => {
-          try {
-            server.close();
-          } catch {}
-          closeSse();
-        }, 20).unref();
         return;
       }
 
@@ -641,6 +683,7 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
       sendJson(res, status, { ok: false, error: wrapped.message });
     }
   });
+  server = hostServer;
 
   if (options.initialResultPromise) {
     options.initialResultPromise.then(
@@ -656,10 +699,6 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
     if (completed) return;
     if (Date.now() - lastHeartbeatAt <= ABANDONED_GRACE_MS) return;
     markCompleted("stale");
-    try {
-      server.close();
-    } catch {}
-    closeSse();
   }, WATCHDOG_INTERVAL_MS);
   watchdog.unref();
 
@@ -667,13 +706,79 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
     const candidates = resolvePortCandidates(options.port);
     let candidateIndex = 0;
 
+    const startSandboxProxy = (parentOrigin: string): Promise<number> => {
+      const proxy = http.createServer((req, res) => {
+        try {
+          const method = req.method || "GET";
+          const hostHeader = req.headers.host;
+          const url = new URL(req.url || "/", `http://${hostHeader || "127.0.0.1"}`);
+          if (hostHeader !== undefined && !isAllowedHost(url.hostname)) {
+            sendText(res, 403, "Invalid host");
+            return;
+          }
+
+          if (method === "HEAD" && url.pathname === SANDBOX_PROXY_PATH) {
+            res.writeHead(200, {
+              "Content-Type": "text/html; charset=utf-8",
+              "Cache-Control": "no-store",
+              "Content-Security-Policy": buildSandboxProxyCsp(),
+            });
+            res.end();
+            return;
+          }
+
+          if (method === "GET" && url.pathname === SANDBOX_PROXY_PATH) {
+            res.writeHead(200, {
+              "Content-Type": "text/html; charset=utf-8",
+              "Cache-Control": "no-store",
+              "Content-Security-Policy": buildSandboxProxyCsp(),
+              "Referrer-Policy": "no-referrer",
+              "X-Content-Type-Options": "nosniff",
+            });
+            res.end(buildSandboxProxyHtml({ parentOrigin }));
+            return;
+          }
+
+          sendJson(res, 404, { ok: false, error: "Not found" });
+        } catch (error) {
+          sendJson(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+      });
+      sandboxProxyServer = proxy;
+
+      return new Promise((resolveProxy, rejectProxy) => {
+        const onError = (error: NodeJS.ErrnoException) => {
+          proxy.off("listening", onListening);
+          rejectProxy(error);
+        };
+        const onListening = () => {
+          proxy.off("error", onError);
+          const address = proxy.address();
+          if (!address || typeof address === "string") {
+            rejectProxy(new ServerError("invalid sandbox proxy address"));
+            return;
+          }
+          resolveProxy(address.port);
+        };
+        proxy.once("error", onError);
+        proxy.listen(0, "127.0.0.1", onListening);
+      });
+    };
+
     const listen = () => {
-      server.once("error", onError);
-      server.listen(candidates[candidateIndex], "127.0.0.1", onListening);
+      const candidate = candidates[candidateIndex];
+      if (candidate === undefined) {
+        const error = new ServerError("no UI server port candidates available");
+        closeListeners();
+        reject(error);
+        return;
+      }
+      hostServer.once("error", onError);
+      hostServer.listen(candidate, "127.0.0.1", onListening);
     };
 
     const onError = (error: NodeJS.ErrnoException) => {
-      server.off("listening", onListening);
+      hostServer.off("listening", onListening);
       if (error.code === "EADDRINUSE" && candidateIndex < candidates.length - 1) {
         candidateIndex += 1;
         listen();
@@ -681,6 +786,7 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
       }
       log.error("Failed to start server", error);
       const port = candidates[candidateIndex];
+      closeListeners();
       reject(new ServerError(error.message, {
         ...(port !== undefined ? { port } : {}),
         cause: error,
@@ -688,52 +794,71 @@ export async function startUiServer(options: UiServerOptions): Promise<UiServerH
     };
 
     const onListening = () => {
-      server.off("error", onError);
-      const address = server.address();
+      hostServer.off("error", onError);
+      const address = hostServer.address();
       if (!address || typeof address === "string") {
         const err = new ServerError("invalid address");
         log.error("Invalid server address", err);
+        closeListeners();
         reject(err);
         return;
       }
 
-      log.debug("Server started", { port: address.port });
-      rememberMoshiDiscoveryPort(address.port);
-
-      const handle: UiServerHandle = {
-        url: `http://localhost:${address.port}/?session=${sessionToken}`,
-        port: address.port,
-        sessionToken,
-        serverName: options.serverName,
-        toolName: options.toolName,
-        close: (reason?: string) => {
-          markCompleted(reason ?? "closed");
-          try {
-            server.close();
-          } catch {}
-          closeSse();
-        },
-        sendToolInput: (args: Record<string, unknown>) => {
-          pushEvent("tool-input", { arguments: args });
-        },
-        sendToolResult: (result: CallToolResult) => {
-          pushEvent("tool-result", result);
-        },
-        sendResultPatch: (result: CallToolResult) => {
-          pushEvent("result-patch", result);
-        },
-        sendToolCancelled: (reason: string) => {
-          pushEvent("tool-cancelled", { reason });
-        },
-        sendHostContext: (context: UiHostContext) => {
-          Object.assign(hostContext, context);
-          pushEvent("host-context", context);
-        },
-        getSessionMessages: () => ({ ...sessionMessages }),
-        getStreamSummary: () => streamSummary ? { ...streamSummary, phases: [...streamSummary.phases] } : undefined,
-      };
+      const parentOrigin = `http://localhost:${address.port}`;
+      void startSandboxProxy(parentOrigin).then((proxyPort) => {
+        if (completed || listenersClosed) {
+          closeListeners();
+          reject(new ServerError("UI session completed before sandbox proxy was ready"));
+          return;
+        }
+        sandboxProxyUrl = `http://localhost:${proxyPort}${SANDBOX_PROXY_PATH}`;
+        log.debug("Servers started", { port: address.port, proxyPort });
+        rememberMoshiDiscoveryPort(address.port);
+
+        const handle: UiServerHandle = {
+          url: `http://localhost:${address.port}/?session=${sessionToken}`,
+          port: address.port,
+          proxyUrl: sandboxProxyUrl,
+          proxyPort,
+          sessionToken,
+          serverName: options.serverName,
+          toolName: options.toolName,
+          close: (reason?: string) => {
+            markCompleted(reason ?? "closed");
+            closeListeners();
+          },
+          sendToolInput: (args: Record<string, unknown>) => {
+            pushEvent("tool-input", { arguments: args });
+          },
+          sendToolResult: (result: CallToolResult) => {
+            pushEvent("tool-result", result);
+          },
+          sendResultPatch: (result: CallToolResult) => {
+            pushEvent("result-patch", result);
+          },
+          sendToolCancelled: (reason: string) => {
+            pushEvent("tool-cancelled", { reason });
+          },
+          sendResourceUpdated: (uri: string) => {
+            pushEvent("resource-updated", { uri });
+          },
+          sendHostContext: (context: UiHostContext) => {
+            Object.assign(hostContext, context);
+            pushEvent("host-context", context);
+          },
+          getSessionMessages: () => ({ ...sessionMessages }),
+          getStreamSummary: () => streamSummary ? { ...streamSummary, phases: [...streamSummary.phases] } : undefined,
+        };
 
-      resolve(handle);
+        resolve(handle);
+      }).catch((error) => {
+        log.error("Failed to start sandbox proxy", error instanceof Error ? error : undefined);
+        closeListeners();
+        const wrapped = error instanceof ServerError
+          ? error
+          : new ServerError(error instanceof Error ? error.message : String(error), { cause: error });
+        reject(wrapped);
+      });
     };
 
     listen();

package/node_modules/pi-mcp-adapter/ui-session.ts

@@ -21,6 +21,7 @@ import { isGlimpseAvailable, openGlimpseWindow } from "./glimpse-ui.ts";
 import type { SessionRecoveryDeps } from "./session-recovery.ts";
 import { combineAbortSignals, isAbortError } from "./runtime-owner.ts";
 import { throwIfAborted } from "./abort.ts";
+import { InputRequiredNeedsUiError } from "./errors.ts";
 
 let activeGlimpseWindow: { close(): void } | null = null;
 
@@ -172,7 +173,7 @@ function probeMoshiGateway(): Promise<boolean> {
   });
 }
 
-function remoteAccessHint(opts: { url: string; port: number; moshi: boolean; openError: string | null; openedOnHost?: boolean }): string {
+function remoteAccessHint(opts: { url: string; port: number; proxyPort: number; moshi: boolean; openError: string | null; openedOnHost?: boolean }): string {
   const lines = [
     opts.openError !== null
       ? "Couldn't open MCP UI here. Open it from your own device:"
@@ -185,10 +186,12 @@ function remoteAccessHint(opts: { url: string; port: number; moshi: boolean; ope
     lines.push(`Browser launch failed: ${opts.openError}`);
   }
   if (opts.moshi) {
-    lines.push("Moshi: tap the preview button in the terminal title bar and pick this MCP UI server.");
+    lines.push(
+      `Moshi: tap the preview button in the terminal title bar and pick this MCP UI server (it must reach ports ${opts.port} and ${opts.proxyPort}).`,
+    );
   }
   lines.push(
-    `SSH: run \`ssh -L ${opts.port}:127.0.0.1:${opts.port} <this-host>\` on your local machine, then open the URL above.`,
+    `SSH: run \`ssh -L ${opts.port}:127.0.0.1:${opts.port} -L ${opts.proxyPort}:127.0.0.1:${opts.proxyPort} <this-host>\` on your local machine, then open the URL above.`,
     "mosh can't forward ports - run that ssh command in a separate terminal.",
   );
   return lines.join("\n");
@@ -314,11 +317,13 @@ export async function maybeStartUiSession(
     let active = true;
     let nextStreamSequence = 0;
     let handle: UiServerHandle;
+    const resourceListenerToken = randomUUID();
 
-    const cleanupStreamListener = () => {
+    const cleanupListeners = () => {
       if (streamToken) {
         state.manager.removeUiStreamListener(streamToken);
       }
+      state.manager.removeResourceUpdatedListener?.(resourceListenerToken);
     };
 
     handle = await startUiServer({
@@ -394,7 +399,7 @@ export async function maybeStartUiSession(
 
       onComplete: (reason: string) => {
         active = false;
-        cleanupStreamListener();
+        cleanupListeners();
 
         if (state.uiServer === handle) {
           const messages = handle.getSessionMessages();
@@ -454,6 +459,16 @@ export async function maybeStartUiSession(
       });
     }
 
+    state.manager.registerResourceUpdatedListener?.(
+      resourceListenerToken,
+      request.serverName,
+      request.uiResourceUri,
+      (_serverName, uri) => {
+        if (!active || state.uiServer !== handle) return;
+        handle.sendResourceUpdated(uri);
+      },
+    );
+
     state.uiServer = handle;
 
     const viewerPref = process.env.MCP_UI_VIEWER?.toLowerCase();
@@ -466,7 +481,11 @@ export async function maybeStartUiSession(
     if (uiSuppressed) {
       viewer = "suppressed";
       windowOpen = false;
-      state.ui?.notify(`MCP UI window suppressed (MCP_UI_VIEWER=${viewerPref}). Open manually: ${handle.url}`, "info");
+      state.ui?.notify(
+        `MCP UI window suppressed (MCP_UI_VIEWER=${viewerPref}). Open manually: ${handle.url}\n` +
+        `If this session is remote, run ssh -L ${handle.port}:127.0.0.1:${handle.port} -L ${handle.proxyPort}:127.0.0.1:${handle.proxyPort} <this-host> first.`,
+        "info",
+      );
       log.info("Suppressing MCP UI window (MCP_UI_VIEWER=" + viewerPref + ")", { url: handle.url });
     } else {
       const remoteLikely = remoteByEnv || await hasActiveRemoteLogin();
@@ -474,6 +493,7 @@ export async function maybeStartUiSession(
         state.ui?.notify(remoteAccessHint({
           url: handle.url,
           port: handle.port,
+          proxyPort: handle.proxyPort,
           moshi: await probeMoshiGateway(),
           openError,
           openedOnHost,
@@ -554,12 +574,12 @@ export async function maybeStartUiSession(
       },
       close: (reason?: string) => {
         active = false;
-        cleanupStreamListener();
+        cleanupListeners();
         handle.close(reason);
       },
     };
   } catch (error) {
-    if (error instanceof UrlElicitationRequiredError || isAbortError(error, runtimeSignal)) throw error;
+    if (error instanceof UrlElicitationRequiredError || error instanceof InputRequiredNeedsUiError || isAbortError(error, runtimeSignal)) throw error;
     const message = error instanceof Error ? error.message : String(error);
     log.error("Failed to start UI session", error instanceof Error ? error : undefined);
     state.ui?.notify(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herbertgao/pi-extensions",
-  "version": "2026.8.15",
+  "version": "2026.9.0",
   "description": "Aggregate installer for HerbertGao-maintained Pi extensions.",
   "keywords": [
     "extensions",
@@ -44,11 +44,11 @@
     "@effect/platform-node": "4.0.0-beta.103",
     "@effect/platform-node-shared": "4.0.0-beta.103",
     "@herbertgao/pi-bark": "0.1.0",
-    "@herbertgao/pi-cc-extensions": "0.8.60",
+    "@herbertgao/pi-cc-extensions": "0.9.0",
     "@herbertgao/pi-subagents": "0.17.1",
     "@herbertgao/resume-from": "0.2.0",
-    "@juicesharp/rpiv-ask-user-question": "2.8.0",
-    "@juicesharp/rpiv-config": "^2.8.0",
+    "@juicesharp/rpiv-ask-user-question": "2.9.0",
+    "@juicesharp/rpiv-config": "^2.9.0",
     "@luxusai/pi-hindsight": "0.12.0",
     "@modelcontextprotocol/client": "2.0.0",
     "@modelcontextprotocol/core": "2.0.0",
@@ -56,14 +56,15 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
     "@napi-rs/keyring": "^1.3.0",
-    "@narumitw/pi-btw": "0.56.0",
+    "@narumitw/pi-btw": "0.57.0",
+    "@narumitw/pi-caffeinate": "0.49.7",
     "@narumitw/pi-tui-kit": "^0.59.0",
     "@noble/ed25519": "^3.1.0",
     "@pi-plugins/fast-mode": "0.1.10",
     "@shikijs/cli": "^4.0.2",
     "@sinclair/typebox": "^0.34.49",
     "@tifan/pi-copy-response": "0.2.6",
-    "@tifan/pi-handoff": "2.2.0",
+    "@tifan/pi-handoff": "2.2.1",
     "@tifan/pi-inline-skills": "1.0.5",
     "@tifan/pi-mermaid-open": "0.2.0",
     "@tifan/pi-preferred-thinking": "1.0.1",
@@ -75,6 +76,7 @@
     "chalk": "^6.0.0",
     "croner": "^10.0.1",
     "cross-spawn": "^7.0.6",
+    "dbus-native": "^0.15.2",
     "defuddle": "0.19.3",
     "effect": "4.0.0-beta.103",
     "gpt-tokenizer": "^3.4.0",
@@ -89,7 +91,7 @@
     "p-limit": "^6.1.0",
     "pi-footer": "0.5.1",
     "pi-lens": "4.1.3",
-    "pi-mcp-adapter": "2.31.0",
+    "pi-mcp-adapter": "2.32.1",
     "pi-web-access": "0.27.0",
     "pidusage": "^4.0.1",
     "promise.try": "^2.0.1",
@@ -120,6 +122,7 @@
     "@juicesharp/rpiv-ask-user-question",
     "@luxusai/pi-hindsight",
     "@narumitw/pi-btw",
+    "@narumitw/pi-caffeinate",
     "@pi-plugins/fast-mode",
     "@tifan/pi-copy-response",
     "@tifan/pi-handoff",
@@ -155,6 +158,7 @@
       "./node_modules/@herbertgao/pi-bark/src/index.ts",
       "./node_modules/@luxusai/pi-hindsight/extensions/index.ts",
       "./node_modules/@narumitw/pi-btw/dist/index.ts",
+      "./node_modules/@narumitw/pi-caffeinate/dist/index.ts",
       "./node_modules/@pi-plugins/fast-mode/dist/index.mjs",
       "./node_modules/pi-mcp-adapter/index.ts",
       "./node_modules/pi-lens/dist/index.js",