pi-soly 1.9.3 → 1.11.0

package/mcp/npx-resolver.ts

@@ -0,0 +1,424 @@
+// npx-resolver.ts - Resolve npx/npm exec binaries to avoid npm parent processes
+import { existsSync, readFileSync, realpathSync, readdirSync, statSync, writeFileSync, renameSync, mkdirSync, openSync, readSync, closeSync } from "node:fs";
+import { join, dirname, extname, resolve, sep } from "node:path";
+import { getAgentPath } from "./agent-dir.ts";
+import { spawn, spawnSync } from "node:child_process";
+
+const CACHE_VERSION = 1;
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
+interface NpxCacheEntry {
+  resolvedBin: string;
+  resolvedAt: number;
+  packageVersion?: string;
+  isJs: boolean;
+}
+
+interface NpxCache {
+  version: number;
+  entries: Record<string, NpxCacheEntry>;
+}
+
+export interface NpxResolution {
+  binPath: string;
+  extraArgs: string[];
+  isJs: boolean;
+}
+
+interface ParsedInvocation {
+  packageSpec: string;
+  binName?: string;
+  extraArgs: string[];
+}
+
+export async function resolveNpxBinary(
+  command: string,
+  args: string[]
+): Promise<NpxResolution | null> {
+  const parsed = command === "npx"
+    ? parseNpxArgs(args)
+    : command === "npm"
+      ? parseNpmExecArgs(args)
+      : null;
+
+  if (!parsed) return null;
+
+  const cacheKey = JSON.stringify([command, ...args]);
+  const cache = loadCache();
+  const cached = cache?.entries?.[cacheKey];
+
+  if (cached && Date.now() - cached.resolvedAt < CACHE_TTL_MS && existsSync(cached.resolvedBin)) {
+    return { binPath: cached.resolvedBin, extraArgs: parsed.extraArgs, isJs: cached.isJs };
+  }
+
+  const resolved = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
+  if (resolved) {
+    saveCacheEntry(cacheKey, resolved);
+    return { binPath: resolved.resolvedBin, extraArgs: parsed.extraArgs, isJs: resolved.isJs };
+  }
+
+  // Slow path: force npx cache population
+  await forceNpxCache(parsed.packageSpec);
+  const resolvedAfterInstall = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
+  if (resolvedAfterInstall) {
+    saveCacheEntry(cacheKey, resolvedAfterInstall);
+    return { binPath: resolvedAfterInstall.resolvedBin, extraArgs: parsed.extraArgs, isJs: resolvedAfterInstall.isJs };
+  }
+
+  return null;
+}
+
+function parseNpxArgs(args: string[]): ParsedInvocation | null {
+  const separatorIndex = args.indexOf("--");
+  const before = separatorIndex >= 0 ? args.slice(0, separatorIndex) : args;
+  const after = separatorIndex >= 0 ? args.slice(separatorIndex + 1) : [];
+
+  const positionals: string[] = [];
+  let packageSpec: string | undefined;
+  let sawPackageFlag = false;
+  let foundFirstPositional = false;
+
+  for (let i = 0; i < before.length; i++) {
+    const arg = before[i];
+    if (foundFirstPositional) {
+      positionals.push(arg);
+      continue;
+    }
+    if (arg === "-y" || arg === "--yes") continue;
+    if (arg === "-p" || arg === "--package") {
+      const value = before[i + 1];
+      if (!value || value.startsWith("-")) return null;
+      if (!packageSpec) packageSpec = value;
+      sawPackageFlag = true;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--package=")) {
+      const value = arg.slice("--package=".length);
+      if (!value) return null;
+      if (!packageSpec) packageSpec = value;
+      sawPackageFlag = true;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      return null;
+    }
+    positionals.push(arg);
+    foundFirstPositional = true;
+  }
+
+  if (sawPackageFlag) {
+    const binName = positionals[0];
+    if (!packageSpec || !binName) return null;
+    const extraArgs = positionals.slice(1).concat(after);
+    return { packageSpec, binName, extraArgs };
+  }
+
+  const packagePositional = positionals[0];
+  if (!packagePositional) return null;
+  const extraArgs = positionals.slice(1).concat(after);
+  return { packageSpec: packagePositional, extraArgs };
+}
+
+function parseNpmExecArgs(args: string[]): ParsedInvocation | null {
+  if (args[0] !== "exec") return null;
+  const execArgs = args.slice(1);
+  const separatorIndex = execArgs.indexOf("--");
+  if (separatorIndex < 0) return null;
+
+  const before = execArgs.slice(0, separatorIndex);
+  const after = execArgs.slice(separatorIndex + 1);
+
+  let packageSpec: string | undefined;
+  for (let i = 0; i < before.length; i++) {
+    const arg = before[i];
+    if (arg === "-y" || arg === "--yes") continue;
+    if (arg === "--package") {
+      const value = before[i + 1];
+      if (!value || value.startsWith("-")) return null;
+      if (!packageSpec) packageSpec = value;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--package=")) {
+      const value = arg.slice("--package=".length);
+      if (!value) return null;
+      if (!packageSpec) packageSpec = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      return null;
+    }
+  }
+
+  const binName = after[0];
+  if (!packageSpec || !binName) return null;
+  const extraArgs = after.slice(1);
+  return { packageSpec, binName, extraArgs };
+}
+
+function resolveFromNpmCache(packageSpec: string, binName?: string): NpxCacheEntry | null {
+  const cacheDir = getNpmCacheDir();
+  if (!cacheDir) return null;
+
+  const packageName = extractPackageName(packageSpec);
+  if (!packageName) return null;
+
+  const packageDir = findCachedPackageDir(cacheDir, packageName);
+  if (!packageDir) return null;
+
+  const packageJsonPath = join(packageDir, "package.json");
+  if (!existsSync(packageJsonPath)) return null;
+
+  let pkg: { bin?: string | Record<string, string>; version?: string } | null = null;
+  try {
+    pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as {
+      bin?: string | Record<string, string>;
+      version?: string;
+    };
+  } catch {
+    return null;
+  }
+
+  const binField = pkg?.bin;
+  if (!binField) return null;
+
+  const candidates = buildBinCandidates(packageName, binName);
+  let chosenBinName: string | undefined;
+  let binRel: string | undefined;
+
+  if (typeof binField === "string") {
+    chosenBinName = defaultBinName(packageName);
+    binRel = binField;
+  } else {
+    for (const candidate of candidates) {
+      if (binField[candidate]) {
+        chosenBinName = candidate;
+        binRel = binField[candidate];
+        break;
+      }
+    }
+    if (!binRel) {
+      const firstEntry = Object.entries(binField)[0];
+      if (firstEntry) {
+        chosenBinName = firstEntry[0];
+        binRel = firstEntry[1];
+      }
+    }
+  }
+
+  if (!binRel) return null;
+
+  const nodeModulesDir = findNodeModulesDir(packageDir);
+  const binLink = chosenBinName ? join(nodeModulesDir, ".bin", chosenBinName) : null;
+  let resolvedBin = binLink && existsSync(binLink) ? safeRealpath(binLink) : "";
+  if (!resolvedBin) {
+    resolvedBin = resolve(packageDir, binRel);
+    if (!existsSync(resolvedBin)) return null;
+  }
+
+  const isJs = detectJsBinary(resolvedBin);
+  return {
+    resolvedBin,
+    resolvedAt: Date.now(),
+    packageVersion: pkg?.version,
+    isJs,
+  };
+}
+
+const FORCE_CACHE_TIMEOUT_MS = 30_000;
+
+async function forceNpxCache(packageSpec: string): Promise<void> {
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const proc = spawn(
+        "npm",
+        ["exec", "--yes", "--package", packageSpec, "--", "node", "-e", "1"],
+        { stdio: "ignore" }
+      );
+      const timer = setTimeout(() => {
+        proc.kill();
+        reject(new Error("timeout"));
+      }, FORCE_CACHE_TIMEOUT_MS);
+      timer.unref();
+      proc.on("close", () => { clearTimeout(timer); resolve(); });
+      proc.on("error", (err) => { clearTimeout(timer); reject(err); });
+    });
+  } catch {
+    // Ignore failures, resolution will fall back to original command
+  }
+}
+
+function buildBinCandidates(packageName: string, explicitBin?: string): string[] {
+  const candidates: string[] = [];
+  if (explicitBin) candidates.push(explicitBin);
+
+  if (packageName.startsWith("@")) {
+    const namePart = packageName.split("/")[1] ?? "";
+    const scopePart = packageName.split("/")[0]?.replace("@", "") ?? "";
+    if (namePart) candidates.push(namePart);
+    if (scopePart && namePart) candidates.push(`${scopePart}-${namePart}`);
+  } else {
+    candidates.push(packageName);
+  }
+
+  return [...new Set(candidates.filter(Boolean))];
+}
+
+function extractPackageName(spec: string): string | null {
+  const trimmed = spec.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("@")) {
+    const slashIndex = trimmed.indexOf("/");
+    if (slashIndex < 0) return null;
+    const atIndex = trimmed.lastIndexOf("@");
+    if (atIndex > slashIndex) {
+      return trimmed.slice(0, atIndex);
+    }
+    return trimmed;
+  }
+  const atIndex = trimmed.indexOf("@");
+  return atIndex >= 0 ? trimmed.slice(0, atIndex) : trimmed;
+}
+
+function defaultBinName(packageName: string): string {
+  if (packageName.startsWith("@")) {
+    const parts = packageName.split("/");
+    return parts[1] ?? packageName.replace("@", "").replace("/", "-");
+  }
+  return packageName;
+}
+
+function findCachedPackageDir(cacheDir: string, packageName: string): string | null {
+  const npxDir = join(cacheDir, "_npx");
+  if (!existsSync(npxDir)) return null;
+
+  const packagePathParts = packageName.startsWith("@")
+    ? packageName.split("/")
+    : [packageName];
+
+  const candidates = readdirSync(npxDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .map(entry => {
+      const full = join(npxDir, entry.name);
+      const mtime = safeStatMtime(full);
+      return { name: entry.name, mtime };
+    })
+    .sort((a, b) => b.mtime - a.mtime);
+
+  for (const entry of candidates) {
+    const pkgDir = join(npxDir, entry.name, "node_modules", ...packagePathParts);
+    if (existsSync(join(pkgDir, "package.json"))) {
+      return pkgDir;
+    }
+  }
+
+  return null;
+}
+
+function findNodeModulesDir(packageDir: string): string {
+  const parts = packageDir.split(sep);
+  const idx = parts.lastIndexOf("node_modules");
+  if (idx >= 0) {
+    return parts.slice(0, idx + 1).join(sep);
+  }
+  return join(packageDir, "..");
+}
+
+function detectJsBinary(binPath: string): boolean {
+  const ext = extname(binPath).toLowerCase();
+  if (ext === ".js" || ext === ".mjs" || ext === ".cjs") return true;
+  try {
+    const fd = openSync(binPath, "r");
+    try {
+      const buf = Buffer.alloc(256);
+      readSync(fd, buf, 0, 256, 0);
+      const firstLine = buf.toString("utf-8").split("\n")[0] ?? "";
+      return firstLine.startsWith("#!") && firstLine.includes("node");
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return false;
+  }
+}
+
+let npmCacheDirCached: string | null | undefined;
+
+function getNpmCacheDir(): string | null {
+  if (npmCacheDirCached !== undefined) return npmCacheDirCached;
+  if (process.env.NPM_CONFIG_CACHE) {
+    npmCacheDirCached = process.env.NPM_CONFIG_CACHE;
+    return npmCacheDirCached;
+  }
+  try {
+    const result = spawnSync("npm", ["config", "get", "cache"], { encoding: "utf-8" });
+    if (result.status === 0) {
+      const path = String(result.stdout).trim();
+      npmCacheDirCached = path || null;
+      return npmCacheDirCached;
+    }
+  } catch {
+    npmCacheDirCached = null;
+    return null;
+  }
+  npmCacheDirCached = null;
+  return null;
+}
+
+function getNpxCachePath(): string {
+  return getAgentPath("mcp-npx-cache.json");
+}
+
+function loadCache(): NpxCache | null {
+  const cachePath = getNpxCachePath();
+  if (!existsSync(cachePath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
+    if (!raw || typeof raw !== "object") return null;
+    if (raw.version !== CACHE_VERSION) return null;
+    if (!raw.entries || typeof raw.entries !== "object") return null;
+    return raw as NpxCache;
+  } catch {
+    return null;
+  }
+}
+
+function saveCacheEntry(key: string, entry: NpxCacheEntry): void {
+  const cachePath = getNpxCachePath();
+  const dir = dirname(cachePath);
+  mkdirSync(dir, { recursive: true });
+
+  let merged: NpxCache = { version: CACHE_VERSION, entries: {} };
+  try {
+    if (existsSync(cachePath)) {
+      const existing = JSON.parse(readFileSync(cachePath, "utf-8")) as NpxCache;
+      if (existing && existing.version === CACHE_VERSION && existing.entries) {
+        merged.entries = { ...existing.entries };
+      }
+    }
+  } catch {
+    // Ignore parse errors
+  }
+
+  merged.entries[key] = entry;
+  const tmpPath = `${cachePath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(merged, null, 2), "utf-8");
+  renameSync(tmpPath, cachePath);
+}
+
+function safeRealpath(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return "";
+  }
+}
+
+function safeStatMtime(path: string): number {
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+}

package/mcp/oauth-handler.ts

@@ -0,0 +1,57 @@
+// oauth-handler.ts - OAuth token management for MCP servers
+import { existsSync, readFileSync } from "node:fs";
+import type { OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import { getAuthEntryFilePath } from "./mcp-auth.ts";
+
+// Token storage path for a server
+function getTokensPath(serverName: string): string {
+  return getAuthEntryFilePath(serverName);
+}
+
+/**
+ * Get stored OAuth tokens for a server (if any).
+ * Returns undefined if no tokens or tokens are expired.
+ * 
+ * Token file location: $MCP_OAUTH_DIR/sha256-<server-hash>/tokens.json when set,
+ * otherwise <Pi agent dir>/mcp-oauth/sha256-<server-hash>/tokens.json
+ * 
+ * Expected format:
+ * {
+ *   "access_token": "...",
+ *   "token_type": "bearer",
+ *   "refresh_token": "...",  // optional
+ *   "expires_in": 3600,      // optional, seconds
+ *   "expiresAt": 1234567890  // optional, absolute timestamp ms
+ * }
+ */
+export function getStoredTokens(serverName: string): OAuthTokens | undefined {
+  const tokensPath = getTokensPath(serverName);
+  
+  if (!existsSync(tokensPath)) return undefined;
+  
+  try {
+    const stored = JSON.parse(readFileSync(tokensPath, "utf-8"));
+    
+    // Validate required field
+    if (!stored.access_token || typeof stored.access_token !== "string") {
+      return undefined;
+    }
+    
+    // Check expiration if expiresAt is set
+    if (stored.expiresAt && typeof stored.expiresAt === "number") {
+      if (Date.now() > stored.expiresAt) {
+        // Token expired
+        return undefined;
+      }
+    }
+    
+    return {
+      access_token: stored.access_token,
+      token_type: stored.token_type ?? "bearer",
+      refresh_token: stored.refresh_token,
+      expires_in: stored.expires_in,
+    };
+  } catch {
+    return undefined;
+  }
+}

package/mcp/onboarding-state.ts

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+import { dirname } from "node:path";
+import { getAgentPath } from "./agent-dir.ts";
+
+export interface McpOnboardingState {
+  version: 1;
+  sharedConfigHintShown: boolean;
+  setupCompleted: boolean;
+  lastDiscoveryFingerprint?: string;
+}
+
+const DEFAULT_STATE: McpOnboardingState = {
+  version: 1,
+  sharedConfigHintShown: false,
+  setupCompleted: false,
+};
+
+export function getOnboardingStatePath(): string {
+  return getAgentPath("mcp-onboarding.json");
+}
+
+export function loadOnboardingState(): McpOnboardingState {
+  const path = getOnboardingStatePath();
+  if (!existsSync(path)) return { ...DEFAULT_STATE };
+
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf-8")) as Partial<McpOnboardingState>;
+    if (!raw || typeof raw !== "object") return { ...DEFAULT_STATE };
+    return {
+      version: 1,
+      sharedConfigHintShown: raw.sharedConfigHintShown === true,
+      setupCompleted: raw.setupCompleted === true,
+      lastDiscoveryFingerprint: typeof raw.lastDiscoveryFingerprint === "string" ? raw.lastDiscoveryFingerprint : undefined,
+    };
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+
+export function saveOnboardingState(state: McpOnboardingState): void {
+  const path = getOnboardingStatePath();
+  mkdirSync(dirname(path), { recursive: true });
+  const tmpPath = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+  renameSync(tmpPath, path);
+}
+
+export function updateOnboardingState(updater: (state: McpOnboardingState) => McpOnboardingState): McpOnboardingState {
+  const next = updater(loadOnboardingState());
+  saveOnboardingState(next);
+  return next;
+}
+
+export function markSharedConfigHintShown(fingerprint?: string): McpOnboardingState {
+  return updateOnboardingState((state) => ({
+    ...state,
+    sharedConfigHintShown: true,
+    lastDiscoveryFingerprint: fingerprint ?? state.lastDiscoveryFingerprint,
+  }));
+}
+
+export function markSetupCompleted(fingerprint?: string): McpOnboardingState {
+  return updateOnboardingState((state) => ({
+    ...state,
+    setupCompleted: true,
+    lastDiscoveryFingerprint: fingerprint ?? state.lastDiscoveryFingerprint,
+  }));
+}

package/mcp/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "pi-mcp-adapter",
+  "version": "2.10.0",
+  "description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
+  "type": "module",
+  "license": "MIT",
+  "author": "Nico Bailon",
+  "bin": {
+    "pi-mcp-adapter": "cli.js"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:oauth-provider": "node --import tsx --test mcp-oauth-provider.test.ts"
+  },
+  "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"
+    ],
+    "video": "https://github.com/nicobailon/pi-mcp-adapter/raw/refs/heads/main/pi-mcp.mp4"
+  },
+  "files": [
+    "cli.js",
+    "agent-dir.ts",
+    "index.ts",
+    "state.ts",
+    "utils.ts",
+    "tool-metadata.ts",
+    "init.ts",
+    "ui-session.ts",
+    "proxy-modes.ts",
+    "direct-tools.ts",
+    "commands.ts",
+    "onboarding-state.ts",
+    "mcp-setup-panel.ts",
+    "types.ts",
+    "ui-stream-types.ts",
+    "config.ts",
+    "server-manager.ts",
+    "sampling-handler.ts",
+    "elicitation-handler.ts",
+    "tool-registrar.ts",
+    "tool-result-renderer.ts",
+    "resource-tools.ts",
+    "lifecycle.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",
+    "mcp-auth.ts",
+    "mcp-oauth-provider.ts",
+    "mcp-callback-server.ts",
+    "mcp-auth-flow.ts",
+    "mcp-panel.ts",
+    "panel-keys.ts",
+    "logger.ts",
+    "errors.ts",
+    "app-bridge.bundle.js",
+    "banner.png",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@earendil-works/pi-ai": "^0.74.0",
+    "@earendil-works/pi-tui": "^0.74.0",
+    "@modelcontextprotocol/ext-apps": "^1.2.2",
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "open": "^10.2.0",
+    "recheck": "^4.5.0",
+    "typebox": "^1.1.24",
+    "zod": "^3.25.0 || ^4.0.0"
+  },
+  "peerDependencies": {
+    "zod": "^3.25.0 || ^4.0.0"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.79.1",
+    "@types/bun": "^1.0.0",
+    "@types/node": "^20.0.0",
+    "@types/open": "^6.2.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  }
+}

package/mcp/panel-keys.ts

@@ -0,0 +1,37 @@
+import { matchesKey } from "@earendil-works/pi-tui";
+
+/** The `tui.select.*` keybinding ids the adapter panels resolve. */
+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;
+}
+
+/**
+ * Key matchers for list navigation: user's `tui.select.*` 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;
+}
+
+export function createPanelKeys(keybindings?: PanelKeybindings): PanelKeys {
+  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"),
+    };
+  }
+  return {
+    selectUp: (data) => matchesKey(data, "up"),
+    selectDown: (data) => matchesKey(data, "down"),
+    selectConfirm: (data) => matchesKey(data, "return"),
+  };
+}