@humain/terminal 0.0.2 → 0.0.3-beta.0

package/dist/humain/mcp-adapter/vendor/package.json

@@ -0,0 +1,178 @@
+{
+	"name": "pi-mcp-adapter",
+	"version": "2.25.0",
+	"description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
+	"type": "module",
+	"types": "./index.ts",
+	"exports": {
+		".": {
+			"types": "./index.ts",
+			"import": "./index.ts",
+			"default": "./index.ts"
+		},
+		"./types": {
+			"types": "./types.ts",
+			"import": "./types.ts",
+			"default": "./types.ts"
+		},
+		"./oauth": {
+			"types": "./oauth.ts",
+			"import": "./oauth.ts",
+			"default": "./oauth.ts"
+		}
+	},
+	"license": "MIT",
+	"author": "Nico Bailon",
+	"engines": {
+		"node": ">=20"
+	},
+	"bin": {
+		"pi-mcp-adapter": "cli.js"
+	},
+	"scripts": {
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:coverage": "vitest run --coverage",
+		"test:oauth": "PI_MCP_ADAPTER_TEST_AUTH_STORE=memory PI_MCP_ADAPTER_DISABLE_AUTH_CACHE=1 node --import tsx --test --test-concurrency=1 oauth-public-api.test.ts mcp-auth.test.ts mcp-auth-flow.test.ts mcp-callback-server.test.ts mcp-oauth-provider.test.ts",
+		"test:oauth-provider": "PI_MCP_ADAPTER_TEST_AUTH_STORE=memory PI_MCP_ADAPTER_DISABLE_AUTH_CACHE=1 node --import tsx --test mcp-oauth-provider.test.ts",
+		"test:conformance": "bash conformance/run.sh"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nicobailon/pi-mcp-adapter.git"
+	},
+	"keywords": [
+		"pi-package",
+		"pi",
+		"mcp",
+		"model-context-protocol",
+		"ai",
+		"coding-agent",
+		"extension",
+		"claude",
+		"llm"
+	],
+	"pi": {
+		"extensions": [
+			"./index.ts"
+		],
+		"skills": [
+			"./skills"
+		],
+		"video": "https://github.com/nicobailon/pi-mcp-adapter/raw/refs/heads/main/pi-mcp.mp4"
+	},
+	"files": [
+		"cli.js",
+		"agent-dir.ts",
+		"index.ts",
+		"error-signal.ts",
+		"state.ts",
+		"utils.ts",
+		"abort.ts",
+		"runtime-owner.ts",
+		"tool-metadata.ts",
+		"ts-shape.ts",
+		"search-ranking.ts",
+		"tool-approval.ts",
+		"init.ts",
+		"ui-session.ts",
+		"proxy-modes.ts",
+		"direct-tools.ts",
+		"commands.ts",
+		"prompts.ts",
+		"onboarding-state.ts",
+		"mcp-setup-panel.ts",
+		"types.ts",
+		"ui-stream-types.ts",
+		"ui-tool-visibility.ts",
+		"ui-app-bridge-helpers.ts",
+		"config.ts",
+		"server-manager.ts",
+		"unix-socket-transport.ts",
+		"json-schema-validator.ts",
+		"session-recovery.ts",
+		"sampling-handler.ts",
+		"elicitation-handler.ts",
+		"tool-registrar.ts",
+		"tool-result-renderer.ts",
+		"mcp-output-guard.ts",
+		"mcp-code.ts",
+		"mcp-script-worker.mjs",
+		"mcp-probe.ts",
+		"agent-plugin-loader.ts",
+		"resource-tools.ts",
+		"lifecycle.ts",
+		"mcp-status.ts",
+		"metadata-cache.ts",
+		"host-html-template.ts",
+		"ui-resource-handler.ts",
+		"consent-manager.ts",
+		"ui-server.ts",
+		"glimpse-ui.ts",
+		"npx-resolver.ts",
+		"oauth-handler.ts",
+		"oauth.ts",
+		"mcp-auth.ts",
+		"mcp-keyring-helper.cjs",
+		"mcp-oauth-provider.ts",
+		"mcp-callback-server.ts",
+		"mcp-auth-flow.ts",
+		"mcp-panel.ts",
+		"panel-keys.ts",
+		"mcp-trace.ts",
+		"logger.ts",
+		"errors.ts",
+		"app-bridge.bundle.js",
+		"banner.png",
+		"skills",
+		"README.md",
+		"CHANGELOG.md",
+		"LICENSE"
+	],
+	"dependencies": {
+		"@modelcontextprotocol/client": "2.0.0",
+		"@modelcontextprotocol/core": "2.0.0",
+		"@modelcontextprotocol/ext-apps": "^1.2.2",
+		"@napi-rs/keyring": "^1.3.0",
+		"ajv": "^8.17.1",
+		"ajv-formats": "^3.0.1",
+		"cross-spawn": "^7.0.6",
+		"open": "^10.2.0",
+		"recheck": "^4.5.0",
+		"smol-toml": "^1.6.1",
+		"strip-json-comments": "^5.0.3",
+		"zod": "^3.25.0 || ^4.0.0"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "^0.84.1",
+		"@earendil-works/pi-tui": "*",
+		"typebox": "*",
+		"zod": "^3.25.0 || ^4.0.0"
+	},
+	"peerDependenciesMeta": {
+		"@earendil-works/pi-ai": {
+			"optional": true
+		},
+		"@earendil-works/pi-tui": {
+			"optional": true
+		},
+		"typebox": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "^0.84.1",
+		"@earendil-works/pi-coding-agent": "0.84.1",
+		"@earendil-works/pi-tui": "^0.84.1",
+		"@modelcontextprotocol/conformance": "0.1.16",
+		"@types/bun": "^1.0.0",
+		"@types/cross-spawn": "6.0.6",
+		"@types/node": "20.19.43",
+		"@types/open": "^6.2.1",
+		"tsx": "^4.21.0",
+		"typebox": "1.3.3",
+		"typescript": "5.9.3",
+		"vitest": "^3.0.0"
+	}
+}

