mcp-aws-manager 0.4.3 → 0.4.5

package/README.md

@@ -179,6 +179,10 @@ mcp-aws-manager setup --clients claude
 
 Default behavior (`setup`/`bootstrap` without `--clients`) auto-detects installed clients and registers only detected CLIs.
 
+Compatibility note:
+- Cursor is registered through MCP config file sync (`~/.cursor/mcp.json` and platform user config path) to avoid editor tab side effects from `cursor mcp ...`.
+- If another editor-style client does not expose stable CLI `mcp` subcommands, `setup`/`doctor` returns `manual configuration required` instead of running unsafe subcommands.
+
 2. Health check:
 
 ```bash

package/README_KO.md

@@ -178,6 +178,10 @@ mcp-aws-manager setup --clients claude
 
 기본 동작(`--clients` 없이 `setup`/`bootstrap`)은 설치된 클라이언트를 자동 감지해, 감지된 CLI만 등록합니다.
 
+호환성 참고:
+- Cursor는 `cursor mcp ...` 호출 부작용(편집기 탭 열림)을 피하기 위해 MCP 설정 파일(`~/.cursor/mcp.json` + 플랫폼 사용자 설정 경로) 동기화 방식으로 등록합니다.
+- 다른 에디터형 클라이언트가 안정적인 CLI `mcp` 하위명령을 제공하지 않으면, `setup`/`doctor`는 위험한 하위명령 실행 대신 `manual configuration required`를 반환합니다.
+
 2. 상태 점검:
 
 ```bash

package/bin/mcp-aws-manager.js

@@ -61,6 +61,7 @@ const DEFAULT_GOVERNANCE_LOG_NAME = "mcp-aws-governance-log.jsonl";
 const DEFAULT_INCIDENT_REPORT_NAME = "incident-escalation.json";
 const DEFAULT_ENTERPRISE_POLICY_NAME = "enterprise-policy.json";
 const SUPPORTED_CLIENTS = new Set(["codex", "claude", "cursor", "windsurf", "antigravity"]);
