@aria-cli/tools 1.0.12 → 1.0.13

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

@@ -1,5 +0,0 @@
-"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.js

@@ -1,185 +0,0 @@
-"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.js

@@ -1,484 +0,0 @@
-"use strict";
-/**
- * MCP Server Connection
- *
- * Manages lifecycle and protocol methods for a single MCP server.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPServerConnection = void 0;
-const child_process_1 = require("child_process");
-const events_1 = require("events");
-const stream_1 = require("stream");
-const jsonrpc_js_1 = require("./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;
-}
-class MCPServerConnection extends events_1.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 jsonrpc_js_1.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: "1.0.0",
-                },
-            });
-            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 jsonrpc_js_1.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 = (0, child_process_1.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 stream_1.Writable({
-            write: (chunk, _encoding, callback) => {
-                const payload = chunk.toString();
-                this.postSSEMessages(payload)
-                    .then(() => callback())
-                    .catch((err) => callback(err));
-            },
-        });
-        const stdout = new stream_1.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 || [];
-    }
-}
-exports.MCPServerConnection = MCPServerConnection;