mcp-aws-manager 0.4.6 → 0.4.7

package/bin/mcp-aws-manager.js

@@ -1990,7 +1990,7 @@ function parseDiscoverArgs(argv) {
     outPath: options.outPath ? path.resolve(expandHome(options.outPath)) : (envText("MCP_AWS_OUT") ? path.resolve(expandHome(envText("MCP_AWS_OUT"))) : null),
     noProgress: options.noProgress != null ? options.noProgress : (envNoProgress != null ? envBool("MCP_AWS_NO_PROGRESS") : true)
   };
-}
+}
 
 function validateConfig(config, warnings, requiredActions) {
   if (config.outPath) {
@@ -2421,6 +2421,106 @@ function cursorMcpConfigCandidates() {
   return dedupePaths(candidates);
 }
 
+function claudeMcpConfigCandidates() {
+  const explicitPath = envText("CLAUDE_MCP_CONFIG_PATH");
+  if (explicitPath) {
+    return dedupePaths([path.resolve(explicitPath)]);
+  }
+
+  const home = os.homedir();
+  const candidates = [];
+
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+    candidates.push(path.join(appData, "Claude", "claude_desktop_config.json"));
+  } else if (process.platform === "darwin") {
+    candidates.push(path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"));
+  } else {
+    candidates.push(path.join(home, ".config", "Claude", "claude_desktop_config.json"));
+  }
+
+  candidates.push(path.join(home, ".claude", "claude_desktop_config.json"));
+  return dedupePaths(candidates);
+}
+
+function claudeInstallFootprints() {
+  const home = os.homedir();
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+    return dedupePaths([
+      path.join(appData, "Claude"),
+      path.join(home, ".claude")
+    ]);
+  }
+  if (process.platform === "darwin") {
+    return dedupePaths([
+      path.join(home, "Library", "Application Support", "Claude"),
+      path.join(home, ".claude")
+    ]);
+  }
+  return dedupePaths([
+    path.join(home, ".config", "Claude"),
+    path.join(home, ".claude")
+  ]);
+}
+
+function parseClaudeMcpConfigContent(raw, filePath) {
+  const normalizedRaw = String(raw || "").replace(/^\uFEFF/, "");
+  if (!normalizedRaw.trim()) {
+    return { ok: true, data: { mcpServers: {} } };
+  }
+  try {
+    const parsed = JSON.parse(normalizedRaw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { ok: false, error: `Claude MCP config must be a JSON object. (${filePath})` };
+    }
+    const mcpServers = parsed.mcpServers && typeof parsed.mcpServers === "object" && !Array.isArray(parsed.mcpServers)
+      ? parsed.mcpServers
+      : {};
+    return { ok: true, data: { ...parsed, mcpServers } };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Failed to parse Claude MCP config: ${error && error.message ? error.message : String(error)} (${filePath})`
+    };
+  }
+}
+
+function readClaudeMcpConfig() {
+  const candidates = claudeMcpConfigCandidates();
+  const errors = [];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      const raw = fs.readFileSync(candidate, "utf8");
+      const parsed = parseClaudeMcpConfigContent(raw, candidate);
+      if (!parsed.ok) {
+        errors.push(parsed.error);
+        continue;
+      }
+      return {
+        ok: true,
+        filePath: candidate,
+        exists: true,
+        data: parsed.data,
+        candidates
+      };
+    } catch (error) {
+      errors.push(`Failed to read Claude MCP config: ${error && error.message ? error.message : String(error)} (${candidate})`);
+    }
+  }
+
+  if (errors.length) {
+    return {
+      ok: false,
+      filePath: candidates[0],
+      error: errors.join("; ")
+    };
+  }
+
+  return { ok: true, filePath: candidates[0], exists: false, data: { mcpServers: {} }, candidates };
+}
+
 function cursorMcpConfigPath() {
   const candidates = cursorMcpConfigCandidates();
   for (const candidate of candidates) {
@@ -2509,6 +2609,29 @@ function writeCursorMcpConfig(filePath, data, mirrorPaths = []) {
   return { written, mirrorFailures };
 }
 
+function writeClaudeMcpConfig(filePath, data, mirrorPaths = []) {
+  const allPaths = dedupePaths([filePath, ...(Array.isArray(mirrorPaths) ? mirrorPaths : [])]);
+  const written = [];
+  const mirrorFailures = [];
+
+  for (let i = 0; i < allPaths.length; i += 1) {
+    const currentPath = allPaths[i];
+    try {
+      fs.mkdirSync(path.dirname(currentPath), { recursive: true });
+      fs.writeFileSync(currentPath, JSON.stringify(data, null, 2) + "\n", "utf8");
+      written.push(currentPath);
+    } catch (error) {
+      const message = `${currentPath}: ${error && error.message ? error.message : String(error)}`;
+      if (i === 0) {
+        throw new Error(message);
+      }
+      mirrorFailures.push(message);
+    }
+  }
+
+  return { written, mirrorFailures };
+}
+
 function cursorRegistrationMatches(entry, mcpCommand, mcpArgs = []) {
   if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
   const entryCommand = normalizeComparableText(entry.command);
@@ -2525,6 +2648,22 @@ function cursorRegistrationMatches(entry, mcpCommand, mcpArgs = []) {
   return true;
 }
 
+function claudeRegistrationMatches(entry, mcpCommand, mcpArgs = []) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
+  const entryCommand = normalizeComparableText(entry.command);
+  if (!entryCommand) return false;
+  if (normalizeComparableText(mcpCommand) && entryCommand !== normalizeComparableText(mcpCommand)) {
+    return false;
+  }
+  const expectedArgs = normalizeComparableArgs(mcpArgs);
+  const actualArgs = normalizeComparableArgs(entry.args);
+  if (expectedArgs.length !== actualArgs.length) return false;
+  for (let i = 0; i < expectedArgs.length; i += 1) {
+    if (expectedArgs[i] !== actualArgs[i]) return false;
+  }
+  return true;
+}
+
 function ensureCursorRegistered(serverName, mcpCommand, mcpArgs = [], force = false) {
   const loaded = readCursorMcpConfig();
   if (!loaded.ok) {
@@ -2562,6 +2701,43 @@ function ensureCursorRegistered(serverName, mcpCommand, mcpArgs = [], force = fa
   return { ok: true, action: "already registered", detail: `primary=${loaded.filePath}` };
 }
 
+function ensureClaudeRegistered(serverName, mcpCommand, mcpArgs = [], force = false) {
+  const loaded = readClaudeMcpConfig();
+  if (!loaded.ok) {
+    return { ok: false, action: "claude config invalid", detail: `${loaded.error} (${loaded.filePath})` };
+  }
+  const desiredEntry = {
+    command: String(mcpCommand || ""),
+    args: Array.isArray(mcpArgs) ? mcpArgs.map((arg) => String(arg)) : []
+  };
+  const config = loaded.data;
+  const current = config.mcpServers[serverName];
+  if (force || !claudeRegistrationMatches(current, desiredEntry.command, desiredEntry.args)) {
+    config.mcpServers[serverName] = desiredEntry;
+    try {
+      const mirrors = (loaded.candidates || []).filter(
+        (candidate) => normalizeComparableText(candidate) !== normalizeComparableText(loaded.filePath)
+      );
+      const writeResult = writeClaudeMcpConfig(loaded.filePath, config, mirrors);
+      const detailParts = [`primary=${loaded.filePath}`];
+      if (writeResult.written.length > 1) {
+        detailParts.push(`mirrored=${writeResult.written.slice(1).join(",")}`);
+      }
+      if (writeResult.mirrorFailures.length) {
+        detailParts.push(`mirror_failures=${writeResult.mirrorFailures.join(" | ")}`);
+      }
+      return { ok: true, action: "registered", detail: detailParts.join("; ") };
+    } catch (error) {
+      return {
+        ok: false,
+        action: "claude registration failed",
+        detail: `${error && error.message ? error.message : String(error)} (${loaded.filePath})`
+      };
+    }
+  }
+  return { ok: true, action: "already registered", detail: `primary=${loaded.filePath}` };
+}
+
 function removeCursorRegistration(serverName) {
   const loaded = readCursorMcpConfig();
   if (!loaded.ok || !loaded.exists) return;
@@ -2577,6 +2753,21 @@ function removeCursorRegistration(serverName) {
   }
 }
 
+function removeClaudeRegistration(serverName) {
+  const loaded = readClaudeMcpConfig();
+  if (!loaded.ok || !loaded.exists) return;
+  if (!Object.prototype.hasOwnProperty.call(loaded.data.mcpServers, serverName)) return;
+  delete loaded.data.mcpServers[serverName];
+  try {
+    const mirrors = (loaded.candidates || []).filter(
+      (candidate) => normalizeComparableText(candidate) !== normalizeComparableText(loaded.filePath)
+    );
+    writeClaudeMcpConfig(loaded.filePath, loaded.data, mirrors);
+  } catch (_) {
+    // ignore best-effort cleanup
+  }
+}
+
 function isCursorRegistered(serverName, mcpCommand, mcpArgs = []) {
   const candidates = cursorMcpConfigCandidates();
   for (const candidate of candidates) {
@@ -2596,6 +2787,25 @@ function isCursorRegistered(serverName, mcpCommand, mcpArgs = []) {
   return false;
 }
 
+function isClaudeRegistered(serverName, mcpCommand, mcpArgs = []) {
+  const candidates = claudeMcpConfigCandidates();
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      const raw = fs.readFileSync(candidate, "utf8");
+      const parsed = parseClaudeMcpConfigContent(raw, candidate);
+      if (!parsed.ok) continue;
+      const entry = parsed.data && parsed.data.mcpServers ? parsed.data.mcpServers[serverName] : null;
+      if (claudeRegistrationMatches(entry, mcpCommand, mcpArgs)) {
+        return true;
+      }
+    } catch (_) {
+      continue;
+    }
+  }
+  return false;
+}
+
 function clientGetAttempts(cliBin, serverName) {
   if (cliBin === "claude") {
     return [
@@ -2662,23 +2872,34 @@ function clientAddAttempts(cliBin, serverName, mcpCommand, mcpArgs = []) {
   ];
 }
 
-function removeRegistration(cliBin, serverName) {
+function removeRegistration(cliBin, serverName, options = {}) {
+  const mode = options && options.mode ? String(options.mode) : "cli";
   if (cliBin === "cursor") {
     removeCursorRegistration(serverName);
     return;
   }
+  if (cliBin === "claude" && mode === "config") {
+    removeClaudeRegistration(serverName);
+    return;
+  }
   const attempts = clientRemoveAttempts(cliBin, serverName);
   for (const args of attempts) {
     runCLICommand(cliBin, args, { stdio: "ignore" });
   }
 }
 
-function isRegistered(cliBin, serverName, target = null) {
+function isRegistered(cliBin, serverName, target = null, options = {}) {
+  const mode = options && options.mode ? String(options.mode) : "cli";
   if (cliBin === "cursor") {
     const mcpCommand = target && target.mcpCommand ? target.mcpCommand : "";
     const mcpArgs = target && Array.isArray(target.mcpArgs) ? target.mcpArgs : [];
     return isCursorRegistered(serverName, mcpCommand, mcpArgs);
   }
+  if (cliBin === "claude" && mode === "config") {
+    const mcpCommand = target && target.mcpCommand ? target.mcpCommand : "";
+    const mcpArgs = target && Array.isArray(target.mcpArgs) ? target.mcpArgs : [];
+    return isClaudeRegistered(serverName, mcpCommand, mcpArgs);
+  }
   const attempts = clientGetAttempts(cliBin, serverName);
   for (const args of attempts) {
     const run = runCLICommand(cliBin, args, { stdio: "ignore" });
@@ -2719,7 +2940,26 @@ function detectClientAvailability(clients) {
     : Array.from(SUPPORTED_CLIENTS);
   return candidateClients.map((cliBin) => {
     const exists = clientHelpAttempts(cliBin).some((args) => commandExists(cliBin, args));
-    return { cliBin, exists };
+    if (exists) return { cliBin, exists: true, mode: "cli", detail: "" };
+    if (cliBin !== "claude") return { cliBin, exists: false, mode: "cli", detail: "" };
+
+    const explicitConfigPath = envText("CLAUDE_MCP_CONFIG_PATH");
+    if (explicitConfigPath) {
+      return { cliBin, exists: true, mode: "config", detail: `CLAUDE_MCP_CONFIG_PATH=${path.resolve(explicitConfigPath)}` };
+    }
+
+    const config = readClaudeMcpConfig();
+    if (config.ok && config.exists) {
+      return { cliBin, exists: true, mode: "config", detail: `config=${config.filePath}` };
+    }
+
+    for (const footprint of claudeInstallFootprints()) {
+      if (fs.existsSync(footprint)) {
+        return { cliBin, exists: true, mode: "config", detail: `footprint=${footprint}` };
+      }
+    }
+
+    return { cliBin, exists: false, mode: "cli", detail: "" };
   });
 }
 
@@ -2731,7 +2971,8 @@ function runSetupInternal(config, options = {}) {
     : [defaultTarget];
   const clientsExplicit = config && config.clientsExplicit === true;
   const availability = detectClientAvailability(config.clients);
-  const clients = availability.filter((row) => row.exists).map((row) => row.cliBin);
+  const activeClients = availability.filter((row) => row.exists);
+  const clients = activeClients.map((row) => row.cliBin);
   const missingClients = availability.filter((row) => !row.exists).map((row) => row.cliBin);
   const results = [];
   const commandChecks = targets.map((target) => ({
@@ -2774,7 +3015,9 @@ function runSetupInternal(config, options = {}) {
     return 2;
   }
 
-  for (const cliBin of clients) {
+  for (const clientInfo of activeClients) {
+    const cliBin = clientInfo.cliBin;
+    const mode = clientInfo.mode || "cli";
     if (EDITOR_STYLE_CLIENTS.has(String(cliBin || "").toLowerCase()) && cliBin !== "cursor") {
       for (const target of activeTargets) {
         results.push({
@@ -2789,9 +3032,9 @@ function runSetupInternal(config, options = {}) {
     }
 
     for (const target of activeTargets) {
-      const alreadyRegistered = isRegistered(cliBin, target.serverName, target);
+      const alreadyRegistered = isRegistered(cliBin, target.serverName, target, { mode });
       if (config.force || !ensureOnly || alreadyRegistered) {
-        removeRegistration(cliBin, target.serverName);
+        removeRegistration(cliBin, target.serverName, { mode });
       }
 
       if (cliBin === "cursor") {
@@ -2819,6 +3062,31 @@ function runSetupInternal(config, options = {}) {
         continue;
       }
 
+      if (cliBin === "claude" && mode === "config") {
+        const registered = ensureClaudeRegistered(target.serverName, target.mcpCommand, target.mcpArgs || [], config.force);
+        if (registered.ok) {
+          const action = ensureOnly
+            ? (alreadyRegistered ? "updated" : "registered")
+            : (alreadyRegistered ? "re-registered" : "registered");
+          results.push({
+            cliBin,
+            serverName: target.serverName,
+            ok: true,
+            action: `${action} (claude config)`,
+            detail: registered.detail || ""
+          });
+        } else {
+          results.push({
+            cliBin,
+            serverName: target.serverName,
+            ok: false,
+            action: registered.action || "registration failed",
+            detail: registered.detail || "unknown"
+          });
+        }
+        continue;
+      }
+
       const registered = tryRegister(cliBin, target.serverName, target.mcpCommand, target.mcpArgs || []);
       if (registered.ok) {
         const action = ensureOnly
@@ -2837,7 +3105,7 @@ function runSetupInternal(config, options = {}) {
 
   for (const row of results) {
     process.stdout.write(`${row.cliBin}/${row.serverName}: ${row.action}\n`);
-    if (row.detail && (!row.ok || /\bcursor mcp\.json\b/i.test(String(row.action || "")))) {
+    if (row.detail && (!row.ok || /\b(cursor mcp\.json|claude config)\b/i.test(String(row.action || "")))) {
       process.stdout.write(`  detail: ${row.detail}\n`);
     }
   }
@@ -2874,6 +3142,7 @@ function runDoctor(config) {
 
   for (const row of availability) {
     const cliBin = row.cliBin;
+    const mode = row.mode || "cli";
     if (!row.exists) {
       if (clientsExplicit) {
         hasIssue = true;
@@ -2893,12 +3162,12 @@ function runDoctor(config) {
     }
 
     for (const target of targets) {
-      const registered = isRegistered(cliBin, target.serverName, target);
+      const registered = isRegistered(cliBin, target.serverName, target, { mode });
       if (registered) {
-        process.stdout.write(`${cliBin}: registered (${target.serverName})\n`);
+        process.stdout.write(`${cliBin}: registered (${target.serverName}${mode === "config" ? ", config mode" : ""})\n`);
       } else {
         hasIssue = true;
-        process.stdout.write(`${cliBin}: missing registration (${target.serverName})\n`);
+        process.stdout.write(`${cliBin}: missing registration (${target.serverName}${mode === "config" ? ", config mode" : ""})\n`);
         const action = `mcp-aws-manager setup --clients ${cliBin}`;
         process.stdout.write(`  action: ${action}\n`);
       }
@@ -12522,4 +12791,4 @@ async function main() {
 
 if (require.main === module) {
   void main();
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-aws-manager",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "AWS operations CLI and MCP server (SSM-only) for EC2/Lambda inventory, remediation, and runtime snapshots",
   "license": "MIT",
   "publishConfig": {