+const EDITOR_STYLE_CLIENTS = new Set(["cursor", "windsurf", "antigravity"]);
 const INTERNAL_BACKEND_ID = "internal";
 const AUTH_MODES = Object.freeze(["auto", "profile", "web-identity"]);
 const SNAPSHOT_PROFILES = Object.freeze({
@@ -2311,13 +2312,14 @@ function listLocalAwsProfiles() {
 }
 
 function runCLICommand(cliBin, args, options = {}) {
-  // Cursor 2.x no longer reliably supports `cursor mcp ...` CLI subcommands.
+  // Some editor-style CLIs no longer reliably support `<cli> mcp ...`.
   // Calling it can open editor tabs named like "mcp", "add", "get".
-  if (String(cliBin).toLowerCase() === "cursor" && Array.isArray(args) && String(args[0] || "").toLowerCase() === "mcp") {
+  const normalizedCli = String(cliBin || "").toLowerCase();
+  if (EDITOR_STYLE_CLIENTS.has(normalizedCli) && Array.isArray(args) && String(args[0] || "").toLowerCase() === "mcp") {
     return {
       status: 2,
       stdout: "",
-      stderr: "cursor mcp subcommand is disabled; use ~/.cursor/mcp.json registration"
+      stderr: `${normalizedCli} mcp subcommand is disabled in automation mode; use client MCP settings registration`
     };
   }
 
@@ -2361,28 +2363,14 @@ function commandExists(bin, checkArgs) {
 }
 
 function clientHelpAttempts(cliBin) {
-  if (cliBin === "cursor") {
-    return [
-      ["--help"]
-    ];
-  }
-  if (cliBin === "windsurf" || cliBin === "antigravity") {
+  if (EDITOR_STYLE_CLIENTS.has(String(cliBin || "").toLowerCase())) {
     return [
-      ["mcp", "--help"],
       ["--help"]
     ];
   }
   return [["mcp", "--help"]];
 }
 
-function cursorMcpConfigPath() {
-  const explicitPath = envText("CURSOR_MCP_CONFIG_PATH");
-  if (explicitPath) {
-    return path.resolve(explicitPath);
-  }
-  return path.join(os.homedir(), ".cursor", "mcp.json");
-}
-
 function normalizeComparableText(value) {
   const text = String(value == null ? "" : value).trim();
   return process.platform === "win32" ? text.toLowerCase() : text;
@@ -2392,37 +2380,128 @@ function normalizeComparableArgs(args) {
   return Array.isArray(args) ? args.map((arg) => normalizeComparableText(arg)) : [];
 }
 
-function readCursorMcpConfig() {
-  const filePath = cursorMcpConfigPath();
-  if (!fs.existsSync(filePath)) {
-    return { ok: true, filePath, exists: false, data: { mcpServers: {} } };
+function dedupePaths(paths) {
+  const seen = new Set();
+  const out = [];
+  for (const candidate of paths) {
+    const resolved = path.resolve(String(candidate || ""));
+    const key = normalizeComparableText(resolved);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(resolved);
+  }
+  return out;
+}
+
+function cursorMcpConfigCandidates() {
+  const explicitPath = envText("CURSOR_MCP_CONFIG_PATH");
+  if (explicitPath) {
+    return dedupePaths([path.resolve(explicitPath)]);
+  }
+
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, ".cursor", "mcp.json")
+  ];
+
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+    candidates.push(path.join(appData, "Cursor", "User", "mcp.json"));
+  } else if (process.platform === "darwin") {
+    candidates.push(path.join(home, "Library", "Application Support", "Cursor", "User", "mcp.json"));
+  } else {
+    candidates.push(path.join(home, ".config", "Cursor", "User", "mcp.json"));
+  }
+
+  return dedupePaths(candidates);
+}
+
+function cursorMcpConfigPath() {
+  const candidates = cursorMcpConfigCandidates();
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return candidates[0];
+}
+
+function parseCursorMcpConfigContent(raw, filePath) {
+  const normalizedRaw = String(raw || "").replace(/^\uFEFF/, "");
+  if (!normalizedRaw.trim()) {
+    return { ok: true, data: { mcpServers: {} } };
   }
   try {
-    const raw = fs.readFileSync(filePath, "utf8");
-    const normalizedRaw = raw.replace(/^\uFEFF/, "");
-    if (!normalizedRaw.trim()) {
-      return { ok: true, filePath, exists: true, data: { mcpServers: {} } };
-    }
     const parsed = JSON.parse(normalizedRaw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return { ok: false, filePath, error: "Cursor MCP config must be a JSON object." };
+      return { ok: false, error: `Cursor 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, filePath, exists: true, data: { ...parsed, mcpServers } };
+    return { ok: true, data: { ...parsed, mcpServers } };
   } catch (error) {
     return {
       ok: false,
-      filePath,
-      error: `Failed to parse Cursor MCP config: ${error && error.message ? error.message : String(error)}`
+      error: `Failed to parse Cursor MCP config: ${error && error.message ? error.message : String(error)} (${filePath})`
+    };
+  }
+}
+
+function readCursorMcpConfig() {
+  const candidates = cursorMcpConfigCandidates();
+  const errors = [];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      const raw = fs.readFileSync(candidate, "utf8");
+      const parsed = parseCursorMcpConfigContent(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 Cursor 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 writeCursorMcpConfig(filePath, data) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf8");
+function writeCursorMcpConfig(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 = []) {
@@ -2455,7 +2534,18 @@ function ensureCursorRegistered(serverName, mcpCommand, mcpArgs = [], force = fa
   if (force || !cursorRegistrationMatches(current, desiredEntry.command, desiredEntry.args)) {
     config.mcpServers[serverName] = desiredEntry;
     try {
-      writeCursorMcpConfig(loaded.filePath, config);
+      const mirrors = (loaded.candidates || []).filter(
+        (candidate) => normalizeComparableText(candidate) !== normalizeComparableText(loaded.filePath)
+      );
+      const writeResult = writeCursorMcpConfig(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,
@@ -2463,9 +2553,8 @@ function ensureCursorRegistered(serverName, mcpCommand, mcpArgs = [], force = fa
         detail: `${error && error.message ? error.message : String(error)} (${loaded.filePath})`
       };
     }
-    return { ok: true, action: "registered", detail: loaded.filePath };
   }
-  return { ok: true, action: "already registered", detail: loaded.filePath };
+  return { ok: true, action: "already registered", detail: `primary=${loaded.filePath}` };
 }
 
 function removeCursorRegistration(serverName) {
@@ -2474,17 +2563,32 @@ function removeCursorRegistration(serverName) {
   if (!Object.prototype.hasOwnProperty.call(loaded.data.mcpServers, serverName)) return;
   delete loaded.data.mcpServers[serverName];
   try {
-    writeCursorMcpConfig(loaded.filePath, loaded.data);
+    const mirrors = (loaded.candidates || []).filter(
+      (candidate) => normalizeComparableText(candidate) !== normalizeComparableText(loaded.filePath)
+    );
+    writeCursorMcpConfig(loaded.filePath, loaded.data, mirrors);
   } catch (_) {
     // ignore best-effort cleanup
   }
 }
 
 function isCursorRegistered(serverName, mcpCommand, mcpArgs = []) {
-  const loaded = readCursorMcpConfig();
-  if (!loaded.ok) return false;
-  const entry = loaded.data && loaded.data.mcpServers ? loaded.data.mcpServers[serverName] : null;
-  return cursorRegistrationMatches(entry, mcpCommand, mcpArgs);
+  const candidates = cursorMcpConfigCandidates();
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      const raw = fs.readFileSync(candidate, "utf8");
+      const parsed = parseCursorMcpConfigContent(raw, candidate);
+      if (!parsed.ok) continue;
+      const entry = parsed.data && parsed.data.mcpServers ? parsed.data.mcpServers[serverName] : null;
+      if (cursorRegistrationMatches(entry, mcpCommand, mcpArgs)) {
+        return true;
+      }
+    } catch (_) {
+      continue;
+    }
+  }
+  return false;
 }
 
 function clientGetAttempts(cliBin, serverName) {
@@ -2666,6 +2770,19 @@ function runSetupInternal(config, options = {}) {
   }
 
   for (const cliBin of clients) {
+    if (EDITOR_STYLE_CLIENTS.has(String(cliBin || "").toLowerCase()) && cliBin !== "cursor") {
+      for (const target of activeTargets) {
+        results.push({
+          cliBin,
+          serverName: target.serverName,
+          ok: false,
+          action: "manual configuration required",
+          detail: `${cliBin} CLI mcp subcommands are unavailable in automation mode; configure MCP server in ${cliBin} client settings`
+        });
+      }
+      continue;
+    }
+
     for (const target of activeTargets) {
       const alreadyRegistered = isRegistered(cliBin, target.serverName, target);
       if (config.force || !ensureOnly || alreadyRegistered) {
@@ -2763,6 +2880,13 @@ function runDoctor(config) {
     }
 
     foundClient = true;
+    if (EDITOR_STYLE_CLIENTS.has(String(cliBin || "").toLowerCase()) && cliBin !== "cursor") {
+      hasIssue = true;
+      process.stdout.write(`${cliBin}: manual MCP configuration required\n`);
+      process.stdout.write(`  action: register mcp-aws-manager in ${cliBin} settings (CLI mcp subcommands unavailable)\n`);
+      continue;
+    }
+
     for (const target of targets) {
       const registered = isRegistered(cliBin, target.serverName, target);
       if (registered) {

package/package.json

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