aemeathcli 1.0.0

package/dist/chunk-JAXXTYID.js

@@ -0,0 +1,51 @@
+import pino from 'pino';
+import { homedir } from 'os';
+import { join } from 'path';
+import { mkdirSync } from 'fs';
+
+// src/utils/logger.ts
+var LOG_DIR = join(homedir(), ".aemeathcli", "logs");
+function ensureLogDir() {
+  try {
+    mkdirSync(LOG_DIR, { recursive: true, mode: 448 });
+  } catch {
+  }
+}
+var REDACT_PATHS = [
+  "token",
+  "refreshToken",
+  "apiKey",
+  "accessToken",
+  "sessionToken",
+  "password",
+  "secret",
+  "authorization",
+  "cookie",
+  "*.token",
+  "*.refreshToken",
+  "*.apiKey",
+  "*.accessToken",
+  "*.sessionToken",
+  "*.password",
+  "*.secret"
+];
+ensureLogDir();
+var logger = pino({
+  name: "aemeathcli",
+  level: process.env["AEMEATHCLI_LOG_LEVEL"] ?? "error",
+  redact: {
+    paths: REDACT_PATHS,
+    censor: "[REDACTED]"
+  },
+  ...process.env["NODE_ENV"] === "development" ? {
+    transport: {
+      target: "pino/file",
+      options: { destination: join(LOG_DIR, "aemeathcli.log"), mkdir: true }
+    }
+  } : {},
+  timestamp: pino.stdTimeFunctions.isoTime
+});
+
+export { logger };
+//# sourceMappingURL=chunk-JAXXTYID.js.map
+//# sourceMappingURL=chunk-JAXXTYID.js.map

package/dist/chunk-JAXXTYID.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/logger.ts"],"names":[],"mappings":";;;;;;AAUA,IAAM,OAAA,GAAU,IAAA,CAAK,OAAA,EAAQ,EAAG,eAAe,MAAM,CAAA;AAErD,SAAS,YAAA,GAAqB;AAC5B,EAAA,IAAI;AACF,IAAA,SAAA,CAAU,SAAS,EAAE,SAAA,EAAW,IAAA,EAAM,IAAA,EAAM,KAAO,CAAA;AAAA,EACrD,CAAA,CAAA,MAAQ;AAAA,EAER;AACF;AAGA,IAAM,YAAA,GAAe;AAAA,EACnB,OAAA;AAAA,EACA,cAAA;AAAA,EACA,QAAA;AAAA,EACA,aAAA;AAAA,EACA,cAAA;AAAA,EACA,UAAA;AAAA,EACA,QAAA;AAAA,EACA,eAAA;AAAA,EACA,QAAA;AAAA,EACA,SAAA;AAAA,EACA,gBAAA;AAAA,EACA,UAAA;AAAA,EACA,eAAA;AAAA,EACA,gBAAA;AAAA,EACA,YAAA;AAAA,EACA;AACF,CAAA;AAEA,YAAA,EAAa;AAEb,IAAM,SAAS,IAAA,CAAK;AAAA,EAClB,IAAA,EAAM,YAAA;AAAA,EACN,KAAA,EAAO,OAAA,CAAQ,GAAA,CAAI,sBAAsB,CAAA,IAAK,OAAA;AAAA,EAC9C,MAAA,EAAQ;AAAA,IACN,KAAA,EAAO,YAAA;AAAA,IACP,MAAA,EAAQ;AAAA,GACV;AAAA,EACA,GAAI,OAAA,CAAQ,GAAA,CAAI,UAAU,MAAM,aAAA,GAC5B;AAAA,IACE,SAAA,EAAW;AAAA,MACT,MAAA,EAAQ,WAAA;AAAA,MACR,OAAA,EAAS,EAAE,WAAA,EAAa,IAAA,CAAK,SAAS,gBAAgB,CAAA,EAAG,OAAO,IAAA;AAAK;AACvE,MAEF,EAAC;AAAA,EACL,SAAA,EAAW,KAAK,gBAAA,CAAiB;AACnC,CAAC","file":"chunk-JAXXTYID.js","sourcesContent":["/**\n * Structured logging via pino per PRD section 16.1\n * Automatic credential redaction per PRD section 14.1\n */\n\nimport pino from \"pino\";\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { mkdirSync } from \"node:fs\";\n\nconst LOG_DIR = join(homedir(), \".aemeathcli\", \"logs\");\n\nfunction ensureLogDir(): void {\n  try {\n    mkdirSync(LOG_DIR, { recursive: true, mode: 0o700 });\n  } catch {\n    // Log dir creation failed — fall back to stderr only\n  }\n}\n\n// Redaction patterns for credentials (PRD section 14.2 REQ-CRED-04)\nconst REDACT_PATHS = [\n  \"token\",\n  \"refreshToken\",\n  \"apiKey\",\n  \"accessToken\",\n  \"sessionToken\",\n  \"password\",\n  \"secret\",\n  \"authorization\",\n  \"cookie\",\n  \"*.token\",\n  \"*.refreshToken\",\n  \"*.apiKey\",\n  \"*.accessToken\",\n  \"*.sessionToken\",\n  \"*.password\",\n  \"*.secret\",\n];\n\nensureLogDir();\n\nconst logger = pino({\n  name: \"aemeathcli\",\n  level: process.env[\"AEMEATHCLI_LOG_LEVEL\"] ?? \"error\",\n  redact: {\n    paths: REDACT_PATHS,\n    censor: \"[REDACTED]\",\n  },\n  ...(process.env[\"NODE_ENV\"] === \"development\"\n    ? {\n        transport: {\n          target: \"pino/file\",\n          options: { destination: join(LOG_DIR, \"aemeathcli.log\"), mkdir: true },\n        },\n      }\n    : {}),\n  timestamp: pino.stdTimeFunctions.isoTime,\n});\n\nexport { logger };\n"]}

