@fitchmultz/pi-mcp-adapter 5.0.0

package/dist/mcp-script-worker.mjs

@@ -0,0 +1,128 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { formatWithOptions } from "node:util";
+import vm from "node:vm";
+
+const TOOLS_ENUMERATION_ERROR = "tools is not enumerable — use tools.search({ query })";
+const RESERVED_TOOL_PROPS = new Set(["then", "catch", "finally", "toJSON", "toString", "valueOf"]);
+
+// Keep this formatting logic in sync with mcp-code.ts; the standalone worker cannot import the TypeScript host module.
+function needsInspectableFormatting(value, stack = new WeakSet()) {
+  if (value === undefined || typeof value === "bigint" || typeof value === "function" || typeof value === "symbol") return true;
+  if (typeof value !== "object" || value === null) return false;
+  if (stack.has(value)) return true;
+  if (value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet) return true;
+  stack.add(value);
+  try {
+    return Object.values(value).some((entry) => needsInspectableFormatting(entry, stack));
+  } finally {
+    stack.delete(value);
+  }
+}
+
+function formatValue(value) {
+  if (typeof value === "string") return value;
+  try {
+    if (!needsInspectableFormatting(value)) {
+      const json = JSON.stringify(value, null, 2);
+      if (json !== undefined) return json;
+    }
+    return formatWithOptions({ colors: false, depth: 6 }, value);
+  } catch {
+    return "[unserializable value]";
+  }
+}
+
+function toContentBlock(value) {
+  if (typeof value === "object" && value !== null) {
+    if (value.type === "text" && typeof value.text === "string") {
+      return { type: "text", text: value.text };
+    }
+    if (value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string") {
+      return { type: "image", data: value.data, mimeType: value.mimeType };
+    }
+  }
+  return { type: "text", text: formatValue(value) };
+}
+
+let nextRequestId = 0;
+const pending = new Map();
+
+parentPort.on("message", (message) => {
+  if (message?.type !== "result" || typeof message.id !== "number") return;
+  const resolve = pending.get(message.id);
+  if (!resolve) return;
+  pending.delete(message.id);
+  resolve(message.envelope);
+});
+
+function request(type, payload) {
+  return new Promise((resolve) => {
+    const id = ++nextRequestId;
+    pending.set(id, resolve);
+    parentPort.postMessage({ type, id, ...payload });
+  });
+}
+
+const tools = new Proxy(Object.create(null), {
+  get(_target, property) {
+    if (property === "search") {
+      return async (input) => request("search", { input });
+    }
+    if (property === "call") {
+      return async (path, args) => {
+        // Invalid paths never reach dispatch and therefore never appear in the call trace.
+        if (typeof path !== "string" || path.trim() === "") {
+          return {
+            ok: false,
+            error: {
+              code: "invalid_tool_path",
+              message: "tools.call(path, args) requires a non-empty tool path.",
+            },
+          };
+        }
+        return request("call", { path, args });
+      };
+    }
+    if (property === "describe") {
+      return async (input) => request("describe", { input });
+    }
+    if (typeof property !== "string" || RESERVED_TOOL_PROPS.has(property)) return undefined;
+    return (args) => request("call", { path: property, args });
+  },
+  ownKeys() {
+    throw new Error(TOOLS_ENUMERATION_ERROR);
+  },
+});
+
+const emit = (value) => {
+  parentPort.postMessage({ type: "emit", block: toContentBlock(value) });
+};
+
+const capturedConsole = Object.freeze({
+  log: (...args) => emit(`[console.log] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  info: (...args) => emit(`[console.info] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  warn: (...args) => emit(`[console.warn] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  error: (...args) => emit(`[console.error] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  debug: (...args) => emit(`[console.debug] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+});
+
+try {
+  const context = vm.createContext(Object.assign(Object.create(null), {
+    tools,
+    emit,
+    console: capturedConsole,
+  }), {
+    codeGeneration: { strings: false, wasm: false },
+    name: "mcp_script",
+  });
+  const script = new vm.Script(`(async () => {\n${workerData.code}\n})()`, { filename: "mcp_script.js" });
+  const returnValue = await Promise.resolve(script.runInContext(context));
+  parentPort.postMessage(returnValue === undefined
+    ? { type: "done" }
+    : { type: "done", returnBlock: toContentBlock(returnValue) });
+} catch (error) {
+  parentPort.postMessage({
+    type: "error",
+    message: error instanceof Error ? error.message : String(error),
+  });
+}

package/dist/mcp-setup-panel.d.ts

@@ -0,0 +1,84 @@
+import { type PanelKeybindings } from "./panel-keys.ts";
+import type { ImportKind } from "./types.ts";
+import { type ConfigWritePreview, type KnownServerPreset, type McpDiscoverySummary } from "./config.ts";
+import type { McpOnboardingState } from "./onboarding-state.ts";
+export interface SetupPanelCallbacks {
+    previewImports: (imports: ImportKind[]) => ConfigWritePreview;
+    previewStarterProject: () => ConfigWritePreview;
+    previewRepoPrompt: () => ConfigWritePreview | null;
+    previewKnownServer: (preset: KnownServerPreset) => ConfigWritePreview;
+    adoptImports: (imports: ImportKind[]) => Promise<{
+        added: ImportKind[];
+        path: string;
+    }>;
+    scaffoldProjectConfig: () => Promise<{
+        path: string;
+    }>;
+    addRepoPrompt: () => Promise<{
+        path: string;
+        serverName: string;
+    }>;
+    addKnownServer: (preset: KnownServerPreset) => Promise<{
+        path: string;
+        serverName: string;
+    }>;
+    openPath: (path: string) => Promise<void>;
+    markSetupCompleted: () => void;
+}
+export interface SetupPanelOptions {
+    mode: "empty" | "setup";
+    onboardingState: McpOnboardingState;
+    keybindings?: PanelKeybindings;
+}
+export declare class McpSetupPanel {
+    private discovery;
+    private callbacks;
+    private options;
+    private done;
+    private screen;
+    private actionCursor;
+    private importCursor;
+    private pathCursor;
+    private selectedImports;
+    private busy;
+    private notice;
+    private tui;
+    private t;
+    private keys;
+    private inactivityTimeout;
+    private static readonly INACTIVITY_MS;
+    constructor(discovery: McpDiscoverySummary, callbacks: SetupPanelCallbacks, options: SetupPanelOptions, tui: {
+        requestRender(): void;
+    }, done: () => void);
+    private resetInactivityTimeout;
+    private cleanup;
+    private getActions;
+    private getDetectedPaths;
+    private getSelectedAction;
+    handleInput(data: string): void;
+    private handleImportsInput;
+    private handlePathsInput;
+    private runAction;
+    private applySelectedImports;
+    private runBusy;
+    render(width: number): string[];
+    private renderActions;
+    private renderImports;
+    private renderPaths;
+    private discoverySummaryLine;
+    private secondarySummaryLine;
+    private visibleActionRange;
+    private contentWidth;
+    private previewWidth;
+    private getActionPreview;
+    private formatPreview;
+    private formatWritePreview;
+    private padLine;
+    invalidate(): void;
+    dispose(): void;
+}
+export declare function createMcpSetupPanel(discovery: McpDiscoverySummary, callbacks: SetupPanelCallbacks, options: SetupPanelOptions, tui: {
+    requestRender(): void;
+}, done: () => void): McpSetupPanel & {
+    dispose(): void;
+};