@aria-cli/tools 1.0.10 → 1.0.12

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCAL_HTTP_CLIENT_PROOF_HEADER = exports.LOCAL_HTTP_CLIENT_ID_HEADER = void 0;
+exports.LOCAL_HTTP_CLIENT_ID_HEADER = "x-aria-local-client-id";
+exports.LOCAL_HTTP_CLIENT_PROOF_HEADER = "x-aria-local-client-proof";

package/dist-cjs/mcp/client.d.ts

@@ -0,0 +1,68 @@
+/**
+ * MCP Multi-Server Client
+ *
+ * Manages connections to multiple MCP servers and aggregates their capabilities.
+ */
+import { EventEmitter } from "events";
+import { MCPServerConnection } from "./connection.js";
+import type { MCPServerConfig, MCPTool, MCPResource, MCPResourceContent, MCPPrompt, MCPPromptMessage } from "./types.js";
+import type { ToolResult, Logger } from "../types.js";
+export declare class MCPClient extends EventEmitter {
+    private servers;
+    private serverConfigs;
+    private reconnectTimers;
+    private logger;
+    constructor(options?: {
+        logger?: Logger;
+    });
+    /**
+     * Connect to an MCP server
+     */
+    connect(config: MCPServerConfig): Promise<MCPServerConnection>;
+    /**
+     * Disconnect from a specific server
+     */
+    disconnect(name: string): Promise<void>;
+    /**
+     * Attempt to reconnect to a server with exponential backoff
+     */
+    private reconnect;
+    /**
+     * Disconnect from all servers
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Get connected server names
+     */
+    getConnectedServers(): string[];
+    /**
+     * List all tools from all connected servers
+     */
+    listAllTools(): Promise<Array<MCPTool & {
+        server: string;
+    }>>;
+    /**
+     * Call a tool on a specific server
+     */
+    callTool(server: string, tool: string, args: unknown, abortSignal?: AbortSignal): Promise<ToolResult>;
+    /**
+     * List all resources from all connected servers
+     */
+    listAllResources(): Promise<Array<MCPResource & {
+        server: string;
+    }>>;
+    /**
+     * Read a resource from a specific server
+     */
+    readResource(server: string, uri: string): Promise<MCPResourceContent[]>;
+    /**
+     * List all prompts from all connected servers
+     */
+    listAllPrompts(): Promise<Array<MCPPrompt & {
+        server: string;
+    }>>;
+    /**
+     * Get a prompt from a specific server
+     */
+    getPrompt(server: string, name: string, args?: Record<string, string>): Promise<MCPPromptMessage[]>;
+}

package/dist-cjs/mcp/client.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * MCP Multi-Server Client
+ *
+ * Manages connections to multiple MCP servers and aggregates their capabilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPClient = void 0;
+const events_1 = require("events");
+const connection_js_1 = require("./connection.js");
+class MCPClient extends events_1.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 connection_js_1.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);
+    }
+}
+exports.MCPClient = MCPClient;

package/dist-cjs/mcp/connection.d.ts

@@ -0,0 +1,54 @@
+/**
+ * MCP Server Connection
+ *
+ * Manages lifecycle and protocol methods for a single MCP server.
+ */
+import { EventEmitter } from "events";
+import type { MCPServerConfig, MCPCapabilities, MCPTool, MCPResource, MCPResourceContent, MCPPrompt, MCPPromptMessage } from "./types.js";
+import type { ToolResult } from "../types.js";
+export declare class MCPServerConnection extends EventEmitter {
+    private config;
+    private process?;
+    private transport;
+    private rpc;
+    private capabilities;
+    private _initialized;
+    private sseAbortController?;
+    private sseStreamPromise?;
+    private ssePostUrl?;
+    private sseSessionId?;
+    private sseOutput?;
+    private _disconnecting;
+    private _reconnecting;
+    private _reconnectAttempts;
+    private static readonly RECONNECT_BASE_DELAY_MS;
+    private static readonly RECONNECT_MAX_DELAY_MS;
+    private static readonly RECONNECT_MAX_ATTEMPTS;
+    constructor(config: MCPServerConfig);
+    get name(): string;
+    get initialized(): boolean;
+    /**
+     * Initialize connection to MCP server
+     */
+    initialize(): Promise<MCPCapabilities>;
+    /**
+     * Attempt to reconnect with exponential backoff.
+     * Called when the transport drops unexpectedly (not via explicit shutdown).
+     */
+    private attemptReconnect;
+    private initializeStdioTransport;
+    private initializeSSETransport;
+    private postSSEMessages;
+    private consumeSSE;
+    private cleanupAfterInitializeFailure;
+    /**
+     * Gracefully shutdown the connection
+     */
+    shutdown(): Promise<void>;
+    listTools(): Promise<MCPTool[]>;
+    callTool(name: string, args: unknown, abortSignal?: AbortSignal): Promise<ToolResult>;
+    listResources(): Promise<MCPResource[]>;
+    readResource(uri: string): Promise<MCPResourceContent[]>;
+    listPrompts(): Promise<MCPPrompt[]>;
+    getPrompt(name: string, args?: Record<string, string>): Promise<MCPPromptMessage[]>;
+}