autohand-cli 0.7.13 → 0.8.0

package/dist/{chunk-BPTBKO7D.js → chunk-SO3QQJAZ.js}

@@ -1,15 +1,23 @@
 import {
-  saveConfig
-} from "./chunk-ZBIBLOZL.js";
+  normalizeMcpCommandForConfig
+} from "./chunk-WQ3VJXZB.js";
 import {
   I18nProvider
-} from "./chunk-BISFR6ZL.js";
+} from "./chunk-EPNYD4NV.js";
+import {
+  loadConfig,
+  saveConfig
+} from "./chunk-WTNBX2JO.js";
+import {
+  PROJECT_DIR_NAME
+} from "./chunk-EGFT4PGW.js";
 import {
   t
-} from "./chunk-NMWEDN4Z.js";
+} from "./chunk-HFMLWH7B.js";
 
 // src/commands/mcp.ts
 import chalk from "chalk";
+import path from "path";
 
 // src/ui/ink/components/McpServerList.tsx
 import { useState, useCallback } from "react";
@@ -155,8 +163,34 @@ async function showMcpServerList(options) {
 }
 
 // src/commands/mcp.ts
+function normalizeMcpScope(scopeInput) {
+  const scope = (scopeInput ?? "user").toLowerCase();
+  if (scope === "user" || scope === "project") {
+    return scope;
+  }
+  return null;
+}
+async function loadConfigForScope(scopeInput, workspaceRoot) {
+  const scope = normalizeMcpScope(scopeInput);
+  if (!scope) {
+    throw new Error(`Invalid scope "${scopeInput}". Use: user or project.`);
+  }
+  if (scope === "user") {
+    return { config: await loadConfig(), scope };
+  }
+  if (!workspaceRoot) {
+    throw new Error("Workspace root is required for project scope.");
+  }
+  const projectConfigPath = path.join(workspaceRoot, PROJECT_DIR_NAME, "config.json");
+  return { config: await loadConfig(projectConfigPath), scope };
+}
+function syncRuntimeConfig(runtimeConfig, updatedConfig) {
+  if (!runtimeConfig) return;
+  if (runtimeConfig.configPath !== updatedConfig.configPath) return;
+  runtimeConfig.mcp = updatedConfig.mcp;
+}
 async function mcp(ctx, args = []) {
-  const { mcpManager, config } = ctx;
+  const { mcpManager, config, workspaceRoot } = ctx;
   if (!mcpManager) {
     return "MCP manager not available.";
   }
@@ -170,10 +204,10 @@ async function mcp(ctx, args = []) {
     case "tools":
       return handleListTools(mcpManager);
     case "add":
-      return handleAdd(mcpManager, config, args.slice(1));
+      return handleAdd(mcpManager, config, args.slice(1), workspaceRoot);
     case "remove":
     case "rm":
-      return handleRemove(mcpManager, config, args.slice(1));
+      return handleRemove(mcpManager, config, args.slice(1), workspaceRoot);
     default:
       return showInteractiveList(mcpManager, config);
   }
@@ -183,7 +217,8 @@ function buildServerItems(manager, config) {
   const items = runtimeServers.map((s) => ({
     name: s.name,
     status: s.status,
-    toolCount: s.toolCount
+    toolCount: s.toolCount,
+    error: s.error
   }));
   const runtimeNames = new Set(runtimeServers.map((s) => s.name));
   const configServers = config?.mcp?.servers ?? [];
@@ -209,7 +244,8 @@ async function showInteractiveList(manager, config) {
     lines.push(t("commands.mcp.noServers"));
     lines.push("");
     lines.push(chalk.gray("Add a server:"));
-    lines.push(chalk.gray("  /mcp add <name> <command> [args...]"));
+    lines.push(chalk.gray("  /mcp add [--scope user|project] <name> <command> [args...]"));
+    lines.push(chalk.gray("  /mcp add --transport http <name> <url>"));
     lines.push("");
     lines.push(chalk.gray("Browse community servers:"));
     lines.push(chalk.gray("  /mcp install"));
@@ -305,64 +341,208 @@ function handleListTools(manager) {
   lines.push(chalk.gray(`Total: ${tools.length} tools from ${byServer.size} servers`));
   return lines.join("\n");
 }
-async function handleAdd(manager, config, args) {
-  if (args.length < 2) {
-    return "Usage: /mcp add <name> <command> [args...]";
+async function handleAdd(manager, config, args, workspaceRoot) {
+  let transport = "stdio";
+  let scopeInput;
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const token = args[i];
+    if (token === "--transport" || token === "-t") {
+      const value = args[i + 1];
+      if (!value) {
+        return "Usage: /mcp add [--transport <stdio|http|sse>] [--scope <user|project>] <name> <command-or-url> [args...]";
+      }
+      const lowered = value.toLowerCase();
+      if (lowered !== "stdio" && lowered !== "http" && lowered !== "sse") {
+        return `Invalid transport "${value}". Use: stdio or http.`;
+      }
+      transport = lowered;
+      i++;
+      continue;
+    }
+    if (token === "--scope" || token === "-s") {
+      const value = args[i + 1];
+      if (!value) {
+        return "Usage: /mcp add [--transport <stdio|http|sse>] [--scope <user|project>] <name> <command-or-url> [args...]";
+      }
+      scopeInput = value;
+      i++;
+      continue;
+    }
+    positional.push(token);
+  }
+  if (positional.length < 2) {
+    return "Usage: /mcp add [--transport <stdio|http|sse>] [--scope <user|project>] <name> <command-or-url> [args...]";
+  }
+  const [name, target, ...serverArgs] = positional;
+  if (transport === "sse") {
+    return "SSE transport is not implemented yet. Use --transport http or stdio.";
+  }
+  if (transport === "http" && serverArgs.length > 0) {
+    return `Transport "${transport}" does not accept extra args. Usage: /mcp add --transport ${transport} <name> <url>`;
+  }
+  let targetConfig = config;
+  let scopeLabel;
+  if (scopeInput) {
+    try {
+      const scoped = await loadConfigForScope(scopeInput, workspaceRoot);
+      targetConfig = scoped.config;
+      scopeLabel = scoped.scope;
+    } catch (error) {
+      return error instanceof Error ? error.message : String(error);
+    }
   }
-  if (!config) {
+  if (!targetConfig) {
     return "Config not available.";
   }
-  const [name, command, ...serverArgs] = args;
-  if (config.mcp?.servers?.some((s) => s.name === name)) {
-    return `Server "${name}" already exists in config. Use /mcp remove first.`;
+  const normalized = normalizeMcpCommandForConfig(
+    target,
+    serverArgs.length > 0 ? serverArgs : void 0
+  );
+  const normalizedCommand = normalized.command ?? target;
+  const normalizedArgs = normalized.args;
+  if (!targetConfig.mcp) {
+    targetConfig.mcp = {};
   }
-  if (!config.mcp) {
-    config.mcp = {};
+  if (!targetConfig.mcp.servers) {
+    targetConfig.mcp.servers = [];
   }
-  if (!config.mcp.servers) {
-    config.mcp.servers = [];
+  const wasMcpDisabled = targetConfig.mcp.enabled === false;
+  if (wasMcpDisabled) {
+    targetConfig.mcp.enabled = true;
   }
-  const newServer = {
+  const newServer = transport === "stdio" ? {
     name,
     transport: "stdio",
-    command,
-    args: serverArgs.length > 0 ? serverArgs : void 0,
+    command: normalizedCommand,
+    args: normalizedArgs,
+    autoConnect: true
+  } : {
+    name,
+    transport: "http",
+    url: target,
     autoConnect: true
   };
-  config.mcp.servers.push(newServer);
+  const displayTarget = transport === "stdio" ? `${normalizedCommand} ${(normalizedArgs ?? []).join(" ")}`.trim() : target;
+  const existing = targetConfig.mcp.servers.find((s) => s.name === name);
+  const scopeSuffix = scopeLabel ? ` in ${scopeLabel} config` : "";
+  if (existing) {
+    const sameConfig = transport === "stdio" ? existing.transport === "stdio" && existing.command === normalizedCommand && JSON.stringify(existing.args) === JSON.stringify(normalizedArgs) : existing.transport === transport && existing.url === target;
+    if (sameConfig) {
+      const wasAutoConnectDisabled = existing.autoConnect === false;
+      if (!wasAutoConnectDisabled && !wasMcpDisabled) {
+        return `Server "${name}" is already configured with the same settings${scopeSuffix}.`;
+      }
+      existing.autoConnect = true;
+      const reenabledParts = [];
+      if (wasMcpDisabled) reenabledParts.push("MCP support");
+      if (wasAutoConnectDisabled) reenabledParts.push("auto-connect");
+      const reenabled = reenabledParts.join(" and ");
+      try {
+        await saveConfig(targetConfig);
+        syncRuntimeConfig(config, targetConfig);
+        try {
+          await manager.connect(existing);
+          const tools = manager.getToolsForServer(name);
+          return `Server "${name}" is already configured${scopeSuffix}. Re-enabled ${reenabled} and connected (${tools.length} tools available).`;
+        } catch (connectError) {
+          return `Server "${name}" is already configured${scopeSuffix}. Re-enabled ${reenabled} but failed to connect: ${connectError instanceof Error ? connectError.message : "Unknown error"}`;
+        }
+      } catch (error) {
+        return `Failed to save config: ${error instanceof Error ? error.message : "Unknown error"}`;
+      }
+    }
+    existing.transport = newServer.transport;
+    if (newServer.transport === "stdio") {
+      existing.command = newServer.command;
+      existing.args = newServer.args;
+      existing.url = void 0;
+    } else {
+      existing.url = newServer.url;
+      existing.command = void 0;
+      existing.args = void 0;
+    }
+    existing.autoConnect = true;
+    try {
+      await saveConfig(targetConfig);
+      syncRuntimeConfig(config, targetConfig);
+      try {
+        await manager.disconnect(name);
+      } catch {
+      }
+      try {
+        await manager.connect(existing);
+        const tools = manager.getToolsForServer(name);
+        return `Updated and reconnected "${name}"${scopeSuffix} (${transport}: ${displayTarget}, ${tools.length} tools available)`;
+      } catch (connectError) {
+        return `Updated "${name}" config${scopeSuffix} but failed to reconnect: ${connectError instanceof Error ? connectError.message : "Unknown error"}`;
+      }
+    } catch (error) {
+      return `Failed to save config: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  }
+  targetConfig.mcp.servers.push(newServer);
   try {
-    await saveConfig(config);
+    await saveConfig(targetConfig);
+    syncRuntimeConfig(config, targetConfig);
     try {
       await manager.connect(newServer);
       const tools = manager.getToolsForServer(name);
-      return `Added and connected to "${name}" (${tools.length} tools available)`;
+      return `Added and connected to "${name}"${scopeSuffix} (${transport}: ${displayTarget}, ${tools.length} tools available)`;
     } catch (connectError) {
-      return `Added "${name}" to config but failed to connect: ${connectError instanceof Error ? connectError.message : "Unknown error"}`;
+      return `Added "${name}" to config${scopeSuffix} but failed to connect: ${connectError instanceof Error ? connectError.message : "Unknown error"}`;
     }
   } catch (error) {
     return `Failed to save config: ${error instanceof Error ? error.message : "Unknown error"}`;
   }
 }
-async function handleRemove(manager, config, args) {
-  const serverName = args[0];
+async function handleRemove(manager, config, args, workspaceRoot) {
+  let scopeInput;
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const token = args[i];
+    if (token === "--scope" || token === "-s") {
+      const value = args[i + 1];
+      if (!value) {
+        return "Usage: /mcp remove [--scope <user|project>] <server-name>";
+      }
+      scopeInput = value;
+      i++;
+      continue;
+    }
+    positional.push(token);
+  }
+  const serverName = positional[0];
   if (!serverName) {
-    return "Usage: /mcp remove <server-name>";
+    return "Usage: /mcp remove [--scope <user|project>] <server-name>";
+  }
+  let targetConfig = config;
+  let scopeLabel;
+  if (scopeInput) {
+    try {
+      const scoped = await loadConfigForScope(scopeInput, workspaceRoot);
+      targetConfig = scoped.config;
+      scopeLabel = scoped.scope;
+    } catch (error) {
+      return error instanceof Error ? error.message : String(error);
+    }
   }
-  if (!config) {
+  if (!targetConfig) {
     return "Config not available.";
   }
-  const serverIndex = config.mcp?.servers?.findIndex((s) => s.name === serverName);
+  const serverIndex = targetConfig.mcp?.servers?.findIndex((s) => s.name === serverName);
   if (serverIndex === void 0 || serverIndex < 0) {
-    return `Server "${serverName}" not found in config.`;
+    return `Server "${serverName}" not found in ${scopeLabel ? `${scopeLabel} config` : "config"}.`;
   }
   try {
     await manager.disconnect(serverName);
   } catch {
   }
-  config.mcp.servers.splice(serverIndex, 1);
+  targetConfig.mcp.servers.splice(serverIndex, 1);
   try {
-    await saveConfig(config);
-    return `Removed "${serverName}" from config`;
+    await saveConfig(targetConfig);
+    syncRuntimeConfig(config, targetConfig);
+    return `Removed "${serverName}" from ${scopeLabel ? `${scopeLabel} config` : "config"}`;
   } catch (error) {
     return `Failed to save config: ${error instanceof Error ? error.message : "Unknown error"}`;
   }