package/dist/chunk-LSOYPSAT.js

@@ -0,0 +1,183 @@
+import { logger } from './chunk-JAXXTYID.js';
+
+// src/skills/executor.ts
+var SkillExecutor = class {
+  registry;
+  activeSkill = null;
+  baseAllowedTools = null;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * Activate a skill by name.
+   */
+  async activateByName(name, modelCapabilities) {
+    const definition = await this.registry.getByName(name);
+    if (!definition) {
+      return { success: false, errorMessage: `Skill "${name}" not found` };
+    }
+    return this.activate(definition, modelCapabilities);
+  }
+  /**
+   * Activate a skill by trigger string (e.g. "$review" or "review").
+   */
+  async activateByTrigger(trigger, modelCapabilities) {
+    const definition = await this.registry.getByTrigger(trigger);
+    if (!definition) {
+      return {
+        success: false,
+        errorMessage: `No skill found for trigger "${trigger}"`
+      };
+    }
+    return this.activate(definition, modelCapabilities);
+  }
+  /**
+   * Deactivate the currently active skill, restoring previous tool set.
+   */
+  deactivate() {
+    if (!this.activeSkill) {
+      logger.debug("No active skill to deactivate");
+      return;
+    }
+    const skillName = this.activeSkill.definition.frontmatter.name;
+    this.baseAllowedTools = this.activeSkill.previousAllowedTools;
+    this.activeSkill = null;
+    logger.info({ skill: skillName }, "Skill deactivated");
+  }
+  /**
+   * Get the currently active skill, or null if none.
+   */
+  getActiveSkill() {
+    return this.activeSkill;
+  }
+  /**
+   * Check if any skill is currently active.
+   */
+  isActive() {
+    return this.activeSkill !== null;
+  }
+  /**
+   * Get the active skill's body content for context injection.
+   * Returns null if no skill is active.
+   */
+  getActiveSkillContent() {
+    return this.activeSkill?.definition.body ?? null;
+  }
+  /**
+   * Get the name of the currently active skill, or null.
+   */
+  getActiveSkillName() {
+    return this.activeSkill?.definition.frontmatter.name ?? null;
+  }
+  /**
+   * Get the allowed tool list under the current state.
+   * When a skill is active with allowed-tools, only those tools are permitted.
+   * Returns null when no restrictions are in effect.
+   */
+  getAllowedTools() {
+    if (this.activeSkill) {
+      return this.activeSkill.definition.frontmatter["allowed-tools"] ?? null;
+    }
+    return this.baseAllowedTools;
+  }
+  /**
+   * Check if a specific tool is allowed under the current skill restrictions.
+   */
+  isToolAllowed(toolName) {
+    const allowed = this.getAllowedTools();
+    if (!allowed) return true;
+    return allowed.includes(toolName);
+  }
+  /**
+   * Set the base allowed tools (used when no skill is active).
+   */
+  setBaseAllowedTools(tools) {
+    this.baseAllowedTools = tools;
+  }
+  /**
+   * Validate model requirements for a skill definition.
+   * Returns compatibility status and any warnings.
+   */
+  checkModelRequirements(definition, capabilities) {
+    const warnings = [];
+    const requirements = definition.frontmatter["model-requirements"];
+    if (!requirements) {
+      return { compatible: true, warnings: [] };
+    }
+    const preferredRole = requirements["preferred-role"];
+    if (preferredRole && capabilities.currentRole) {
+      if (capabilities.currentRole !== preferredRole) {
+        warnings.push(
+          `Skill "${definition.frontmatter.name}" prefers role "${preferredRole}", current role is "${capabilities.currentRole}"`
+        );
+      }
+    }
+    const minContext = requirements["min-context"];
+    if (minContext !== void 0 && minContext !== null) {
+      if (capabilities.contextWindow < minContext) {
+        warnings.push(
+          `Skill "${definition.frontmatter.name}" requires ${minContext} context tokens, but current model has ${capabilities.contextWindow}`
+        );
+        return { compatible: false, warnings };
+      }
+    }
+    return { compatible: true, warnings };
+  }
+  // ── Private ───────────────────────────────────────────────────────────
+  /**
+   * Core activation logic. Deactivates any current skill first.
+   */
+  activate(definition, modelCapabilities) {
+    const allWarnings = [];
+    if (modelCapabilities) {
+      const { compatible, warnings } = this.checkModelRequirements(
+        definition,
+        modelCapabilities
+      );
+      allWarnings.push(...warnings);
+      for (const warning of warnings) {
+        logger.warn({ skill: definition.frontmatter.name }, warning);
+      }
+      if (!compatible) {
+        return {
+          success: false,
+          skill: definition,
+          errorMessage: `Model does not meet skill requirements: ${warnings.join("; ")}`,
+          warnings: allWarnings
+        };
+      }
+    }
+    if (this.activeSkill) {
+      logger.info(
+        {
+          current: this.activeSkill.definition.frontmatter.name,
+          next: definition.frontmatter.name
+        },
+        "Switching active skill"
+      );
+      this.deactivate();
+    }
+    this.activeSkill = {
+      definition,
+      activatedAt: /* @__PURE__ */ new Date(),
+      previousAllowedTools: this.baseAllowedTools
+    };
+    logger.info(
+      {
+        skill: definition.frontmatter.name,
+        version: definition.frontmatter.version,
+        allowedTools: definition.frontmatter["allowed-tools"]
+      },
+      "Skill activated"
+    );
+    return {
+      success: true,
+      skill: definition,
+      ...allWarnings.length > 0 ? { warnings: allWarnings } : {}
+    };
+  }
+};
+
+export { SkillExecutor };
+//# sourceMappingURL=chunk-LSOYPSAT.js.map
+//# sourceMappingURL=chunk-LSOYPSAT.js.map

