@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/pi-mcp-adapter-DPTJGAAL.js

@@ -0,0 +1,428 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  abortable,
+  buildProxyDescription,
+  getConfigPathFromArgv,
+  getMetadataCachePath,
+  getMissingConfiguredDirectToolServers,
+  loadMcpConfig,
+  loadMetadataCache,
+  normalizeDirectToolInputSchema,
+  resolveDirectTools,
+  throwIfAborted,
+  truncateAtWord
+} from "./chunk-EHMBW7FA.js";
+import "./chunk-ARC4KOTI.js";
+import "./chunk-4HXHDDCF.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/index.js
+import { existsSync } from "node:fs";
+import { Type } from "typebox";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/tool-result-renderer.js
+import { Text } from "@ashx-j/lunr-tui";
+var DEFAULT_MAX_CALL_INPUT_CHARS = 1500;
+function truncateText(value, maxChars) {
+  return value.length <= maxChars ? value : `${value.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+}
+function formatJsonish(value, maxChars) {
+  if (typeof value == "string")
+    try {
+      return truncateText(JSON.stringify(JSON.parse(value), null, 2), maxChars);
+    } catch {
+      return truncateText(value, maxChars);
+    }
+  try {
+    return truncateText(JSON.stringify(value, null, 2), maxChars);
+  } catch {
+    return truncateText(String(value), maxChars);
+  }
+}
+function hasUsefulObjectContent(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+function formatMcpProxyToolCallLines(args, maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS) {
+  if (args.action === "ui-messages")
+    return [`mcp ${args.action}`];
+  if (args.tool) {
+    let lines = [`mcp call ${args.server ? `${args.tool} @ ${args.server}` : args.tool}`];
+    return args.args && lines.push(formatJsonish(args.args, maxInputChars)), lines;
+  }
+  if (args.connect)
+    return [`mcp connect ${args.connect}`];
+  if (args.describe)
+    return [`mcp describe ${args.describe}`];
+  if (args.search) {
+    let line = `mcp search ${args.search}`;
+    return args.server && (line += ` @ ${args.server}`), args.regex === !0 && (line += " (regex)"), args.includeSchemas === !1 && (line += " (schemas hidden)"), [line];
+  }
+  return args.server ? [`mcp list ${args.server}`] : args.action ? [`mcp ${args.action}`] : ["mcp status"];
+}
+function formatMcpDirectToolCallLines(displayName, args, maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS) {
+  return hasUsefulObjectContent(args) ? [displayName, formatJsonish(args, maxInputChars)] : [displayName];
+}
+function renderToolCallLines(lines, theme) {
+  let [title = "mcp", ...rest] = lines, styledTitle = theme.fg("toolTitle", theme.bold ? theme.bold(title) : title), styledRest = rest.map((line) => theme.fg("muted", line));
+  return new Text([styledTitle, ...styledRest].join(`
+`), 0, 0);
+}
+function renderMcpProxyToolCall(args, theme) {
+  return renderToolCallLines(formatMcpProxyToolCallLines(args), theme);
+}
+function createMcpDirectToolCallRenderer(displayName) {
+  return (args, theme) => renderToolCallLines(formatMcpDirectToolCallLines(displayName, args), theme);
+}
+function blockToLines(block) {
+  return block.type === "text" ? block.text.split(`
+`) : [`[image: ${block.mimeType}]`];
+}
+function formatMcpToolResultLines(result, expanded, maxCollapsedLines = 3) {
+  let allLines = result.content.flatMap(blockToLines), lines = allLines.length > 0 ? allLines : ["(empty result)"];
+  return expanded || lines.length <= maxCollapsedLines ? { lines, truncated: !1 } : {
+    lines: [...lines.slice(0, maxCollapsedLines), "\u2026"],
+    truncated: !0
+  };
+}
+function renderMcpToolResult(result, options, theme, context) {
+  if (options.isPartial)
+    return new Text(theme.fg("warning", "Running MCP tool..."), 0, 0);
+  let hasErrorDetails = !!result.details.error, display = formatMcpToolResultLines(result, options.expanded || context?.isError === !0 || hasErrorDetails), output = display.lines.map((line) => line === "\u2026" ? theme.fg("muted", line) : theme.fg("toolOutput", line)).join(`
+`), hint = display.truncated && !options.expanded ? `
+${theme.fg("muted", "(Ctrl+O to expand)")}` : "";
+  return new Text(`${output}${hint}`, 0, 0);
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/error-signal.js
+function toolErrorOverride(details) {
+  if (details && typeof details == "object" && "error" in details) {
+    let code = details.error;
+    if (code === "tool_error" || code === "call_failed")
+      return { isError: !0 };
+  }
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/index.js
+function shouldBackgroundAutostart(config, cache) {
+  let serverEntries = Object.entries(config.mcpServers);
+  if (serverEntries.length === 0)
+    return !1;
+  if (!existsSync(getMetadataCachePath()))
+    return !0;
+  for (let [, definition] of serverEntries) {
+    let mode = definition.lifecycle ?? "lazy";
+    if (mode === "keep-alive" || mode === "eager")
+      return !0;
+  }
+  return process.env.MCP_DIRECT_TOOLS === "__none__" ? !1 : getMissingConfiguredDirectToolServers(config, cache).length > 0;
+}
+function mcpAdapter(pi) {
+  let state = null, initPromise = null, lifecycleGeneration = 0, sessionAbort = new AbortController(), initializingStates = /* @__PURE__ */ new Set(), shutdownPromises = /* @__PURE__ */ new WeakMap(), heavyModules = null, heavyModulesPromise = null, directExecutors = /* @__PURE__ */ new Map();
+  function loadHeavyModules() {
+    return heavyModules ? Promise.resolve(heavyModules) : (heavyModulesPromise || (heavyModulesPromise = (async () => {
+      let [init, authFlow, commands, proxyModes, directToolExecutor] = await Promise.all([
+        import("./init-EKE277AG.js"),
+        import("./mcp-auth-flow-YL6RWPYG.js"),
+        import("./commands-LGR5VT5X.js"),
+        import("./proxy-modes-R64LU6WZ.js"),
+        import("./direct-tool-executor-TDJS7TBD.js")
+      ]), loaded = { init, authFlow, commands, proxyModes, directToolExecutor };
+      return heavyModules = loaded, loaded;
+    })().catch((error) => {
+      throw heavyModulesPromise = null, error;
+    })), heavyModulesPromise);
+  }
+  function shutdownState(currentState, reason) {
+    if (!currentState)
+      return Promise.resolve();
+    let existing = shutdownPromises.get(currentState);
+    if (existing)
+      return existing;
+    let shutdown = (async () => {
+      currentState.uiServer && (currentState.uiServer.close(reason), currentState.uiServer = null);
+      let flushError;
+      try {
+        heavyModules && heavyModules.init.flushMetadataCache(currentState);
+      } catch (error) {
+        flushError = error;
+      }
+      try {
+        await currentState.lifecycle.gracefulShutdown();
+      } catch (error) {
+        if (flushError)
+          console.error("MCP: graceful shutdown failed after metadata flush error", error);
+        else
+          throw error;
+      }
+      if (flushError)
+        throw flushError;
+    })();
+    return shutdownPromises.set(currentState, shutdown), shutdown;
+  }
+  async function shutdownInitializingStates() {
+    let pending = [...initializingStates];
+    initializingStates.clear(), await Promise.all(pending.map((entry) => shutdownState(entry, "initialization_cancelled")));
+  }
+  async function shutdownLoadedRuntime() {
+    heavyModules && await heavyModules.authFlow.shutdownOAuth();
+  }
+  async function runInitialize(generation, sessionPi, ctx) {
+    let signal = sessionAbort.signal, heavy = await loadHeavyModules();
+    if (throwIfAborted(signal), generation !== lifecycleGeneration)
+      throw new Error("MCP initialization aborted (session changed)");
+    if (await heavy.authFlow.initializeOAuth().catch((err) => {
+      console.error("MCP OAuth initialization failed:", err);
+    }), generation !== lifecycleGeneration)
+      throw new Error("MCP initialization aborted (session changed)");
+    let partial;
+    try {
+      let initialized = await heavy.init.initializeMcp(sessionPi, ctx, {
+        signal,
+        onState: (entry) => {
+          partial = entry, initializingStates.add(entry);
+        }
+      });
+      return partial || (partial = initialized, initializingStates.add(initialized)), throwIfAborted(signal), initialized;
+    } catch (error) {
+      throw partial && (initializingStates.delete(partial), await shutdownState(partial, "initialization_failed")), error;
+    } finally {
+      partial && initializingStates.delete(partial);
+    }
+  }
+  function startSessionInit(generation, sessionPi, ctx) {
+    let promise = runInitialize(generation, sessionPi, ctx);
+    return initPromise = promise, promise.then(async (nextState) => {
+      if (generation !== lifecycleGeneration || initPromise !== promise) {
+        try {
+          await shutdownState(nextState, "stale_session_start");
+        } catch (error) {
+          console.error("MCP: failed to clean stale session state", error);
+        }
+        return;
+      }
+      state = nextState, heavyModules && heavyModules.init.updateStatusBar(nextState), initPromise = null;
+    }).catch((err) => {
+      generation === lifecycleGeneration && (initPromise !== promise && initPromise !== null || (console.error("MCP initialization failed:", err), initPromise = null));
+    }), promise;
+  }
+  async function ensureState(sessionPi, ctx, signal) {
+    if (throwIfAborted(signal), state)
+      return state;
+    let generation = lifecycleGeneration;
+    initPromise || startSessionInit(generation, sessionPi, ctx);
+    let promise = initPromise;
+    if (!promise)
+      throw new Error("MCP not initialized");
+    try {
+      let nextState = await abortable(promise, signal);
+      if (generation !== lifecycleGeneration)
+        throw new Error("MCP initialization aborted (session changed)");
+      return state || (state = nextState, initPromise === promise && (initPromise = null), state);
+    } catch (error) {
+      throw initPromise === promise && !signal?.aborted && (initPromise = null), error;
+    }
+  }
+  function assertCurrentState(currentState) {
+    if (currentState !== state)
+      throw new Error("MCP session changed before execution");
+  }
+  function createLazyDirectToolExecute(spec) {
+    return async function(toolCallId, params, incomingSignal, onUpdate, ctx) {
+      let signal = incomingSignal ? AbortSignal.any([incomingSignal, sessionAbort.signal]) : sessionAbort.signal, currentState;
+      try {
+        currentState = await ensureState(pi, ctx, signal);
+      } catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `MCP initialization failed: ${message}` }],
+          details: { error: "init_failed", message }
+        };
+      }
+      let heavy = await loadHeavyModules();
+      throwIfAborted(signal), assertCurrentState(currentState);
+      let executor = directExecutors.get(spec.prefixedName);
+      return executor || (executor = heavy.directToolExecutor.createDirectToolExecutor(() => currentState, () => null, spec), directExecutors.set(spec.prefixedName, executor)), executor(toolCallId, params, signal, onUpdate, ctx);
+    };
+  }
+  let earlyConfigPath = getConfigPathFromArgv(), earlyConfig = loadMcpConfig(earlyConfigPath), earlyCache = loadMetadataCache(), prefix = earlyConfig.settings?.toolPrefix ?? "server", envRaw = process.env.MCP_DIRECT_TOOLS, directSpecs = envRaw === "__none__" ? [] : resolveDirectTools(earlyConfig, earlyCache, prefix, envRaw?.split(",").map((s) => s.trim()).filter(Boolean)), missingConfiguredDirectToolServers = getMissingConfiguredDirectToolServers(earlyConfig, earlyCache), shouldRegisterProxyTool = earlyConfig.settings?.disableProxyTool !== !0 || directSpecs.length === 0 || missingConfiguredDirectToolServers.length > 0;
+  for (let spec of directSpecs)
+    pi.registerTool({
+      name: spec.prefixedName,
+      label: `MCP: ${spec.originalName}`,
+      description: spec.description || "(no description)",
+      promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
+      parameters: Type.Unsafe(normalizeDirectToolInputSchema(spec.inputSchema)),
+      execute: createLazyDirectToolExecute(spec),
+      renderCall: createMcpDirectToolCallRenderer(spec.prefixedName),
+      renderResult: renderMcpToolResult
+    });
+  let getPiTools = () => pi.getAllTools();
+  pi.registerFlag("mcp-config", {
+    description: "Path to MCP config file",
+    type: "string"
+  }), pi.on("session_start", async (_event, ctx) => {
+    let generation = ++lifecycleGeneration;
+    sessionAbort.abort(new Error("MCP session changed")), sessionAbort = new AbortController();
+    let previousState = state;
+    state = null, initPromise = null, directExecutors.clear();
+    try {
+      await Promise.all([
+        shutdownState(previousState, "session_restart"),
+        shutdownInitializingStates(),
+        shutdownLoadedRuntime()
+      ]);
+    } catch (error) {
+      console.error("MCP: failed to shut down previous session state", error);
+    }
+    if (generation !== lifecycleGeneration)
+      return;
+    let configPath = pi.getFlag("mcp-config") ?? earlyConfigPath, sessionConfig = loadMcpConfig(configPath, ctx.cwd), sessionCache = loadMetadataCache();
+    shouldBackgroundAutostart(sessionConfig, sessionCache) && startSessionInit(generation, pi, ctx);
+  }), pi.on("session_shutdown", async () => {
+    ++lifecycleGeneration, sessionAbort.abort(new Error("MCP session ended"));
+    let currentState = state;
+    state = null, initPromise = null, directExecutors.clear();
+    try {
+      await Promise.all([
+        shutdownState(currentState, "session_shutdown"),
+        shutdownInitializingStates(),
+        shutdownLoadedRuntime()
+      ]);
+    } catch (error) {
+      console.error("MCP: session shutdown cleanup failed", error);
+    }
+  }), pi.on("tool_result", (event) => toolErrorOverride(event.details)), pi.registerCommand("mcp", {
+    description: "Show MCP server status",
+    handler: async (args, ctx) => {
+      let currentState;
+      try {
+        currentState = await ensureState(pi, ctx);
+      } catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        ctx.hasUI && ctx.ui.notify(`MCP initialization failed: ${message}`, "error");
+        return;
+      }
+      let heavy = await loadHeavyModules();
+      assertCurrentState(currentState);
+      let parts = args?.trim()?.split(/\s+/) ?? [], subcommand = parts[0] ?? "", targetServer = parts[1], rest = parts.slice(1).join(" ");
+      switch (subcommand) {
+        case "reconnect":
+          await heavy.commands.reconnectServers(currentState, ctx, targetServer);
+          break;
+        case "tools":
+          await heavy.commands.showTools(currentState, ctx);
+          break;
+        case "setup": {
+          if ((await heavy.commands.openMcpSetup(currentState, pi, ctx, earlyConfigPath, "setup"))?.configChanged) {
+            await ctx.reload();
+            return;
+          }
+          break;
+        }
+        case "logout": {
+          let serverName = rest;
+          if (!serverName) {
+            ctx.hasUI && ctx.ui.notify("Usage: /mcp logout <server>", "error");
+            return;
+          }
+          await heavy.commands.logoutServer(serverName, currentState, ctx);
+          break;
+        }
+        default:
+          if (ctx.hasUI) {
+            if ((await heavy.commands.openMcpPanel(currentState, pi, ctx, earlyConfigPath))?.configChanged) {
+              await ctx.reload();
+              return;
+            }
+          } else
+            await heavy.commands.showStatus(currentState, ctx);
+          break;
+      }
+    }
+  }), pi.registerCommand("mcp-auth", {
+    description: "Authenticate with an MCP server (OAuth)",
+    handler: async (args, ctx) => {
+      let serverName = args?.trim();
+      if (!serverName && !ctx.hasUI)
+        return;
+      let currentState;
+      try {
+        currentState = await ensureState(pi, ctx);
+      } catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        ctx.hasUI && ctx.ui.notify(`MCP initialization failed: ${message}`, "error");
+        return;
+      }
+      let heavy = await loadHeavyModules();
+      if (assertCurrentState(currentState), !serverName) {
+        await heavy.commands.openMcpAuthPanel(currentState, pi, ctx, earlyConfigPath);
+        return;
+      }
+      await heavy.commands.authenticateServer(serverName, currentState.config, ctx);
+    }
+  }), shouldRegisterProxyTool && pi.registerTool({
+    name: "mcp",
+    label: "MCP",
+    description: buildProxyDescription(earlyConfig, earlyCache, directSpecs),
+    promptSnippet: "MCP gateway - connect to MCP servers and call their tools",
+    renderCall: renderMcpProxyToolCall,
+    parameters: Type.Object({
+      tool: Type.Optional(Type.String({ description: "Tool name to call (e.g., 'xcodebuild_list_sims')" })),
+      args: Type.Optional(Type.String({ description: `Arguments as JSON string (e.g., '{"key": "value"}')` })),
+      connect: Type.Optional(Type.String({ description: "Server name to connect (lazy connect + metadata refresh)" })),
+      describe: Type.Optional(Type.String({ description: "Tool name to describe (shows parameters)" })),
+      search: Type.Optional(Type.String({ description: "Search tools by name/description" })),
+      regex: Type.Optional(Type.Boolean({ description: "Treat search as regex (default: substring match)" })),
+      includeSchemas: Type.Optional(Type.Boolean({ description: "Include parameter schemas in search results (default: true)" })),
+      server: Type.Optional(Type.String({ description: "Filter to specific server (also disambiguates tool calls)" })),
+      action: Type.Optional(Type.String({ description: "Action: 'ui-messages', 'auth-start', or 'auth-complete'" }))
+    }),
+    renderResult: renderMcpToolResult,
+    async execute(_toolCallId, params, incomingSignal, _onUpdate, ctx) {
+      let signal = incomingSignal ? AbortSignal.any([incomingSignal, sessionAbort.signal]) : sessionAbort.signal, parsedArgs;
+      if (params.args)
+        try {
+          if (parsedArgs = JSON.parse(params.args), typeof parsedArgs != "object" || parsedArgs === null || Array.isArray(parsedArgs)) {
+            let gotType = Array.isArray(parsedArgs) ? "array" : parsedArgs === null ? "null" : typeof parsedArgs;
+            throw new Error(`Invalid args: expected a JSON object, got ${gotType}`);
+          }
+        } catch (error) {
+          throw error instanceof SyntaxError ? new Error(`Invalid args JSON: ${error.message}`, { cause: error }) : error;
+        }
+      let currentState;
+      try {
+        currentState = await ensureState(pi, ctx, signal);
+      } catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `MCP initialization failed: ${message}` }],
+          details: { error: "init_failed", message }
+        };
+      }
+      let heavy = await loadHeavyModules();
+      if (throwIfAborted(signal), assertCurrentState(currentState), params.action === "ui-messages")
+        return heavy.proxyModes.executeUiMessages(currentState);
+      if (params.action === "auth-start")
+        return params.server ? heavy.proxyModes.executeAuthStart(currentState, params.server) : {
+          content: [{ type: "text", text: 'auth-start requires `server`. Example: mcp({ action: "auth-start", server: "linear-server" })' }],
+          details: { mode: "auth-start", error: "missing_server" }
+        };
+      if (params.action === "auth-complete") {
+        if (!params.server)
+          return {
+            content: [{ type: "text", text: "auth-complete requires `server`." }],
+            details: { mode: "auth-complete", error: "missing_server" }
+          };
+        let input = parsedArgs?.redirectUrl ?? parsedArgs?.code ?? parsedArgs?.input;
+        return typeof input != "string" || input.trim().length === 0 ? {
+          content: [{ type: "text", text: "auth-complete requires args with `redirectUrl`, `code`, or `input`." }],
+          details: { mode: "auth-complete", error: "missing_input" }
+        } : heavy.proxyModes.executeAuthComplete(currentState, params.server, input);
+      }
+      return params.tool ? heavy.proxyModes.executeCall(currentState, params.tool, parsedArgs, params.server, getPiTools, signal) : params.connect ? heavy.proxyModes.executeConnect(currentState, params.connect, signal) : params.describe ? heavy.proxyModes.executeDescribe(currentState, params.describe) : params.search ? heavy.proxyModes.executeSearch(currentState, params.search, params.regex, params.server, params.includeSchemas) : params.server ? heavy.proxyModes.executeList(currentState, params.server) : heavy.proxyModes.executeStatus(currentState);
+    }
+  });
+}
+export {
+  mcpAdapter as default
+};