package/dist/humain/mcp-adapter/vendor/panel-keys.ts

@@ -0,0 +1,53 @@
+import { matchesKey, type KeyId } from "@earendil-works/pi-tui";
+
+/** The panel keybinding ids the adapter panels resolve through pi-tui. */
+export type PanelSelectKeybinding =
+  | "tui.select.up"
+  | "tui.select.down"
+  | "tui.select.confirm";
+
+/** Structural subset of pi-tui's `KeybindingsManager` (which satisfies it). */
+export interface PanelKeybindings {
+  matches(data: string, keybinding: PanelSelectKeybinding): boolean;
+  getUserBindings?(): Record<string, KeyId | KeyId[] | undefined>;
+}
+
+/**
+ * Key matchers for panel actions: user bindings when a manager is provided,
+ * otherwise the previous hardcoded defaults.
+ */
+export interface PanelKeys {
+  selectUp(data: string): boolean;
+  selectDown(data: string): boolean;
+  selectConfirm(data: string): boolean;
+  save(data: string): boolean;
+  saveLabel(): string | null;
+}
+
+function configuredSaveKeys(keybindings?: PanelKeybindings): { keys: KeyId[]; configured: boolean } {
+  const explicit = keybindings?.getUserBindings?.()["mcp.panel.save"];
+  if (explicit !== undefined) return { keys: Array.isArray(explicit) ? explicit : [explicit], configured: true };
+  return { keys: [], configured: false };
+}
+
+export function createPanelKeys(keybindings?: PanelKeybindings): PanelKeys {
+  const saveBinding = configuredSaveKeys(keybindings);
+  if (keybindings) {
+    return {
+      selectUp: (data) => keybindings.matches(data, "tui.select.up"),
+      selectDown: (data) => keybindings.matches(data, "tui.select.down"),
+      selectConfirm: (data) => keybindings.matches(data, "tui.select.confirm"),
+      save: (data) => saveBinding.keys.length > 0
+        ? saveBinding.keys.some((key) => matchesKey(data, key))
+        : !saveBinding.configured && matchesKey(data, "ctrl+s"),
+      saveLabel: () => saveBinding.keys[0] ?? (saveBinding.configured ? null : "ctrl+s"),
+    };
+  }
+  return {
+    selectUp: (data) => matchesKey(data, "up"),
+    selectDown: (data) => matchesKey(data, "down"),
+    selectConfirm: (data) => matchesKey(data, "return"),
+    save: (data) => matchesKey(data, "ctrl+s"),
+    saveLabel: () => "ctrl+s",
+  };
+}

