@aria-cli/tools 1.0.8 → 1.0.10

package/src/local-control-http-auth.ts

@@ -1,2 +0,0 @@
-export const LOCAL_HTTP_CLIENT_ID_HEADER = "x-aria-local-client-id";
-export const LOCAL_HTTP_CLIENT_PROOF_HEADER = "x-aria-local-client-proof";

package/src/mcp/client.ts

@@ -1,218 +0,0 @@
-/**
- * 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 class MCPClient extends EventEmitter {
-  private servers: Map<string, MCPServerConnection> = new Map();
-  private serverConfigs: Map<string, MCPServerConfig> = new Map();
-  private reconnectTimers: Map<string, ReturnType<typeof setTimeout>> = new Map();
-  private logger: Logger;
-
-  constructor(options?: { logger?: Logger }) {
-    super();
-    this.logger = options?.logger ?? console;
-  }
-
-  /**
-   * Connect to an MCP server
-   */
-  async connect(config: MCPServerConfig): Promise<MCPServerConnection> {
-    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: string): Promise<void> {
-    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
-   */
-  private async reconnect(serverName: string, config: MCPServerConfig, attempt = 0): Promise<void> {
-    const maxAttempts = 3;
-    const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
-    if (attempt >= maxAttempts) return;
-    await new Promise<void>((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(): Promise<void> {
-    // 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(): string[] {
-    return [...this.servers.keys()];
-  }
-
-  // ========== Tools ==========
-
-  /**
-   * List all tools from all connected servers
-   */
-  async listAllTools(): Promise<Array<MCPTool & { server: string }>> {
-    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: string,
-    tool: string,
-    args: unknown,
-    abortSignal?: AbortSignal,
-  ): Promise<ToolResult> {
-    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(): Promise<Array<MCPResource & { server: string }>> {
-    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: string, uri: string): Promise<MCPResourceContent[]> {
-    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(): Promise<Array<MCPPrompt & { server: string }>> {
-    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: string,
-    name: string,
-    args?: Record<string, string>,
-  ): Promise<MCPPromptMessage[]> {
-    const conn = this.servers.get(server);
-    if (!conn) {
-      throw new Error(`Server not connected: ${server}`);
-    }
-    return conn.getPrompt(name, args);
-  }
-}