package/dist/chunk-LSOYPSAT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/skills/executor.ts"],"names":[],"mappings":"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","file":"chunk-LSOYPSAT.js","sourcesContent":["/**\n * SkillExecutor — Manages skill activation, context injection, and tool restriction.\n * Per PRD section 10.3: Load full SKILL.md content into context on activation,\n * restrict tools, and unload on deactivation.\n */\n\nimport { logger } from \"../utils/logger.js\";\nimport type { ISkillDefinition } from \"../types/config.js\";\nimport type { ModelRole } from \"../types/model.js\";\nimport type { SkillRegistry } from \"./registry.js\";\n\n// ── Types ───────────────────────────────────────────────────────────────\n\nexport interface IActiveSkill {\n  readonly definition: ISkillDefinition;\n  readonly activatedAt: Date;\n  readonly previousAllowedTools: readonly string[] | null;\n}\n\nexport interface ISkillActivationResult {\n  readonly success: boolean;\n  readonly skill?: ISkillDefinition;\n  readonly errorMessage?: string;\n  readonly warnings?: readonly string[];\n}\n\nexport interface IModelCapabilities {\n  readonly contextWindow: number;\n  readonly currentRole?: ModelRole;\n}\n\n// ── SkillExecutor Class ─────────────────────────────────────────────────\n\nexport class SkillExecutor {\n  private readonly registry: SkillRegistry;\n  private activeSkill: IActiveSkill | null = null;\n  private baseAllowedTools: readonly string[] | null = null;\n\n  constructor(registry: SkillRegistry) {\n    this.registry = registry;\n  }\n\n  /**\n   * Activate a skill by name.\n   */\n  async activateByName(\n    name: string,\n    modelCapabilities?: IModelCapabilities,\n  ): Promise<ISkillActivationResult> {\n    const definition = await this.registry.getByName(name);\n    if (!definition) {\n      return { success: false, errorMessage: `Skill \"${name}\" not found` };\n    }\n\n    return this.activate(definition, modelCapabilities);\n  }\n\n  /**\n   * Activate a skill by trigger string (e.g. \"$review\" or \"review\").\n   */\n  async activateByTrigger(\n    trigger: string,\n    modelCapabilities?: IModelCapabilities,\n  ): Promise<ISkillActivationResult> {\n    const definition = await this.registry.getByTrigger(trigger);\n    if (!definition) {\n      return {\n        success: false,\n        errorMessage: `No skill found for trigger \"${trigger}\"`,\n      };\n    }\n\n    return this.activate(definition, modelCapabilities);\n  }\n\n  /**\n   * Deactivate the currently active skill, restoring previous tool set.\n   */\n  deactivate(): void {\n    if (!this.activeSkill) {\n      logger.debug(\"No active skill to deactivate\");\n      return;\n    }\n\n    const skillName = this.activeSkill.definition.frontmatter.name;\n    this.baseAllowedTools = this.activeSkill.previousAllowedTools;\n    this.activeSkill = null;\n\n    logger.info({ skill: skillName }, \"Skill deactivated\");\n  }\n\n  /**\n   * Get the currently active skill, or null if none.\n   */\n  getActiveSkill(): IActiveSkill | null {\n    return this.activeSkill;\n  }\n\n  /**\n   * Check if any skill is currently active.\n   */\n  isActive(): boolean {\n    return this.activeSkill !== null;\n  }\n\n  /**\n   * Get the active skill's body content for context injection.\n   * Returns null if no skill is active.\n   */\n  getActiveSkillContent(): string | null {\n    return this.activeSkill?.definition.body ?? null;\n  }\n\n  /**\n   * Get the name of the currently active skill, or null.\n   */\n  getActiveSkillName(): string | null {\n    return this.activeSkill?.definition.frontmatter.name ?? null;\n  }\n\n  /**\n   * Get the allowed tool list under the current state.\n   * When a skill is active with allowed-tools, only those tools are permitted.\n   * Returns null when no restrictions are in effect.\n   */\n  getAllowedTools(): readonly string[] | null {\n    if (this.activeSkill) {\n      return this.activeSkill.definition.frontmatter[\"allowed-tools\"] ?? null;\n    }\n    return this.baseAllowedTools;\n  }\n\n  /**\n   * Check if a specific tool is allowed under the current skill restrictions.\n   */\n  isToolAllowed(toolName: string): boolean {\n    const allowed = this.getAllowedTools();\n    if (!allowed) return true;\n    return allowed.includes(toolName);\n  }\n\n  /**\n   * Set the base allowed tools (used when no skill is active).\n   */\n  setBaseAllowedTools(tools: readonly string[] | null): void {\n    this.baseAllowedTools = tools;\n  }\n\n  /**\n   * Validate model requirements for a skill definition.\n   * Returns compatibility status and any warnings.\n   */\n  checkModelRequirements(\n    definition: ISkillDefinition,\n    capabilities: IModelCapabilities,\n  ): { compatible: boolean; warnings: readonly string[] } {\n    const warnings: string[] = [];\n    const requirements = definition.frontmatter[\"model-requirements\"];\n\n    if (!requirements) {\n      return { compatible: true, warnings: [] };\n    }\n\n    const preferredRole = requirements[\"preferred-role\"];\n    if (preferredRole && capabilities.currentRole) {\n      if (capabilities.currentRole !== preferredRole) {\n        warnings.push(\n          `Skill \"${definition.frontmatter.name}\" prefers role \"${preferredRole}\", ` +\n            `current role is \"${capabilities.currentRole}\"`,\n        );\n      }\n    }\n\n    const minContext = requirements[\"min-context\"];\n    if (minContext !== undefined && minContext !== null) {\n      if (capabilities.contextWindow < minContext) {\n        warnings.push(\n          `Skill \"${definition.frontmatter.name}\" requires ${minContext} context tokens, ` +\n            `but current model has ${capabilities.contextWindow}`,\n        );\n        return { compatible: false, warnings };\n      }\n    }\n\n    return { compatible: true, warnings };\n  }\n\n  // ── Private ───────────────────────────────────────────────────────────\n\n  /**\n   * Core activation logic. Deactivates any current skill first.\n   */\n  private activate(\n    definition: ISkillDefinition,\n    modelCapabilities?: IModelCapabilities,\n  ): ISkillActivationResult {\n    const allWarnings: string[] = [];\n\n    // Validate model requirements if capabilities are provided\n    if (modelCapabilities) {\n      const { compatible, warnings } = this.checkModelRequirements(\n        definition,\n        modelCapabilities,\n      );\n      allWarnings.push(...warnings);\n\n      for (const warning of warnings) {\n        logger.warn({ skill: definition.frontmatter.name }, warning);\n      }\n\n      if (!compatible) {\n        return {\n          success: false,\n          skill: definition,\n          errorMessage: `Model does not meet skill requirements: ${warnings.join(\"; \")}`,\n          warnings: allWarnings,\n        };\n      }\n    }\n\n    // Deactivate current skill if one is active\n    if (this.activeSkill) {\n      logger.info(\n        {\n          current: this.activeSkill.definition.frontmatter.name,\n          next: definition.frontmatter.name,\n        },\n        \"Switching active skill\",\n      );\n      this.deactivate();\n    }\n\n    this.activeSkill = {\n      definition,\n      activatedAt: new Date(),\n      previousAllowedTools: this.baseAllowedTools,\n    };\n\n    logger.info(\n      {\n        skill: definition.frontmatter.name,\n        version: definition.frontmatter.version,\n        allowedTools: definition.frontmatter[\"allowed-tools\"],\n      },\n      \"Skill activated\",\n    );\n\n    return {\n      success: true,\n      skill: definition,\n      ...(allWarnings.length > 0 ? { warnings: allWarnings } : {}),\n    };\n  }\n}\n"]}

