mcp-aws-manager 0.4.3 → 0.4.4

package/bin/mcp-aws-manager.js

@@ -2375,14 +2375,6 @@ function clientHelpAttempts(cliBin) {
   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 +2384,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 +2538,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 +2557,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 +2567,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) {

package/package.json

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