@memoraone/mcp 0.1.27 → 0.1.29

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.27",
+      version: "0.1.29",
       type: "module",
       main: "dist/index.cjs",
       bin: {
@@ -67,9 +67,9 @@ var require_package = __commonJS({
 });
 
 // src/cli.ts
-var path5 = __toESM(require("path"), 1);
+var path6 = __toESM(require("path"), 1);
 var net = __toESM(require("net"), 1);
-var import_node_child_process2 = require("child_process");
+var import_node_child_process3 = require("child_process");
 
 // src/socketPaths.ts
 var os = __toESM(require("os"), 1);
@@ -292,8 +292,8 @@ function encodeResolvedBinding(binding) {
 }
 
 // src/setupIdeFiles.ts
-var fs4 = __toESM(require("fs/promises"), 1);
-var path4 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs/promises"), 1);
+var path5 = __toESM(require("path"), 1);
 
 // src/cleanup.ts
 var fs3 = __toESM(require("fs/promises"), 1);
@@ -685,27 +685,236 @@ async function cliCleanup(argv) {
   return result.exitCode;
 }
 
+// src/cursorGlobalMcpConfig.ts
+var fs4 = __toESM(require("fs/promises"), 1);
+var os2 = __toESM(require("os"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+function buildMemoraoneCursorMcpServer(npxPath) {
+  return {
+    command: npxPath,
+    args: ["-y", "@memoraone/mcp@latest"],
+    env: {
+      MEMORAONE_API_URL: "https://api.memoraone.com",
+      MEMORAONE_IDE_TYPE: "cursor"
+    }
+  };
+}
+async function pathExists(filePath) {
+  try {
+    await fs4.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stripLeadingLineComments(text) {
+  return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
+}
+function getKnownCursorGlobalMcpConfigCandidates(homeDir) {
+  return [path4.join(homeDir, ".cursor", "mcp.json")];
+}
+async function detectCursorGlobalMcpConfig(options) {
+  if (options?.explicitPath) {
+    return { ok: true, path: options.explicitPath, detectedExisting: await pathExists(options.explicitPath) };
+  }
+  const homeDir = options?.homeDir ?? os2.homedir();
+  const candidates = getKnownCursorGlobalMcpConfigCandidates(homeDir);
+  const existing = [];
+  for (const candidate of candidates) {
+    if (await pathExists(candidate)) existing.push(candidate);
+  }
+  if (existing.length > 1) {
+    return {
+      ok: false,
+      error: "[setup-ide-files] Multiple Cursor global MCP config paths found. Specify one explicitly.",
+      candidates: existing
+    };
+  }
+  if (existing.length === 1) {
+    return { ok: true, path: existing[0], detectedExisting: true };
+  }
+  const defaultPath = candidates[0];
+  if (!defaultPath) {
+    return {
+      ok: false,
+      error: "[setup-ide-files] No known Cursor global MCP config path.",
+      candidates: []
+    };
+  }
+  return { ok: true, path: defaultPath, detectedExisting: false };
+}
+function formatBackupTimestamp(d = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+async function isWorkingNpx(npxPath) {
+  try {
+    if (!await pathExists(npxPath)) return false;
+    if (process.platform !== "win32") {
+      try {
+        await fs4.access(npxPath, fs4.constants.X_OK);
+      } catch {
+        return false;
+      }
+    }
+    await execFileAsync2(npxPath, ["--version"], { timeout: 1e4 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveNpxPath() {
+  const npxName = process.platform === "win32" ? "npx.cmd" : "npx";
+  const candidates = [];
+  if (process.platform === "darwin") {
+    candidates.push("/opt/homebrew/bin/npx", "/usr/local/bin/npx");
+  } else if (process.platform === "linux") {
+    candidates.push("/usr/local/bin/npx");
+  }
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  for (const dir of (process.env.PATH ?? "").split(pathSep)) {
+    if (!dir) continue;
+    candidates.push(path4.join(dir, npxName));
+  }
+  try {
+    const lookupCmd = process.platform === "win32" ? "where" : "which";
+    const { stdout } = await execFileAsync2(lookupCmd, [npxName], { timeout: 5e3 });
+    const first = stdout.trim().split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+    if (first) candidates.unshift(first);
+  } catch {
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const abs = path4.isAbsolute(candidate) ? candidate : path4.resolve(candidate);
+    const key = process.platform === "win32" ? abs.toLowerCase() : abs;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (await isWorkingNpx(abs)) return abs;
+  }
+  return null;
+}
+function mergeCursorGlobalMcpConfigObject(existing, npxPath) {
+  const base = existing && typeof existing === "object" ? { ...existing } : { mcpServers: {} };
+  const mcpServers = typeof base.mcpServers === "object" && base.mcpServers !== null && !Array.isArray(base.mcpServers) ? { ...base.mcpServers } : {};
+  mcpServers.memoraone = buildMemoraoneCursorMcpServer(npxPath);
+  return { ...base, mcpServers };
+}
+function memoraoneServerMatches(server, npxPath) {
+  if (!server || typeof server !== "object") return false;
+  const s = server;
+  if (s.command !== npxPath) return false;
+  if (!Array.isArray(s.args) || s.args.length !== 2) return false;
+  if (s.args[0] !== "-y" || s.args[1] !== "@memoraone/mcp@latest") return false;
+  const env = s.env;
+  if (!env || typeof env !== "object") return false;
+  const e = env;
+  return e.MEMORAONE_API_URL === "https://api.memoraone.com" && e.MEMORAONE_IDE_TYPE === "cursor";
+}
+function validateCursorGlobalMcpConfig(parsed, npxPath) {
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("[setup-ide-files] Cursor global MCP config must be a JSON object.");
+  }
+  const mcpServers = parsed.mcpServers;
+  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    throw new Error("[setup-ide-files] Cursor global MCP config missing mcpServers object.");
+  }
+  const memoraone = mcpServers.memoraone;
+  if (!memoraoneServerMatches(memoraone, npxPath)) {
+    throw new Error(
+      "[setup-ide-files] Cursor global MCP config mcpServers.memoraone is missing or invalid."
+    );
+  }
+}
+async function setupCursorGlobalMcpConfig(options) {
+  const { configPath, npxPath, dryRun } = options;
+  const existed = await pathExists(configPath);
+  let existing = null;
+  if (existed) {
+    const raw = await fs4.readFile(configPath, "utf8");
+    try {
+      existing = JSON.parse(stripLeadingLineComments(raw));
+    } catch {
+      throw new Error(
+        `[setup-ide-files] Invalid JSON in Cursor global MCP config: ${configPath}`
+      );
+    }
+  }
+  const merged = mergeCursorGlobalMcpConfigObject(existing, npxPath);
+  const body = JSON.stringify(merged, null, 2) + "\n";
+  if (existed) {
+    const currentMemoraone = existing && typeof existing.mcpServers === "object" && existing.mcpServers !== null && !Array.isArray(existing.mcpServers) ? existing.mcpServers.memoraone : void 0;
+    if (memoraoneServerMatches(currentMemoraone, npxPath)) {
+      return { outcome: "skipped" };
+    }
+  }
+  if (dryRun) {
+    return { outcome: existed ? "updated" : "created" };
+  }
+  let backupPath;
+  if (existed) {
+    backupPath = `${configPath}.backup-${formatBackupTimestamp()}`;
+    await fs4.copyFile(configPath, backupPath);
+  }
+  await fs4.mkdir(path4.dirname(configPath), { recursive: true });
+  await fs4.writeFile(configPath, body, "utf8");
+  const verifyRaw = await fs4.readFile(configPath, "utf8");
+  const verifyParsed = JSON.parse(stripLeadingLineComments(verifyRaw));
+  validateCursorGlobalMcpConfig(verifyParsed, npxPath);
+  return { outcome: existed ? "updated" : "created", backupPath };
+}
+function logCursorGlobalMcpCliSummary(info, dryRun) {
+  const { configPath, npxPath, backupPath, outcome } = info;
+  console.log(`[setup-ide-files] Cursor global MCP config: ${configPath}`);
+  console.log(`[setup-ide-files] Resolved npx: ${npxPath}`);
+  if (backupPath) {
+    console.log(`[setup-ide-files] Cursor global MCP config backup: ${backupPath}`);
+  }
+  if (outcome === "created") {
+    console.log(
+      dryRun ? `[setup-ide-files] Cursor global MCP config would be created: ${configPath}` : `[setup-ide-files] Cursor global MCP config created: ${configPath}`
+    );
+  } else if (outcome === "updated") {
+    console.log(
+      dryRun ? `[setup-ide-files] Cursor global MCP config would be updated: ${configPath}` : `[setup-ide-files] Cursor global MCP config updated: ${configPath}`
+    );
+  } else if (outcome === "skipped") {
+    console.log(`[setup-ide-files] Cursor global MCP config unchanged: ${configPath}`);
+  }
+  console.log(
+    "[setup-ide-files] Repo-level .cursor/mcp.json was not created or modified."
+  );
+  console.log(
+    "[setup-ide-files] Fully quit Cursor and reopen this repo for MCP changes to take effect."
+  );
+}
+
 // src/setupIdeFiles.ts
 var MANAGED_MARKER = "<!-- MemoraOne managed IDE helper -->";
 var GITIGNORE_MEMORAONE_COMMENT = "# MemoraOne local project binding / API key";
 var GITIGNORE_MEMORAONE_ENTRY = "memoraone.m1";
-var MEMORAONE_MCP_SERVER = {
-  command: "npx",
-  args: ["-y", "@memoraone/mcp@latest"],
-  env: {
-    MEMORAONE_API_URL: "https://api.memoraone.com"
-  }
-};
+function buildMemoraoneMcpServer(ideType, command = "npx") {
+  return {
+    command,
+    args: ["-y", "@memoraone/mcp@latest"],
+    env: {
+      MEMORAONE_API_URL: "https://api.memoraone.com",
+      MEMORAONE_IDE_TYPE: ideType
+    }
+  };
+}
 function assertUnderRepoRoot(repoRoot, absPath) {
-  const normRoot = path4.resolve(repoRoot) + path4.sep;
-  const normPath = path4.resolve(absPath);
-  if (normPath !== path4.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
+  const normRoot = path5.resolve(repoRoot) + path5.sep;
+  const normPath = path5.resolve(absPath);
+  if (normPath !== path5.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
     throw new Error(`[setup-ide-files] Refusing to write outside repo root: ${absPath}`);
   }
 }
-async function pathExists(filePath) {
+async function pathExists2(filePath) {
   try {
-    await fs4.access(filePath);
+    await fs5.access(filePath);
     return true;
   } catch {
     return false;
@@ -726,12 +935,12 @@ ${GITIGNORE_MEMORAONE_ENTRY}
 }
 async function ensureGitignoreMemoraone(repoRoot, opts) {
   if (opts.noGitignore) return "skipped";
-  const abs = path4.join(repoRoot, ".gitignore");
+  const abs = path5.join(repoRoot, ".gitignore");
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs4.readFile(abs, "utf8");
+    prior = await fs5.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
@@ -742,25 +951,25 @@ async function ensureGitignoreMemoraone(repoRoot, opts) {
   const separator = existed && prior.length > 0 ? prior.endsWith("\n") ? "\n" : "\n\n" : "";
   const next = (existed ? prior : "") + separator + block;
   if (opts.dryRun) return existed ? "updated" : "created";
-  await fs4.writeFile(abs, next, "utf8");
+  await fs5.writeFile(abs, next, "utf8");
   return existed ? "updated" : "created";
 }
 async function findRepoRoot(startDir) {
-  let current = path4.resolve(startDir);
-  const root = path4.parse(current).root;
+  let current = path5.resolve(startDir);
+  const root = path5.parse(current).root;
   while (true) {
-    const gitPath = path4.join(current, ".git");
-    const m1Path = path4.join(current, "memoraone.m1");
-    if (await pathExists(gitPath) || await pathExists(m1Path)) {
+    const gitPath = path5.join(current, ".git");
+    const m1Path = path5.join(current, "memoraone.m1");
+    if (await pathExists2(gitPath) || await pathExists2(m1Path)) {
       return current;
     }
     if (current === root) {
       return null;
     }
-    current = path4.dirname(current);
+    current = path5.dirname(current);
   }
 }
-function stripLeadingLineComments(text) {
+function stripLeadingLineComments2(text) {
   return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
 }
 function cursorRuleBody() {
@@ -803,75 +1012,75 @@ function mcpJsonHeader() {
   return `// ${MANAGED_MARKER}
 `;
 }
-function buildMcpJsonBody(existing) {
+function buildVscodeMcpJsonBody(existing) {
   const base = existing && typeof existing === "object" ? { ...existing } : { servers: {} };
   const servers = typeof base.servers === "object" && base.servers !== null && !Array.isArray(base.servers) ? { ...base.servers } : {};
-  servers.memoraone = { ...MEMORAONE_MCP_SERVER };
+  servers.memoraone = buildMemoraoneMcpServer("copilot-vscode");
   const merged = { ...base, servers };
   return mcpJsonHeader() + JSON.stringify(merged, null, 2) + "\n";
 }
 async function writeManagedMarkdown(repoRoot, relPath, fullContent, opts) {
-  const abs = path4.join(repoRoot, relPath);
+  const abs = path5.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs4.readFile(abs, "utf8");
+    prior = await fs5.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
   if (!existed) {
     if (opts.dryRun) return "created";
-    await fs4.mkdir(path4.dirname(abs), { recursive: true });
-    await fs4.writeFile(abs, fullContent, "utf8");
+    await fs5.mkdir(path5.dirname(abs), { recursive: true });
+    await fs5.writeFile(abs, fullContent, "utf8");
     return "created";
   }
   if (prior.includes(MANAGED_MARKER)) {
     if (prior === fullContent) return "skipped";
     if (opts.dryRun) return "updated";
-    await fs4.mkdir(path4.dirname(abs), { recursive: true });
-    await fs4.writeFile(abs, fullContent, "utf8");
+    await fs5.mkdir(path5.dirname(abs), { recursive: true });
+    await fs5.writeFile(abs, fullContent, "utf8");
     return "updated";
   }
   if (!opts.force) return "skipped-untracked";
   if (opts.dryRun) return "updated";
-  await fs4.mkdir(path4.dirname(abs), { recursive: true });
-  await fs4.writeFile(abs, fullContent, "utf8");
+  await fs5.mkdir(path5.dirname(abs), { recursive: true });
+  await fs5.writeFile(abs, fullContent, "utf8");
   return "updated";
 }
-async function writeMcpJson(repoRoot, opts) {
-  const abs = path4.join(repoRoot, ".vscode/mcp.json");
+async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
+  const abs = path5.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let raw = "";
   let existed = false;
   try {
-    raw = await fs4.readFile(abs, "utf8");
+    raw = await fs5.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
   if (!existed) {
-    const body = buildMcpJsonBody(null);
+    const body = buildBody(null);
     if (opts.dryRun) return "created";
-    await fs4.mkdir(path4.dirname(abs), { recursive: true });
-    await fs4.writeFile(abs, body, "utf8");
+    await fs5.mkdir(path5.dirname(abs), { recursive: true });
+    await fs5.writeFile(abs, body, "utf8");
     return "created";
   }
   const managed = raw.includes(MANAGED_MARKER);
   if (!managed && !opts.force) return "skipped-untracked";
   let parsed = null;
   try {
-    parsed = JSON.parse(stripLeadingLineComments(raw));
+    parsed = JSON.parse(stripLeadingLineComments2(raw));
   } catch {
     parsed = null;
   }
   if (!parsed && !opts.force) return "skipped-untracked";
-  const next = buildMcpJsonBody(parsed);
+  const next = buildBody(parsed);
   if (managed && next === raw) return "skipped";
   if (opts.dryRun) return "updated";
-  await fs4.mkdir(path4.dirname(abs), { recursive: true });
-  await fs4.writeFile(abs, next, "utf8");
+  await fs5.mkdir(path5.dirname(abs), { recursive: true });
+  await fs5.writeFile(abs, next, "utf8");
   return "updated";
 }
 function parseSetupIdeFlags(argv) {
@@ -926,6 +1135,7 @@ function summarizeOutcomes(outcomes) {
 }
 async function runSetupIdeFiles(o) {
   const outcomes = {};
+  let cursorGlobalMcp;
   const repoRoot = await findRepoRoot(o.cwd);
   if (!repoRoot) {
     return {
@@ -945,18 +1155,73 @@ description: MemoraOne MCP \u2014 IDE agent instructions
 
 ` + cursorRuleBody();
   if (o.targets.cursor) {
+    const detection = await detectCursorGlobalMcpConfig({
+      homeDir: o.homeDir,
+      explicitPath: o.cursorGlobalMcpConfigPath
+    });
+    if (!detection.ok) {
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        error: `${detection.error}
+  ${detection.candidates.join("\n  ")}`
+      };
+    }
+    let npxPath;
+    if (o.npxPathOverride !== void 0) {
+      npxPath = o.npxPathOverride;
+    } else {
+      npxPath = await resolveNpxPath();
+    }
+    if (!npxPath) {
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        error: "[setup-ide-files] Could not resolve a working npx executable. Install Node.js/npm or ensure npx is on PATH before configuring Cursor global MCP."
+      };
+    }
     outcomes[".cursor/rules/memoraone-mcp.mdc"] = await writeManagedMarkdown(
       repoRoot,
       ".cursor/rules/memoraone-mcp.mdc",
       cursorContent,
       { force: o.force, dryRun: o.dryRun }
     );
+    try {
+      const globalSetup = await setupCursorGlobalMcpConfig({
+        configPath: detection.path,
+        npxPath,
+        dryRun: o.dryRun
+      });
+      cursorGlobalMcp = {
+        configPath: detection.path,
+        outcome: globalSetup.outcome,
+        npxPath,
+        backupPath: globalSetup.backupPath
+      };
+      outcomes[`cursor-global:${detection.path}`] = globalSetup.outcome;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        cursorGlobalMcp: { configPath: detection.path, outcome: "skipped", npxPath },
+        error: message
+      };
+    }
   }
   if (o.targets.vscode) {
-    outcomes[".vscode/mcp.json"] = await writeMcpJson(repoRoot, {
-      force: o.force,
-      dryRun: o.dryRun
-    });
+    outcomes[".vscode/mcp.json"] = await writeIdeMcpJson(
+      repoRoot,
+      ".vscode/mcp.json",
+      buildVscodeMcpJsonBody,
+      {
+        force: o.force,
+        dryRun: o.dryRun
+      }
+    );
     outcomes[".github/copilot-instructions.md"] = await writeManagedMarkdown(
       repoRoot,
       ".github/copilot-instructions.md",
@@ -972,7 +1237,7 @@ description: MemoraOne MCP \u2014 IDE agent instructions
       { force: o.force, dryRun: o.dryRun }
     );
   }
-  return { exitCode: 0, repoRoot, outcomes };
+  return { exitCode: 0, repoRoot, outcomes, cursorGlobalMcp };
 }
 async function cliSetupIdeFiles(argv) {
   const { targets, force, dryRun, noGitignore, cleanup, unknown } = parseSetupIdeFlags(argv);
@@ -989,11 +1254,18 @@ async function cliSetupIdeFiles(argv) {
   });
   if (result.error) {
     console.error(result.error);
+    if (result.repoRoot) {
+      console.log(`[setup-ide-files] Repo root: ${result.repoRoot}`);
+    }
+    summarizeOutcomes(result.outcomes);
     return result.exitCode;
   }
   if (result.repoRoot) {
     console.log(`[setup-ide-files] Repo root: ${result.repoRoot}`);
   }
+  if (targets.cursor && result.cursorGlobalMcp) {
+    logCursorGlobalMcpCliSummary(result.cursorGlobalMcp, dryRun);
+  }
   summarizeOutcomes(result.outcomes);
   if (dryRun) {
     console.log("[setup-ide-files] Dry run: no files written.");
@@ -1057,8 +1329,8 @@ if (args[0] === "cleanup") {
     const raw = process.env.WORKSPACE_FOLDER_PATHS;
     const parts = [];
     if (raw !== void 0 && raw.trim() !== "") {
-      for (const p of raw.split(path5.delimiter).map((s) => s.trim()).filter(Boolean)) {
-        parts.push(path5.resolve(p));
+      for (const p of raw.split(path6.delimiter).map((s) => s.trim()).filter(Boolean)) {
+        parts.push(path6.resolve(p));
       }
     }
     parts.push(process.cwd());
@@ -1072,10 +1344,10 @@ if (args[0] === "cleanup") {
     }
     return deduped;
   }, connectWithRetry = function(socketPath) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const tryConnect = (attempt) => {
         const socket = net.connect(socketPath, () => {
-          resolve5(socket);
+          resolve6(socket);
         });
         socket.on("error", (err) => {
           if (attempt >= MAX_RETRIES) {
@@ -1111,7 +1383,7 @@ if (args[0] === "cleanup") {
       socket = await connectWithRetry(socketPath);
     } catch {
       log("daemon not running, spawning...");
-      const child = (0, import_node_child_process2.spawn)(
+      const child = (0, import_node_child_process3.spawn)(
         process.execPath,
         buildDaemonSpawnArgs(process.argv[1], binding.projectId),
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoraone/mcp",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "type": "module",
   "main": "dist/index.cjs",
   "bin": {