package/dist/humain/mcp-adapter/vendor/prompts.ts

@@ -0,0 +1,353 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type {
+  GetPromptResult,
+  PromptMessage,
+} from "@modelcontextprotocol/client";
+import type { McpExtensionState } from "./state.ts";
+import { isServerDisabled, type McpConfig, type PromptMetadata } from "./types.ts";
+import { formatPromptCommandName } from "./types.ts";
+import { lazyConnect } from "./init.ts";
+import { isServerCacheValid, loadMetadataCache, reconstructPromptMetadata } from "./metadata-cache.ts";
+import { logger } from "./logger.ts";
+import { truncateAtWord } from "./utils.ts";
+
+/**
+ * Resolve prompt metadata for slash-command registration at extension load
+ * time. Mirrors `resolveDirectTools`: reads the persistent metadata cache so
+ * commands are available before any server connects.
+ */
+export function resolveCachedPrompts(config: McpConfig): PromptMetadata[] {
+  const cache = loadMetadataCache();
+  if (!cache?.servers) return [];
+
+  const prefix = config.settings?.toolPrefix ?? "server";
+  const specs: PromptMetadata[] = [];
+
+  for (const [serverName, entry] of Object.entries(cache.servers)) {
+    const definition = config.mcpServers[serverName];
+    if (!definition || isServerDisabled(definition)) continue;
+    if (!entry?.prompts?.length || !isServerCacheValid(entry, definition)) continue;
+    specs.push(...reconstructPromptMetadata(serverName, entry.prompts, prefix, definition));
+  }
+
+  return specs;
+}
+
+/**
+ * Parse a slash-command argument string into positional and named MCP prompt
+ * arguments. Supports bash-style quoting so callers can pass values with
+ * spaces:
+ *
+ *   /mcp__demo__brief today "important tasks"
+ *   /mcp__demo__brief day=today topic="important tasks"
+ */
+export function parsePromptArgs(input: string): { positional: string[]; named: Record<string, string> } {
+  const positional: string[] = [];
+  const named: Record<string, string> = {};
+
+  const tokens = tokenizeArgs(input);
+  for (const token of tokens) {
+    const eq = findUnquotedEquals(token);
+    if (eq > 0) {
+      const key = token.slice(0, eq).trim();
+      const value = stripQuotes(token.slice(eq + 1).trim());
+      if (key) {
+        named[key] = value;
+        continue;
+      }
+    }
+    positional.push(stripQuotes(token));
+  }
+
+  return { positional, named };
+}
+
+function tokenizeArgs(input: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: '"' | "'" | null = null;
+  let escaped = false;
+
+  for (const char of input) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      current += char;
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+
+  if (current.length > 0) tokens.push(current);
+  return tokens;
+}
+
+function findUnquotedEquals(token: string): number {
+  let quote: '"' | "'" | null = null;
+  for (let i = 0; i < token.length; i++) {
+    const ch = token[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === "=") return i;
+  }
+  return -1;
+}
+
+function stripQuotes(value: string): string {
+  if (value.length >= 2 && (value.startsWith('"') || value.startsWith("'")) && value.endsWith(value.charAt(0))) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+export interface ResolvedPromptArgs {
+  ok: boolean;
+  /** Present when `ok === true`. */
+  args?: Record<string, string>;
+  /** Present when `ok === false`. */
+  error?: string;
+}
+
+/**
+ * Map positional and named arguments onto the prompt's declared argument
+ * list. Named arguments win over positional when both target the same slot.
+ * Missing required arguments produce a helpful usage message that the
+ * command handler surfaces via `ctx.ui.notify`.
+ */
+export function resolvePromptArgs(
+  metadata: PromptMetadata,
+  parsed: { positional: string[]; named: Record<string, string> },
+): ResolvedPromptArgs {
+  const args: Record<string, string> = {};
+
+  const declared = metadata.arguments;
+  let positionalIndex = 0;
+  for (const argDef of declared) {
+    const value = parsed.named[argDef.name] ?? parsed.positional[positionalIndex++];
+    if (value !== undefined && value !== "") {
+      args[argDef.name] = value;
+    }
+  }
+
+  // Preserve named arguments the prompt did not declare so servers with
+  // permissive schemas still receive them. The MCP spec allows arbitrary
+  // string key/values in `prompts/get` params.arguments.
+  for (const [key, value] of Object.entries(parsed.named)) {
+    if (!(key in args)) args[key] = value;
+  }
+
+  const missing = declared.filter(a => a.required && (args[a.name] === undefined || args[a.name] === ""));
+  if (missing.length > 0) {
+    return { ok: false, error: buildUsageMessage(metadata, missing) };
+  }
+
+  return { ok: true, args };
+}
+
+function buildUsageMessage(metadata: PromptMetadata, missing: PromptMetadata["arguments"]): string {
+  const usage = metadata.arguments
+    .map(a => (a.required ? `<${a.name}>` : `[${a.name}]`))
+    .join(" ");
+  const missingList = missing.map(a => a.name).join(", ");
+  return `Missing required argument${missing.length > 1 ? "s" : ""}: ${missingList}.\nUsage: /${metadata.commandName} ${usage}`.trim();
+}
+
+/**
+ * Flatten a `GetPromptResult` into a single string suitable for
+ * `pi.sendUserMessage`. MCP prompts can contain multiple messages with
+ * mixed roles; we preserve role attribution as inline markers so the model
+ * still sees the intended conversational shape without needing a
+ * multi-message replay API on the pi side.
+ */
+export function formatPromptResult(result: GetPromptResult): string {
+  const lines: string[] = [];
+  for (const message of result.messages) {
+    const text = extractMessageText(message);
+    if (!text) continue;
+    if (message.role === "user" && result.messages.length === 1) {
+      lines.push(text);
+    } else {
+      lines.push(`[${message.role}] ${text}`);
+    }
+  }
+  return lines.join("\n\n").trim();
+}
+
+function extractMessageText(message: PromptMessage): string {
+  const content = message.content;
+  if (!content || typeof content !== "object") return "";
+  switch (content.type) {
+    case "text":
+      return content.text ?? "";
+    case "resource": {
+      const resource = content.resource;
+      if (!resource) return "";
+      if ("text" in resource && typeof resource.text === "string") {
+        return `[resource ${resource.uri}]\n${resource.text}`;
+      }
+      return `[resource ${resource.uri}]`;
+    }
+    case "resource_link":
+      return `[resource_link ${content.uri ?? ""}${content.name ? ` — ${content.name}` : ""}]`;
+    case "image":
+      return `[image ${content.mimeType ?? "unknown"}${content.data ? " (embedded)" : ""}]`;
+    case "audio":
+      return `[audio ${content.mimeType ?? "unknown"}]`;
+    default:
+      return "";
+  }
+}
+
+/**
+ * Build the pi command definition for a single MCP prompt. Registered once
+ * per prompt at extension load time from the metadata cache; the same
+ * factory is reused by tests to invoke the handler without a running pi.
+ */
+export function createPromptCommand(
+  pi: ExtensionAPI,
+  getState: () => McpExtensionState | null,
+  metadata: PromptMetadata,
+) {
+  const description = buildCommandDescription(metadata);
+
+  return {
+    description,
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const state = getState();
+      if (!state) {
+        if (ctx.hasUI) ctx.ui.notify("MCP not initialized", "error");
+        return;
+      }
+
+      const liveMetadata = findLivePromptMetadata(state, metadata.serverName, metadata.originalName);
+      if (state.promptMetadataLive?.has(metadata.serverName) && !liveMetadata) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(
+            `MCP prompt "${metadata.originalName}" is no longer advertised by server "${metadata.serverName}". Run /mcp reconnect to refresh.`,
+            "error",
+          );
+        }
+        return;
+      }
+      const live = liveMetadata ?? metadata;
+      const parsed = parsePromptArgs(args ?? "");
+      const resolved = resolvePromptArgs(live, parsed);
+      if (!resolved.ok) {
+        if (ctx.hasUI) ctx.ui.notify(resolved.error ?? "Invalid prompt arguments", "error");
+        return;
+      }
+      const promptArgs = resolved.args ?? {};
+
+      if (!state.config.mcpServers[metadata.serverName]) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(
+            `MCP prompt "${live.originalName}" is no longer configured. Run /mcp reconnect to refresh.`,
+            "error",
+          );
+        }
+        return;
+      }
+
+      const connected = await lazyConnect(state, metadata.serverName, ctx.signal);
+      if (!connected) {
+        if (ctx.hasUI) {
+          const conn = state.manager.getConnection(metadata.serverName);
+          const message = conn?.status === "needs-auth"
+            ? `MCP server "${metadata.serverName}" needs authentication. Run /mcp-auth ${metadata.serverName}.`
+            : `MCP server "${metadata.serverName}" is not available. Run /mcp reconnect ${metadata.serverName}.`;
+          ctx.ui.notify(message, "error");
+        }
+        return;
+      }
+
+      const refreshed = findLivePromptMetadata(state, metadata.serverName, metadata.originalName);
+      if (state.promptMetadataLive?.has(metadata.serverName) && !refreshed) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(
+            `MCP prompt "${metadata.originalName}" is no longer advertised by server "${metadata.serverName}". Run /mcp reconnect to refresh.`,
+            "error",
+          );
+        }
+        return;
+      }
+      const dispatchMetadata = refreshed ?? live;
+      let result: GetPromptResult;
+      try {
+        result = await state.manager.getPrompt(
+          metadata.serverName,
+          dispatchMetadata.originalName,
+          Object.keys(promptArgs).length > 0 ? promptArgs : undefined,
+          ctx.signal,
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.debug(`MCP prompt "${live.originalName}" on ${metadata.serverName} failed: ${message}`);
+        if (ctx.hasUI) {
+          ctx.ui.notify(`MCP prompt "${live.originalName}" failed: ${message}`, "error");
+        }
+        return;
+      }
+
+      const text = formatPromptResult(result);
+      if (!text) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(`MCP prompt "${live.originalName}" returned no text content.`, "warning");
+        }
+        return;
+      }
+
+      pi.sendUserMessage(text);
+    },
+  };
+}
+
+function findLivePromptMetadata(
+  state: McpExtensionState,
+  serverName: string,
+  originalName: string,
+): PromptMetadata | undefined {
+  return state.promptMetadata?.get(serverName)?.find(p => p.originalName === originalName);
+}
+
+function buildCommandDescription(metadata: PromptMetadata): string {
+  const base = metadata.description || metadata.title || `MCP prompt from ${metadata.serverName}`;
+  return truncateAtWord(`MCP: ${base}`, 120) || `MCP prompt from ${metadata.serverName}`;
+}
+
+/**
+ * Public helper used by `/mcp prompts` to render the list of prompts known
+ * to the adapter, whether from a live connection or the metadata cache.
+ */
+export function listAllPromptMetadata(state: McpExtensionState): PromptMetadata[] {
+  const flat: PromptMetadata[] = [];
+  for (const list of state.promptMetadata?.values() ?? []) flat.push(...list);
+  flat.sort((a, b) => a.commandName.localeCompare(b.commandName));
+  return flat;
+}
+
+// Re-exported so index.ts can format cache-only prompt-command names without
+// duplicating the namespace logic.
+export { formatPromptCommandName };