@fitchmultz/pi-mcp-adapter 5.0.0

package/dist/ui-tool-visibility.js

@@ -0,0 +1,26 @@
+export function extractUiToolVisibility(meta) {
+    if (!meta || typeof meta !== "object")
+        return undefined;
+    const ui = meta.ui;
+    if (!ui || typeof ui !== "object" || Array.isArray(ui))
+        return undefined;
+    const visibility = ui.visibility;
+    if (visibility === undefined)
+        return undefined;
+    if (!Array.isArray(visibility))
+        return [];
+    const values = [];
+    for (const entry of visibility) {
+        if (entry !== "model" && entry !== "app")
+            return [];
+        if (!values.includes(entry))
+            values.push(entry);
+    }
+    return values;
+}
+export function isUiToolVisibleToModel(visibility) {
+    return visibility === undefined || visibility.includes("model");
+}
+export function isUiToolCallableByApp(visibility) {
+    return visibility === undefined || visibility.includes("app");
+}

package/dist/unix-socket-transport.d.ts

@@ -0,0 +1,15 @@
+import type { Transport } from "@modelcontextprotocol/client";
+import type { JSONRPCMessage } from "@modelcontextprotocol/client";
+/** MCP JSONL transport for an explicitly configured Unix-domain socket. */
+export declare class UnixSocketClientTransport implements Transport {
+    private readonly socketPath;
+    private socket;
+    private readonly readBuffer;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(socketPath: string);
+    start(): Promise<void>;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+}

package/dist/unix-socket-transport.js

