@humain/terminal 0.0.14 → 0.0.16

package/dist/humain/mcp-adapter/vendor/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/dist/humain/mcp-adapter/vendor/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/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
 	"name": "@humain/terminal",
-	"version": "0.0.14",
+	"version": "0.0.16",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@humain/terminal",
-			"version": "0.0.14",
+			"version": "0.0.16",
 			"license": "MIT",
 			"dependencies": {
 				"@humain/terminal-contracts": "0.0.3",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@humain/terminal",
-	"version": "0.0.14",
+	"version": "0.0.16",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"humainTerminalConfig": {

package/src/humain/mcp-adapter/UPSTREAM.md

@@ -1,7 +1,7 @@
 # pi-mcp-adapter upstream tracking
 
 HUMAIN Terminal vendors [`pi-mcp-adapter`](https://github.com/nicobailon/pi-mcp-adapter)
-version `2.31.0` so MCP support is available without a separate VM installation.
+version `2.32.1` so MCP support is available without a separate VM installation.
 
 The unmodified upstream package is recorded in `upstream.json`, including the
 registry integrity and source `gitHead`. The release currentness gate resolves

package/src/humain/mcp-adapter/upstream.json

@@ -1,8 +1,8 @@
 {
   "name": "pi-mcp-adapter",
   "repository": "https://github.com/nicobailon/pi-mcp-adapter",
-  "version": "2.31.0",
-  "tarball": "https://registry.npmjs.org/pi-mcp-adapter/-/pi-mcp-adapter-2.31.0.tgz",
-  "integrity": "sha512-yKPgHWFLQY6FT7ukCgEp5KvkAZ4ZC1pl7+8Tdq+j4evfTtjhHXPuIpi0joNN7lIIKuJD1cjlTb+hu6IxRpseoA==",
-  "gitHead": "eca6e8e14746f2a093e5d3085ccc244832962d71"
+  "version": "2.32.1",
+  "tarball": "https://registry.npmjs.org/pi-mcp-adapter/-/pi-mcp-adapter-2.32.1.tgz",
+  "integrity": "sha512-GNLYa2U9T5ZqIhZmhx/RTenEjfakJTelq/z6Q+At5SIxyuYvrvobriDEVsnx+lqetVDizUCudTWLfdZytQu0rg==",
+  "gitHead": "10a45367e033a32026987a75d6f401e37340c86f"
 }

package/src/humain/mcp-adapter/vendor/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.32.1] - 2026-09-01
+
+### Fixed
+- The published package now includes the updated public helper build artifacts for the `2.32.0` config and MCP Apps changes.
+
+## [2.32.0] - 2026-09-01
+
+### Highlights
+- You can now enable and disable MCP servers directly from the `/mcp` panel.
+- `/mcp setup` is clearer about where new shared servers will be saved.
+- MCP App views that use browser storage now render reliably without exposing host session access.
+- Long-running sessions handle MCP 2026 input flows, catalog updates, and UI resource refreshes more reliably.
+- OAuth reuse and per-server status messages are less confusing.
+
+### Added
+- The `/mcp` panel now supports enabling and disabling servers in place with `ctrl+d` on a server row. Saving persists the `disabled` flag to the project Pi layer and reloads the session, matching `/mcp disable` and `/mcp enable`. Thanks to [@ericykim](https://github.com/ericykim) for PR #479.
+
+### Changed
+- `/mcp setup` now lets you choose project `.mcp.json` or global `~/.config/mcp/mcp.json` as the write target for new shared MCP servers, while keeping Pi-owned files and compatibility inputs in the advanced flow. The bundled `mcp-scripting` skill is manual-only by default. Thanks to [@w-winter](https://github.com/w-winter) for #477.
+
+### Fixed
+- MCP 2026 multi-round input flows now work more reliably across proxy, direct, resource, and UI-resource calls, with clearer no-UI errors and cancellation cleanup.
+- MCP 2026-07-28 catalog listens now recover from dropped listens, refresh quietly when catalogs change, and notify open UIs when resources update. (#468)
+- MCP App views now load through a separate loopback sandbox proxy origin so storage APIs work without exposing host session capabilities. Thanks to [@drewbitt](https://github.com/drewbitt) for #480.
+- Implicit OAuth now reuses URL-bound stored credentials while preserving anonymous fallback. Thanks to [@wilt00](https://github.com/wilt00) for #471.
+- Per-server proxy lists now distinguish cached lazy tools from servers that need authentication while preserving active failure backoff. Thanks to [@inattendu](https://github.com/inattendu) for PR #474.
+
 ## [2.31.0] - 2026-08-28
 
 ### Highlights