package/dist/chunk-MFBHNWGV.js

@@ -0,0 +1,416 @@
+import { ServerConnectionError, ToolCallError } from './chunk-ZGOHARPV.js';
+import { logger } from './chunk-JAXXTYID.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+var DEFAULT_TIMEOUT_MS = 3e4;
+var CLIENT_NAME = "aemeathcli";
+var CLIENT_VERSION = "1.0.0";
+function extractText(content) {
+  if (!Array.isArray(content)) {
+    return "No output";
+  }
+  const parts = [];
+  for (const item of content) {
+    if (item.type === "text" && typeof item.text === "string") {
+      parts.push(item.text);
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : "No output";
+}
+var MCPClient = class {
+  client;
+  connected = false;
+  serverName;
+  transportConfig;
+  connectionTimeoutMs;
+  constructor(options) {
+    this.serverName = options.serverName;
+    this.transportConfig = options.transport;
+    this.connectionTimeoutMs = options.connectionTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  get name() {
+    return this.serverName;
+  }
+  /** Establish connection to the MCP server. */
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    logger.info({ server: this.serverName }, "Connecting to MCP server");
+    try {
+      this.client = new Client(
+        { name: CLIENT_NAME, version: CLIENT_VERSION },
+        { capabilities: { sampling: {} } }
+      );
+      await this.connectWithTimeout();
+      this.connected = true;
+      logger.info({ server: this.serverName }, "Connected to MCP server");
+    } catch (error) {
+      this.connected = false;
+      this.client = void 0;
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new ServerConnectionError(this.serverName, msg);
+    }
+  }
+  /** Gracefully close the MCP connection. */
+  async disconnect() {
+    if (!this.connected || !this.client) {
+      return;
+    }
+    logger.info({ server: this.serverName }, "Disconnecting from MCP server");
+    try {
+      await this.client.close();
+    } catch (error) {
+      logger.warn({ server: this.serverName, error }, "Error during MCP disconnect");
+    } finally {
+      this.connected = false;
+      this.client = void 0;
+    }
+  }
+  /** Disconnect then reconnect to the server. */
+  async reconnect() {
+    await this.disconnect();
+    await this.connect();
+  }
+  /** List all tools exposed by this MCP server. */
+  async listTools() {
+    const client = this.requireConnected();
+    try {
+      const result = await client.listTools();
+      return result.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description ?? "",
+        inputSchema: tool.inputSchema ?? {}
+      }));
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new ServerConnectionError(this.serverName, `listTools failed: ${msg}`);
+    }
+  }
+  /** Call a tool on this MCP server with the given arguments. */
+  async callTool(toolName, args) {
+    const client = this.requireConnected();
+    try {
+      const result = await client.callTool({ name: toolName, arguments: args });
+      return {
+        content: extractText(result.content),
+        isError: result.isError === true
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new ToolCallError(toolName, msg);
+    }
+  }
+  /** List resources exposed by this MCP server. */
+  async listResources() {
+    const client = this.requireConnected();
+    try {
+      const result = await client.listResources();
+      return result.resources.map((r) => ({
+        uri: r.uri,
+        name: r.name ?? r.uri,
+        description: "",
+        mimeType: r.mimeType ?? "application/octet-stream"
+      }));
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new ServerConnectionError(
+        this.serverName,
+        `listResources failed: ${msg}`
+      );
+    }
+  }
+  /** Read a specific resource by URI. */
+  async readResource(uri) {
+    const client = this.requireConnected();
+    try {
+      const result = await client.readResource({ uri });
+      return extractText(result.contents);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new ServerConnectionError(
+        this.serverName,
+        `readResource(${uri}) failed: ${msg}`
+      );
+    }
+  }
+  // ── Private Helpers ─────────────────────────────────────────────────
+  async connectWithTimeout() {
+    const client = this.client;
+    if (!client) {
+      throw new Error("Client not initialised");
+    }
+    const timeoutPromise = new Promise((_resolve, reject) => {
+      setTimeout(
+        () => reject(
+          new Error(
+            `Connection timed out after ${this.connectionTimeoutMs}ms`
+          )
+        ),
+        this.connectionTimeoutMs
+      );
+    });
+    if (this.transportConfig.type === "stdio") {
+      const transport = new StdioClientTransport({
+        command: this.transportConfig.command,
+        args: [...this.transportConfig.args],
+        ...this.transportConfig.env !== void 0 ? { env: { ...this.transportConfig.env } } : {}
+      });
+      await Promise.race([client.connect(transport), timeoutPromise]);
+      return;
+    }
+    if (this.transportConfig.type === "streamable-http") {
+      const { StreamableHTTPClientTransport } = await import('@modelcontextprotocol/sdk/client/streamableHttp.js');
+      const transport = new StreamableHTTPClientTransport(
+        new URL(this.transportConfig.url)
+      );
+      await Promise.race([client.connect(transport), timeoutPromise]);
+      return;
+    }
+    const _exhaustive = this.transportConfig;
+    throw new ServerConnectionError(
+      this.serverName,
+      `Unknown transport type: ${JSON.stringify(_exhaustive)}`
+    );
+  }
+  requireConnected() {
+    if (!this.connected || !this.client) {
+      throw new ServerConnectionError(this.serverName, "Not connected");
+    }
+    return this.client;
+  }
+};
+
+// src/mcp/server-manager.ts
+var DEFAULT_HEALTH_INTERVAL_MS = 6e4;
+var DEFAULT_MAX_FAILURES = 3;
+var DEFAULT_MAX_CALLS_PER_MINUTE = 60;
+var RATE_LIMIT_WINDOW_MS = 6e4;
+var MCPServerManager = class {
+  servers = /* @__PURE__ */ new Map();
+  options;
+  healthCheckTimer;
+  constructor(options) {
+    this.options = {
+      connectionTimeoutMs: options?.connectionTimeoutMs ?? 3e4,
+      healthCheckIntervalMs: options?.healthCheckIntervalMs ?? DEFAULT_HEALTH_INTERVAL_MS,
+      maxConsecutiveFailures: options?.maxConsecutiveFailures ?? DEFAULT_MAX_FAILURES,
+      defaultRateLimit: options?.defaultRateLimit,
+      rateLimits: options?.rateLimits
+    };
+  }
+  /** Start all servers defined in the MCP config. */
+  async startAll(config) {
+    const entries = Object.entries(config.mcpServers);
+    if (entries.length === 0) {
+      logger.info("No MCP servers configured");
+      return;
+    }
+    logger.info({ count: entries.length }, "Starting MCP servers");
+    const results = await Promise.allSettled(
+      entries.map(([name, serverConfig]) => this.startServer(name, serverConfig))
+    );
+    let successCount = 0;
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        successCount++;
+      }
+    }
+    logger.info(
+      { total: entries.length, connected: successCount },
+      "MCP server startup complete"
+    );
+    this.startHealthChecks();
+  }
+  /** Start a single MCP server by name and config. */
+  async startServer(name, serverConfig) {
+    if (this.servers.has(name)) {
+      logger.warn({ server: name }, "MCP server already registered, stopping first");
+      await this.stopServer(name);
+    }
+    logger.info({ server: name, command: serverConfig.command }, "Starting MCP server");
+    const transportConfig = {
+      type: "stdio",
+      command: serverConfig.command,
+      args: [...serverConfig.args],
+      ...serverConfig.env !== void 0 ? { env: { ...serverConfig.env } } : {}
+    };
+    const clientOptions = {
+      serverName: name,
+      transport: transportConfig,
+      connectionTimeoutMs: this.options.connectionTimeoutMs
+    };
+    const client = new MCPClient(clientOptions);
+    const maxCalls = this.getMaxCallsPerMinute(name);
+    const entry = {
+      client,
+      status: "connecting",
+      lastHealthCheck: Date.now(),
+      consecutiveFailures: 0,
+      rateLimit: { callTimestamps: [], maxCallsPerMinute: maxCalls }
+    };
+    this.servers.set(name, entry);
+    try {
+      await client.connect();
+      entry.status = "connected";
+      logger.info({ server: name }, "MCP server connected");
+    } catch (error) {
+      entry.status = "error";
+      entry.consecutiveFailures = 1;
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error({ server: name, error: msg }, "Failed to start MCP server");
+      throw new ServerConnectionError(name, msg);
+    }
+  }
+  /** Stop a single server by name. */
+  async stopServer(name) {
+    const entry = this.servers.get(name);
+    if (!entry) {
+      return;
+    }
+    logger.info({ server: name }, "Stopping MCP server");
+    try {
+      await entry.client.disconnect();
+    } catch (error) {
+      logger.warn({ server: name, error }, "Error stopping MCP server");
+    }
+    entry.status = "stopped";
+    this.servers.delete(name);
+  }
+  /** Stop all managed servers and clean up. */
+  async stopAll() {
+    this.stopHealthChecks();
+    const names = [...this.servers.keys()];
+    logger.info({ count: names.length }, "Stopping all MCP servers");
+    await Promise.allSettled(names.map((name) => this.stopServer(name)));
+  }
+  /** Get a connected client by server name. */
+  getClient(name) {
+    const entry = this.servers.get(name);
+    if (!entry || entry.status !== "connected") {
+      return void 0;
+    }
+    return entry.client;
+  }
+  /** Get all connected server names. */
+  getConnectedServers() {
+    const connected = [];
+    for (const [name, entry] of this.servers) {
+      if (entry.status === "connected") {
+        connected.push(name);
+      }
+    }
+    return connected;
+  }
+  /** Get the status of a server. */
+  getServerStatus(name) {
+    return this.servers.get(name)?.status;
+  }
+  /** List tools from a specific server (with rate-limit check). */
+  async listServerTools(name) {
+    const entry = this.requireServer(name);
+    this.checkRateLimit(entry, name);
+    return entry.client.listTools();
+  }
+  /** Check rate limit before allowing a call to the given server. Throws on exceeded. */
+  checkRateLimitFor(name) {
+    const entry = this.requireServer(name);
+    this.checkRateLimit(entry, name);
+  }
+  /** Record a tool call for rate-limiting purposes. */
+  recordCall(name) {
+    const entry = this.servers.get(name);
+    if (entry) {
+      entry.rateLimit.callTimestamps.push(Date.now());
+    }
+  }
+  // ── Health Checking ─────────────────────────────────────────────────
+  startHealthChecks() {
+    this.stopHealthChecks();
+    this.healthCheckTimer = setInterval(() => {
+      void this.runHealthChecks();
+    }, this.options.healthCheckIntervalMs);
+    if (typeof this.healthCheckTimer === "object" && "unref" in this.healthCheckTimer) {
+      this.healthCheckTimer.unref();
+    }
+  }
+  stopHealthChecks() {
+    if (this.healthCheckTimer !== void 0) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = void 0;
+    }
+  }
+  async runHealthChecks() {
+    for (const [name, entry] of this.servers) {
+      if (entry.status === "stopped") {
+        continue;
+      }
+      try {
+        await entry.client.listTools();
+        entry.status = "connected";
+        entry.consecutiveFailures = 0;
+        entry.lastHealthCheck = Date.now();
+      } catch {
+        entry.consecutiveFailures++;
+        entry.status = "error";
+        logger.warn(
+          { server: name, failures: entry.consecutiveFailures },
+          "MCP health check failed"
+        );
+        if (entry.consecutiveFailures >= this.options.maxConsecutiveFailures) {
+          logger.info({ server: name }, "Attempting MCP server restart");
+          void this.restartServer(name, entry);
+        }
+      }
+    }
+  }
+  async restartServer(name, entry) {
+    try {
+      await entry.client.reconnect();
+      entry.status = "connected";
+      entry.consecutiveFailures = 0;
+      logger.info({ server: name }, "MCP server restarted successfully");
+    } catch (error) {
+      entry.status = "error";
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error({ server: name, error: msg }, "MCP server restart failed");
+    }
+  }
+  // ── Rate Limiting ─────────────────────────────────────────────────
+  checkRateLimit(entry, serverName) {
+    const now = Date.now();
+    const windowStart = now - RATE_LIMIT_WINDOW_MS;
+    entry.rateLimit.callTimestamps = entry.rateLimit.callTimestamps.filter(
+      (ts) => ts > windowStart
+    );
+    if (entry.rateLimit.callTimestamps.length >= entry.rateLimit.maxCallsPerMinute) {
+      throw new ServerConnectionError(
+        serverName,
+        `Rate limit exceeded: ${entry.rateLimit.maxCallsPerMinute} calls/minute`
+      );
+    }
+  }
+  getMaxCallsPerMinute(serverName) {
+    const perServer = this.options.rateLimits?.[serverName];
+    if (perServer) {
+      return perServer.maxCallsPerMinute;
+    }
+    return this.options.defaultRateLimit?.maxCallsPerMinute ?? DEFAULT_MAX_CALLS_PER_MINUTE;
+  }
+  // ── Helpers ───────────────────────────────────────────────────────
+  requireServer(name) {
+    const entry = this.servers.get(name);
+    if (!entry || entry.status !== "connected") {
+      throw new ServerConnectionError(name, "Server not connected");
+    }
+    return entry;
+  }
+};
+
+export { MCPClient, MCPServerManager };
+//# sourceMappingURL=chunk-MFBHNWGV.js.map
+//# sourceMappingURL=chunk-MFBHNWGV.js.map