@aria-cli/tools 1.0.19 → 1.0.31

package/dist/local-control-http-auth.js

@@ -0,0 +1,3 @@
+export const LOCAL_HTTP_CLIENT_ID_HEADER = "x-aria-local-client-id";
+export const LOCAL_HTTP_CLIENT_PROOF_HEADER = "x-aria-local-client-proof";
+//# sourceMappingURL=local-control-http-auth.js.map

package/dist/mcp/client.js

@@ -0,0 +1,182 @@
+/**
+ * MCP Multi-Server Client
+ *
+ * Manages connections to multiple MCP servers and aggregates their capabilities.
+ */
+import { EventEmitter } from "events";
+import { MCPServerConnection } from "./connection.js";
+export class MCPClient extends EventEmitter {
+    servers = new Map();
+    serverConfigs = new Map();
+    reconnectTimers = new Map();
+    logger;
+    constructor(options) {
+        super();
+        this.logger = options?.logger ?? console;
+    }
+    /**
+     * Connect to an MCP server
+     */
+    async connect(config) {
+        if (this.servers.has(config.name)) {
+            throw new Error(`Server already connected: ${config.name}`);
+        }
+        const connection = new MCPServerConnection(config);
+        await connection.initialize();
+        // Forward events
+        connection.on("tools/list_changed", () => this.emit("toolsChanged", config.name));
+        connection.on("resources/list_changed", () => this.emit("resourcesChanged", config.name));
+        connection.on("prompts/list_changed", () => this.emit("promptsChanged", config.name));
+        connection.on("exit", (code) => {
+            this.servers.delete(config.name);
+            this.emit("serverExit", config.name, code);
+            // Attempt auto-reconnect on unexpected exit
+            if (code !== 0 && this.serverConfigs.has(config.name)) {
+                this.reconnect(config.name, config).catch((err) => {
+                    this.logger.warn("[MCPClient] Reconnect failed:", err?.message);
+                });
+            }
+        });
+        this.servers.set(config.name, connection);
+        this.serverConfigs.set(config.name, config);
+        return connection;
+    }
+    /**
+     * Disconnect from a specific server
+     */
+    async disconnect(name) {
+        this.serverConfigs.delete(name);
+        // Cancel any pending reconnect timer for this server
+        const timer = this.reconnectTimers.get(name);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            this.reconnectTimers.delete(name);
+        }
+        const conn = this.servers.get(name);
+        if (conn) {
+            this.servers.delete(name);
+            conn.removeAllListeners();
+            await conn.shutdown();
+        }
+    }
+    /**
+     * Attempt to reconnect to a server with exponential backoff
+     */
+    async reconnect(serverName, config, attempt = 0) {
+        const maxAttempts = 3;
+        const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+        if (attempt >= maxAttempts)
+            return;
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, delay);
+            this.reconnectTimers.set(serverName, timer);
+        });
+        this.reconnectTimers.delete(serverName);
+        // Bail out if server was disconnected while we were waiting
+        if (!this.serverConfigs.has(serverName))
+            return;
+        // Guard against double-reconnect race: if another reconnect already
+        // re-established the connection, skip this attempt.
+        if (this.servers.has(serverName))
+            return;
+        try {
+            await this.connect(config);
+        }
+        catch {
+            await this.reconnect(serverName, config, attempt + 1);
+        }
+    }
+    /**
+     * Disconnect from all servers
+     */
+    async disconnectAll() {
+        // Collect names from both active connections and pending reconnects
+        const names = new Set([...this.servers.keys(), ...this.reconnectTimers.keys()]);
+        await Promise.all([...names].map((name) => this.disconnect(name)));
+    }
+    /**
+     * Get connected server names
+     */
+    getConnectedServers() {
+        return [...this.servers.keys()];
+    }
+    // ========== Tools ==========
+    /**
+     * List all tools from all connected servers
+     */
+    async listAllTools() {
+        const results = await Promise.all([...this.servers.entries()].map(async ([name, conn]) => {
+            try {
+                const tools = await conn.listTools();
+                return tools.map((t) => ({ ...t, server: name }));
+            }
+            catch {
+                return [];
+            }
+        }));
+        return results.flat();
+    }
+    /**
+     * Call a tool on a specific server
+     */
+    async callTool(server, tool, args, abortSignal) {
+        const conn = this.servers.get(server);
+        if (!conn) {
+            return { success: false, message: `Server not connected: ${server}` };
+        }
+        return conn.callTool(tool, args, abortSignal);
+    }
+    // ========== Resources ==========
+    /**
+     * List all resources from all connected servers
+     */
+    async listAllResources() {
+        const results = await Promise.all([...this.servers.entries()].map(async ([name, conn]) => {
+            try {
+                const resources = await conn.listResources();
+                return resources.map((r) => ({ ...r, server: name }));
+            }
+            catch {
+                return [];
+            }
+        }));
+        return results.flat();
+    }
+    /**
+     * Read a resource from a specific server
+     */
+    async readResource(server, uri) {
+        const conn = this.servers.get(server);
+        if (!conn) {
+            throw new Error(`Server not connected: ${server}`);
+        }
+        return conn.readResource(uri);
+    }
+    // ========== Prompts ==========
+    /**
+     * List all prompts from all connected servers
+     */
+    async listAllPrompts() {
+        const results = await Promise.all([...this.servers.entries()].map(async ([name, conn]) => {
+            try {
+                const prompts = await conn.listPrompts();
+                return prompts.map((p) => ({ ...p, server: name }));
+            }
+            catch {
+                return [];
+            }
+        }));
+        return results.flat();
+    }
+    /**
+     * Get a prompt from a specific server
+     */
+    async getPrompt(server, name, args) {
+        const conn = this.servers.get(server);
+        if (!conn) {
+            throw new Error(`Server not connected: ${server}`);
+        }
+        return conn.getPrompt(name, args);
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/mcp/connection.js

@@ -0,0 +1,484 @@
+/**
+ * MCP Server Connection
+ *
+ * Manages lifecycle and protocol methods for a single MCP server.
+ */
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+import { PassThrough, Writable } from "stream";
+// Hardcoded version — updated by release script.
+// DO NOT read from package.json — breaks when bun bundles the file.
+const TOOLS_VERSION = "1.0.30";
+import { JSONRPCClient } from "./jsonrpc.js";
+function sanitizeGitEnv(env = process.env) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value === undefined)
+            continue;
+        if (key.toUpperCase().startsWith("GIT_"))
+            continue;
+        sanitized[key] = value;
+    }
+    return sanitized;
+}
+export class MCPServerConnection extends EventEmitter {
+    config;
+    process;
+    transport = "stdio";
+    rpc;
+    capabilities = {};
+    _initialized = false;
+    sseAbortController;
+    sseStreamPromise;
+    ssePostUrl;
+    sseSessionId;
+    sseOutput;
+    // Auto-reconnect state
+    _disconnecting = false;
+    _reconnecting = false;
+    _reconnectAttempts = 0;
+    static RECONNECT_BASE_DELAY_MS = 1000;
+    static RECONNECT_MAX_DELAY_MS = 30000;
+    static RECONNECT_MAX_ATTEMPTS = 5;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.rpc = new JSONRPCClient();
+    }
+    get name() {
+        return this.config.name;
+    }
+    get initialized() {
+        return this._initialized;
+    }
+    /**
+     * Initialize connection to MCP server
+     */
+    async initialize() {
+        // Reset disconnecting flag on fresh initialization so auto-reconnect is active.
+        // During reconnect, attemptReconnect() checks _disconnecting before each attempt.
+        if (!this._reconnecting) {
+            this._disconnecting = false;
+            this._reconnectAttempts = 0;
+        }
+        this.transport = this.config.transport ?? "stdio";
+        try {
+            if (this.transport === "stdio") {
+                await this.initializeStdioTransport();
+            }
+            else {
+                await this.initializeSSETransport();
+            }
+            // Forward notifications
+            this.rpc.on("notifications/tools/list_changed", () => this.emit("tools/list_changed"));
+            this.rpc.on("notifications/resources/list_changed", () => this.emit("resources/list_changed"));
+            this.rpc.on("notifications/prompts/list_changed", () => this.emit("prompts/list_changed"));
+            // MCP initialize handshake
+            const result = await this.rpc.request("initialize", {
+                protocolVersion: "2024-11-05",
+                capabilities: {
+                    roots: { listChanged: true },
+                },
+                clientInfo: {
+                    name: "aria-cli",
+                    version: TOOLS_VERSION,
+                },
+            });
+            this.capabilities = result.capabilities || {};
+            this._initialized = true;
+            // Send initialized notification
+            this.rpc.notify("notifications/initialized", {});
+            return this.capabilities;
+        }
+        catch (error) {
+            await this.cleanupAfterInitializeFailure();
+            throw error;
+        }
+    }
+    /**
+     * Attempt to reconnect with exponential backoff.
+     * Called when the transport drops unexpectedly (not via explicit shutdown).
+     */
+    async attemptReconnect() {
+        if (this._disconnecting || this._reconnecting) {
+            return;
+        }
+        this._reconnecting = true;
+        while (this._reconnectAttempts < MCPServerConnection.RECONNECT_MAX_ATTEMPTS &&
+            !this._disconnecting) {
+            this._reconnectAttempts++;
+            const delay = Math.min(MCPServerConnection.RECONNECT_BASE_DELAY_MS * Math.pow(2, this._reconnectAttempts - 1), MCPServerConnection.RECONNECT_MAX_DELAY_MS);
+            this.emit("log", {
+                level: "info",
+                message: `Reconnect attempt ${this._reconnectAttempts}/${MCPServerConnection.RECONNECT_MAX_ATTEMPTS} in ${delay}ms`,
+            });
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            if (this._disconnecting) {
+                break;
+            }
+            try {
+                // Clean up stale RPC state before reconnecting
+                this.rpc.close();
+                this.rpc = new JSONRPCClient();
+                await this.initialize();
+                // Success — reset reconnect state
+                this._reconnectAttempts = 0;
+                this._reconnecting = false;
+                this.emit("reconnected");
+                return;
+            }
+            catch (error) {
+                this.emit("log", {
+                    level: "error",
+                    message: `Reconnect attempt ${this._reconnectAttempts} failed: ${error.message}`,
+                });
+            }
+        }
+        // All attempts exhausted or disconnecting flag was set
+        this._reconnecting = false;
+        if (!this._disconnecting) {
+            this._initialized = false;
+            this.emit("error", new Error(`Failed to reconnect after ${MCPServerConnection.RECONNECT_MAX_ATTEMPTS} attempts`));
+        }
+    }
+    async initializeStdioTransport() {
+        if (!this.config.command) {
+            throw new Error("Command required for stdio transport");
+        }
+        // Spawn server process
+        this.process = spawn(this.config.command, this.config.args || [], {
+            env: { ...sanitizeGitEnv(), ...sanitizeGitEnv(this.config.env ?? {}) },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (!this.process.stdin || !this.process.stdout) {
+            throw new Error("Failed to create stdio streams");
+        }
+        this.rpc.connect(this.process.stdin, this.process.stdout);
+        // Handle stderr for logging
+        this.process.stderr?.on("data", (data) => {
+            this.emit("log", { level: "error", message: data.toString() });
+        });
+        this.process.on("exit", (code) => {
+            this._initialized = false;
+            this.rpc.close();
+            this.emit("exit", code);
+            // Attempt auto-reconnect on unexpected exit
+            if (!this._disconnecting) {
+                void this.attemptReconnect();
+            }
+        });
+    }
+    async initializeSSETransport() {
+        const url = this.config.url;
+        if (!url) {
+            throw new Error("URL required for sse transport");
+        }
+        const stdin = new Writable({
+            write: (chunk, _encoding, callback) => {
+                const payload = chunk.toString();
+                this.postSSEMessages(payload)
+                    .then(() => callback())
+                    .catch((err) => callback(err));
+            },
+        });
+        const stdout = new PassThrough();
+        this.sseOutput = stdout;
+        this.rpc.connect(stdin, stdout);
+        this.sseAbortController = new AbortController();
+        const response = await fetch(url, {
+            method: "GET",
+            headers: { Accept: "text/event-stream" },
+            signal: this.sseAbortController.signal,
+        });
+        if (!response.ok || !response.body) {
+            const errorText = await response.text();
+            throw new Error(`Failed to connect SSE transport: ${response.status} ${response.statusText} ${errorText}`);
+        }
+        this.sseSessionId = response.headers.get("mcp-session-id") ?? undefined;
+        this.ssePostUrl = url;
+        this.sseStreamPromise = this.consumeSSE(response.body, url);
+    }
+    async postSSEMessages(payload) {
+        const trimmed = payload.trim();
+        if (!trimmed) {
+            return;
+        }
+        const endpoint = this.ssePostUrl || this.config.url;
+        if (!endpoint) {
+            throw new Error("SSE transport endpoint is not configured");
+        }
+        const messages = trimmed
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+        for (const message of messages) {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(this.sseSessionId ? { "mcp-session-id": this.sseSessionId } : {}),
+                },
+                body: message,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`SSE transport POST failed: ${response.status} ${response.statusText} ${errorText}`);
+            }
+            const responseText = (await response.text()).trim();
+            if (!responseText || !this.sseOutput) {
+                continue;
+            }
+            // Some servers return direct JSON-RPC responses on POST while others
+            // publish responses only via SSE. Forward direct JSON replies into RPC.
+            for (const line of responseText.split("\n")) {
+                const jsonLine = line.trim();
+                if (!jsonLine) {
+                    continue;
+                }
+                if (jsonLine.startsWith("{") && jsonLine.endsWith("}")) {
+                    this.sseOutput.write(`${jsonLine}\n`);
+                }
+            }
+        }
+    }
+    async consumeSSE(body, baseUrl) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let eventType = "";
+        let dataLines = [];
+        const dispatch = () => {
+            if (dataLines.length === 0) {
+                eventType = "";
+                return;
+            }
+            const data = dataLines.join("\n").trim();
+            const event = eventType || "message";
+            eventType = "";
+            dataLines = [];
+            if (!data) {
+                return;
+            }
+            if (event === "endpoint") {
+                this.ssePostUrl = new URL(data, baseUrl).toString();
+                return;
+            }
+            if (!this.sseOutput) {
+                return;
+            }
+            if (data.startsWith("{") && data.endsWith("}")) {
+                this.sseOutput.write(`${data}\n`);
+            }
+        };
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    dispatch();
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split(/\r?\n/);
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line === "") {
+                        dispatch();
+                        continue;
+                    }
+                    if (line.startsWith("event:")) {
+                        eventType = line.slice(6).trim();
+                        continue;
+                    }
+                    if (line.startsWith("data:")) {
+                        dataLines.push(line.slice(5).trim());
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore abort errors from normal shutdown.
+            if (!(error instanceof DOMException && error.name === "AbortError")) {
+                this.emit("log", {
+                    level: "error",
+                    message: `SSE stream error: ${error.message}`,
+                });
+            }
+        }
+        finally {
+            if (this._initialized) {
+                this._initialized = false;
+                this.rpc.close();
+                this.emit("exit", 0);
+                // Attempt auto-reconnect on unexpected SSE stream end
+                if (!this._disconnecting) {
+                    void this.attemptReconnect();
+                }
+            }
+        }
+    }
+    async cleanupAfterInitializeFailure() {
+        if (this.transport === "stdio") {
+            if (this.process && !this.process.killed) {
+                try {
+                    this.process.kill("SIGTERM");
+                }
+                catch {
+                    // Ignore kill failures during cleanup.
+                }
+            }
+            this.process = undefined;
+        }
+        else {
+            this.sseAbortController?.abort();
+            try {
+                await this.sseStreamPromise;
+            }
+            catch {
+                // Ignore stream errors during cleanup.
+            }
+            this.sseOutput?.end();
+            this.sseOutput = undefined;
+        }
+        this.rpc.close();
+    }
+    /**
+     * Gracefully shutdown the connection
+     */
+    async shutdown() {
+        this._disconnecting = true;
+        if (!this._initialized)
+            return;
+        this._initialized = false;
+        if (this.transport === "sse") {
+            try {
+                await this.rpc.request("shutdown", {});
+                this.rpc.notify("notifications/exit", {});
+            }
+            catch {
+                // Best effort
+            }
+            this.sseAbortController?.abort();
+            try {
+                await this.sseStreamPromise;
+            }
+            catch {
+                // Ignore stream shutdown errors
+            }
+            this.sseOutput?.end();
+            this.sseOutput = undefined;
+            this.rpc.close();
+            return;
+        }
+        if (this.process) {
+            // Send MCP shutdown/exit protocol before killing
+            try {
+                await this.rpc.request("shutdown", {});
+                this.rpc.notify("notifications/exit", {});
+                // Give process a moment to clean up
+                await new Promise((resolve) => setTimeout(resolve, 500));
+            }
+            catch {
+                // Process may already be dead, proceed with kill
+            }
+            this.process.kill("SIGTERM");
+            // Await process exit before resolving
+            await new Promise((resolve) => {
+                // Escalate to SIGKILL if process doesn't exit within 5s
+                const killTimeout = setTimeout(() => {
+                    try {
+                        this.process?.kill("SIGKILL");
+                    }
+                    catch {
+                        /* already dead */
+                    }
+                }, 5000);
+                this.process.once("exit", () => {
+                    clearTimeout(killTimeout);
+                    this.rpc.close();
+                    resolve();
+                });
+            });
+        }
+        else {
+            this.rpc.close();
+        }
+    }
+    // ========== Tools ==========
+    async listTools() {
+        const result = await this.rpc.request("tools/list", {});
+        return result.tools || [];
+    }
+    async callTool(name, args, abortSignal) {
+        // Early abort check before making the RPC call
+        if (abortSignal?.aborted) {
+            return { success: false, message: "Tool execution cancelled by user." };
+        }
+        try {
+            // Race the RPC call against the abort signal so user cancel
+            // doesn't block waiting for a slow MCP server response.
+            const rpcPromise = this.rpc.request("tools/call", {
+                name,
+                arguments: args,
+            });
+            let result;
+            if (abortSignal) {
+                result = await new Promise((resolve, reject) => {
+                    const onAbort = () => reject(new DOMException("Aborted", "AbortError"));
+                    abortSignal.addEventListener("abort", onAbort, { once: true });
+                    rpcPromise.then((r) => {
+                        abortSignal.removeEventListener("abort", onAbort);
+                        resolve(r);
+                    }, (e) => {
+                        abortSignal.removeEventListener("abort", onAbort);
+                        reject(e);
+                    });
+                });
+            }
+            else {
+                result = await rpcPromise;
+            }
+            const text = result.content
+                ?.filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n") || "";
+            return {
+                success: !result.isError,
+                message: text,
+                data: result.content,
+            };
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === "AbortError") {
+                return { success: false, message: "Tool execution cancelled by user." };
+            }
+            return {
+                success: false,
+                message: error.message,
+            };
+        }
+    }
+    // ========== Resources ==========
+    async listResources() {
+        const result = await this.rpc.request("resources/list", {});
+        return result.resources || [];
+    }
+    async readResource(uri) {
+        const result = await this.rpc.request("resources/read", {
+            uri,
+        });
+        return result.contents || [];
+    }
+    // ========== Prompts ==========
+    async listPrompts() {
+        const result = await this.rpc.request("prompts/list", {});
+        return result.prompts || [];
+    }
+    async getPrompt(name, args) {
+        const result = await this.rpc.request("prompts/get", {
+            name,
+            arguments: args,
+        });
+        return result.messages || [];
+    }
+}
+//# sourceMappingURL=connection.js.map

package/dist/mcp/index.js

@@ -0,0 +1,11 @@
+/**
+ * MCP (Model Context Protocol) Module
+ *
+ * Provides client implementation for connecting to MCP servers
+ * and discovering tools, resources, and prompts dynamically.
+ */
+export * from "./types.js";
+export { JSONRPCClient } from "./jsonrpc.js";
+export { MCPServerConnection } from "./connection.js";
+export { MCPClient } from "./client.js";
+//# sourceMappingURL=index.js.map