@@ -0,0 +1,84 @@
+import { createConnection } from "node:net";
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/client";
+/** MCP JSONL transport for an explicitly configured Unix-domain socket. */
+export class UnixSocketClientTransport {
+    socketPath;
+    socket;
+    readBuffer = new ReadBuffer();
+    onclose;
+    onerror;
+    onmessage;
+    constructor(socketPath) {
+        this.socketPath = socketPath;
+    }
+    async start() {
+        if (this.socket) {
+            throw new Error("UnixSocketClientTransport already started");
+        }
+        await new Promise((resolve, reject) => {
+            const socket = createConnection(this.socketPath);
+            this.socket = socket;
+            let connected = false;
+            socket.once("connect", () => {
+                connected = true;
+                resolve();
+            });
+            socket.on("data", chunk => {
+                try {
+                    this.readBuffer.append(chunk);
+                    while (true) {
+                        const message = this.readBuffer.readMessage();
+                        if (message === null)
+                            break;
+                        this.onmessage?.(message);
+                    }
+                }
+                catch (error) {
+                    const cause = error instanceof Error ? error : new Error(String(error));
+                    this.onerror?.(cause);
+                    void this.close();
+                }
+            });
+            socket.on("error", error => {
+                if (!connected)
+                    reject(error);
+                this.onerror?.(error);
+            });
+            socket.on("close", () => {
+                if (this.socket === socket)
+                    this.socket = undefined;
+                this.readBuffer.clear();
+                this.onclose?.();
+            });
+        });
+    }
+    async close() {
+        const socket = this.socket;
+        this.socket = undefined;
+        this.readBuffer.clear();
+        if (!socket || socket.destroyed)
+            return;
+        await new Promise(resolve => {
+            const timeout = setTimeout(() => socket.destroy(), 2_000);
+            timeout.unref();
+            socket.once("close", () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            socket.end();
+        });
+    }
+    async send(message) {
+        const socket = this.socket;
+        if (!socket || socket.destroyed)
+            throw new Error("Unix socket is not connected");
+        await new Promise((resolve, reject) => {
+            socket.write(serializeMessage(message), error => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+        });
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,30 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { McpConfig, ServerEntry } from "./types.ts";
+export declare function normalizeRequestTimeoutMs(timeoutMs: number | undefined): number | undefined;
+export declare function openUrl(pi: ExtensionAPI, url: string, browser?: string, signal?: AbortSignal): Promise<void>;
+export declare function openPath(pi: ExtensionAPI, targetPath: string): Promise<void>;
+export declare function parallelLimit<T, R>(items: T[], limit: number, fn: (item: T) => Promise<R>): Promise<R[]>;
+export declare function interpolateEnvVars(value: string): string;
+export declare function toStringRecord(value: unknown): Record<string, string> | undefined;
+export declare function interpolateEnvRecord(values: Record<string, string> | undefined): Record<string, string> | undefined;
+/** Resolve a secret value, executing only a single leading `!` command marker. */
+export declare function resolveCommandSecret(value: string, context: string): string;
+export declare function resolveCommandSecret(value: undefined, context: string): undefined;
+export declare function resolveCommandSecret(value: string | undefined, context: string): string | undefined;
+/** Resolve command markers in a configured record without mutating the input. */
+export declare function resolveCommandSecretsRecord(values: Record<string, string> | undefined, context: (key: string) => string): Record<string, string> | undefined;
+export declare function resolveServerUrl(definition: Pick<ServerEntry, "url">): string | undefined;
+export declare function resolveConfigPath(value: string | undefined): string | undefined;
+export declare function resolveBearerToken(definition: Pick<ServerEntry, "bearerToken" | "bearerTokenEnv">): string | undefined;
+/** Remove OSC control strings, including payloads that have no terminator. */
+export declare function stripOscSequences(text: string): string;
+export declare function sanitizeTerminalText(text: string): string;
+export declare function formatTerminalError(error: unknown): string;
+export declare function truncateAtWord(text: string, target: number): string;
+export declare function normalizeDirectToolInputSchema(schema: unknown): Record<string, unknown>;
+export declare function formatAuthRequiredMessage(config: Pick<McpConfig, "settings">, serverName: string, defaultMessage: string): string;
+export declare function formatMcpStatus(config: Pick<McpConfig, "settings">, message: string): string | undefined;
+/**
+ * Extract the adapter-owned UI stream mode from tool metadata.
+ */
+export declare function extractToolUiStreamMode(toolMeta: Record<string, unknown> | undefined): "eager" | "stream-first" | undefined;

package/dist/utils.js

@@ -0,0 +1,276 @@
+import { spawnSync } from "node:child_process";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+export function normalizeRequestTimeoutMs(timeoutMs) {
+    return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0
+        ? timeoutMs
+        : undefined;
+}
+async function execOpen(pi, target, browser, signal) {
+    const os = platform();
+    if (os === "darwin") {
+        return browser
+            ? pi.exec("open", ["-a", browser, target], signal ? { signal } : {})
+            : pi.exec("open", [target], signal ? { signal } : {});
+    }
+    if (os === "win32") {
+        return browser
+            ? pi.exec("cmd", ["/c", "start", "", browser, target], signal ? { signal } : {})
+            : pi.exec("cmd", ["/c", "start", "", target], signal ? { signal } : {});
+    }
+    return browser
+        ? pi.exec(browser, [target], signal ? { signal } : {})
+        : pi.exec("xdg-open", [target], signal ? { signal } : {});
+}
+export async function openUrl(pi, url, browser, signal) {
+    const result = await execOpen(pi, url, browser, signal);
+    if (result.code !== 0) {
+        throw new Error(result.stderr || `Failed to open browser (exit code ${result.code})`);
+    }
+}
+export async function openPath(pi, targetPath) {
+    const result = await execOpen(pi, targetPath);
+    if (result.code !== 0) {
+        throw new Error(result.stderr || `Failed to open path (exit code ${result.code})`);
+    }
+}
+export async function parallelLimit(items, limit, fn) {
+    const results = [];
+    const iterator = items.entries();
+    async function worker() {
+        while (true) {
+            const next = iterator.next();
+            if (next.done)
+                return;
+            const [index, item] = next.value;
+            results[index] = await fn(item);
+        }
+    }
+    const workers = Array(Math.min(limit, items.length)).fill(null).map(() => worker());
+    await Promise.all(workers);
+    return results;
+}
+export function interpolateEnvVars(value) {
+    return value
+        .replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? "")
+        .replace(/\$env:(\w+)/g, (_, name) => process.env[name] ?? "")
+        .replace(/\{env:(\w+)\}/g, (_, name) => process.env[name] ?? "");
+}
+function getMissingEnvVars(value) {
+    const missing = new Set();
+    for (const match of value.matchAll(/\$\{(\w+)\}|\$env:(\w+)|\{env:(\w+)\}/g)) {
+        const name = match[1] ?? match[2] ?? match[3];
+        if (name && process.env[name] === undefined) {
+            missing.add(name);
+        }
+    }
+    return [...missing];
+}
+export function toStringRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry === "string")
+            result[key] = entry;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function interpolateSecretExpression(value) {
+    if (value.startsWith("!!"))
+        return interpolateEnvVars(value.slice(1));
+    return value.startsWith("!") ? value : interpolateEnvVars(value);
+}
+export function interpolateEnvRecord(values) {
+    if (!values)
+        return undefined;
+    return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+        key,
+        interpolateSecretExpression(value),
+    ]));
+}
+const COMMAND_SECRET_TIMEOUT_MS = 10_000;
+const COMMAND_SECRET_MAX_OUTPUT_BYTES = 1024 * 1024;
+export function resolveCommandSecret(value, context) {
+    if (value === undefined)
+        return undefined;
+    if (value.startsWith("!!"))
+        return interpolateEnvVars(value.slice(1));
+    if (!value.startsWith("!"))
+        return interpolateEnvVars(value);
+    let result;
+    try {
+        result = spawnSync(value.slice(1), {
+            shell: true,
+            encoding: "utf8",
+            timeout: COMMAND_SECRET_TIMEOUT_MS,
+            maxBuffer: COMMAND_SECRET_MAX_OUTPUT_BYTES,
+            stdio: ["ignore", "pipe", "ignore"],
+            windowsHide: true,
+        });
+    }
+    catch {
+        throw new Error(`Failed to resolve ${context}: command failed to start`);
+    }
+    if (result.error) {
+        const code = result.error.code;
+        const reason = code === "ETIMEDOUT"
+            ? "command timed out after 10 seconds"
+            : code === "ENOBUFS"
+                ? "command output exceeded 1 MiB"
+                : "command failed to start";
+        throw new Error(`Failed to resolve ${context}: ${reason}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`Failed to resolve ${context}: command exited with code ${result.status ?? "unknown"}`);
+    }
+    const resolved = result.stdout.trim();
+    if (!resolved)
+        throw new Error(`Failed to resolve ${context}: command returned empty output`);
+    return resolved;
+}
+/** Resolve command markers in a configured record without mutating the input. */
+export function resolveCommandSecretsRecord(values, context) {
+    if (!values)
+        return undefined;
+    return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+        key,
+        resolveCommandSecret(value, context(key)),
+    ]));
+}
+export function resolveServerUrl(definition) {
+    if (definition.url == null)
+        return undefined;
+    if (typeof definition.url !== "string") {
+        throw new Error("MCP server URL must be a string");
+    }
+    const missing = getMissingEnvVars(definition.url);
+    if (missing.length > 0) {
+        throw new Error(`Missing environment variable${missing.length === 1 ? "" : "s"} in MCP server URL: ${missing.join(", ")}`);
+    }
+    const resolved = interpolateEnvVars(definition.url);
+    try {
+        new URL(resolved);
+    }
+    catch (error) {
+        throw new Error(`Invalid MCP server URL after environment interpolation: ${resolved}`, { cause: error });
+    }
+    return resolved;
+}
+export function resolveConfigPath(value) {
+    if (value === undefined)
+        return undefined;
+    const resolved = interpolateEnvVars(value);
+    if (resolved === "~")
+        return homedir();
+    if (resolved.startsWith("~/") || resolved.startsWith("~\\")) {
+        return join(homedir(), resolved.slice(2));
+    }
+    return resolved;
+}
+export function resolveBearerToken(definition) {
+    if (definition.bearerToken !== undefined) {
+        return interpolateSecretExpression(definition.bearerToken);
+    }
+    return definition.bearerTokenEnv ? process.env[definition.bearerTokenEnv] : undefined;
+}
+/** Remove OSC control strings, including payloads that have no terminator. */
+export function stripOscSequences(text) {
+    let result = "";
+    let index = 0;
+    while (index < text.length) {
+        const isEscOsc = text.charCodeAt(index) === 0x1b && text[index + 1] === "]";
+        const isC1Osc = text.charCodeAt(index) === 0x9d;
+        if (!isEscOsc && !isC1Osc) {
+            result += text[index++];
+            continue;
+        }
+        index += isEscOsc ? 2 : 1;
+        while (index < text.length) {
+            const code = text.charCodeAt(index++);
+            if (code === 0x07 || code === 0x9c)
+                break;
+            if (code === 0x1b && text[index] === "\\") {
+                index++;
+                break;
+            }
+        }
+    }
+    return result;
+}
+export function sanitizeTerminalText(text) {
+    return stripOscSequences(text)
+        .replace(/(?:\x1b\[[0-?]*[ -/]*[@-~]|\x1b[@-Z\\-_])/g, "")
+        .replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function formatTerminalError(error) {
+    const messages = [];
+    const seen = new Set();
+    const collect = (value) => {
+        if (seen.has(value))
+            return;
+        if ((typeof value === "object" && value !== null) || typeof value === "function")
+            seen.add(value);
+        if (value instanceof AggregateError) {
+            const countBefore = messages.length;
+            for (const nested of value.errors)
+                collect(nested);
+            if (value.cause !== undefined)
+                collect(value.cause);
+            if (messages.length === countBefore && value.message)
+                messages.push(value.message);
+            return;
+        }
+        if (value instanceof Error) {
+            if (value.message)
+                messages.push(value.message);
+            if (value.cause !== undefined)
+                collect(value.cause);
+            return;
+        }
+        messages.push(String(value));
+    };
+    collect(error);
+    return sanitizeTerminalText([...new Set(messages)].join(": "));
+}
+export function truncateAtWord(text, target) {
+    if (!text || text.length <= target)
+        return text;
+    const truncated = text.slice(0, target);
+    const lastSpace = truncated.lastIndexOf(" ");
+    if (lastSpace > target * 0.6) {
+        return truncated.slice(0, lastSpace) + "...";
+    }
+    return truncated + "...";
+}
+export function normalizeDirectToolInputSchema(schema) {
+    const inputSchema = schema && typeof schema === "object" && !Array.isArray(schema)
+        ? schema
+        : { type: "object", properties: {} };
+    const { $schema, additionalProperties, ...normalized } = inputSchema;
+    return normalized;
+}
+export function formatAuthRequiredMessage(config, serverName, defaultMessage) {
+    const template = config.settings?.authRequiredMessage;
+    return template ? template.replaceAll("${server}", serverName) : defaultMessage;
+}
+export function formatMcpStatus(config, message) {
+    if (config.settings?.mcpFooterStatus === "off")
+        return undefined;
+    return `${config.settings?.showStatusIcon === false ? "MCP: " : "🔌 MCP: "}${message}`;
+}
+/**
+ * Extract the adapter-owned UI stream mode from tool metadata.
+ */
+export function extractToolUiStreamMode(toolMeta) {
+    const uiMeta = toolMeta?.ui;
+    if (!uiMeta || typeof uiMeta !== "object")
+        return undefined;
+    const streamMode = uiMeta["pi-mcp-adapter.streamMode"];
+    if (streamMode === "eager" || streamMode === "stream-first") {
+        return streamMode;
+    }
+    return undefined;
+}

package/docs/client-metadata.json

@@ -0,0 +1,14 @@
+{
+  "client_id": "https://fitchmultz.github.io/pi-mcp-adapter/client-metadata.json",
+  "client_name": "Fitch MCP Adapter",
+  "client_uri": "https://github.com/fitchmultz/pi-mcp-adapter",
+  "redirect_uris": [
+    "http://localhost:19876/callback",
+    "http://127.0.0.1:19876/callback",
+    "http://[::1]:19876/callback"
+  ],
+  "application_type": "native",
+  "grant_types": ["authorization_code", "refresh_token"],
+  "response_types": ["code"],
+  "token_endpoint_auth_method": "none"
+}