@memoraone/mcp 0.1.22 → 0.1.24

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.22",
+      version: "0.1.24",
       type: "module",
       main: "dist/index.cjs",
       bin: {
@@ -67,22 +67,84 @@ var require_package = __commonJS({
 });
 
 // src/cli.ts
-var path4 = __toESM(require("path"), 1);
+var path5 = __toESM(require("path"), 1);
 var net = __toESM(require("net"), 1);
-var import_node_child_process = require("child_process");
+var import_node_child_process2 = require("child_process");
 
 // src/socketPaths.ts
 var os = __toESM(require("os"), 1);
 var path = __toESM(require("path"), 1);
 var fs = __toESM(require("fs"), 1);
 var BASE_DIR = process.env.MEMORAONE_MCP_LOCK_DIR || path.join(os.homedir(), ".memoraone-mcp");
-function getSocketPath(projectId) {
+var SOCKET_PROJECT_ID_RE = /^mcp-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:-([a-z-]+))?\.sock$/i;
+function getMcpBaseDir() {
+  return BASE_DIR;
+}
+var IDE_TYPES = ["cursor", "copilot-vscode", "jetbrains"];
+var IDE_TYPE_SET = new Set(IDE_TYPES);
+function parseIdeType(value) {
+  if (value === void 0 || value.trim() === "" || !IDE_TYPE_SET.has(value)) {
+    return void 0;
+  }
+  return value;
+}
+function resolveIdeTypeFromEnv(env = process.env) {
+  return parseIdeType(env.MEMORAONE_IDE_TYPE);
+}
+function parseIdeTypeFromCommandLine(commandLine) {
+  const match = commandLine.match(/--ide\s+(cursor|copilot-vscode|jetbrains)(?:\s|$)/);
+  return match ? match[1] : void 0;
+}
+function buildDaemonSpawnArgs(scriptPath, projectId, env = process.env) {
+  const args2 = [scriptPath, "--daemon", "--project-id", projectId];
+  const ideType = resolveIdeTypeFromEnv(env);
+  if (ideType) {
+    args2.push("--ide", ideType);
+  }
+  return args2;
+}
+function getSocketPath(projectId, ideType) {
+  if (ideType) {
+    return path.join(BASE_DIR, `mcp-${projectId}-${ideType}.sock`);
+  }
   return path.join(BASE_DIR, `mcp-${projectId}.sock`);
 }
+function getDaemonSocketPath(projectId, env = process.env) {
+  return getSocketPath(projectId, resolveIdeTypeFromEnv(env));
+}
 function ensureBaseDir() {
   fs.mkdirSync(BASE_DIR, { recursive: true });
   return BASE_DIR;
 }
+function isMemoraoneSocketFilename(filename) {
+  return SOCKET_PROJECT_ID_RE.test(path.basename(filename));
+}
+function extractProjectIdFromSocketFilename(filename) {
+  const match = path.basename(filename).match(SOCKET_PROJECT_ID_RE);
+  return match ? match[1].toLowerCase() : null;
+}
+function isSocketFilenameForProject(filename, projectId) {
+  const extracted = extractProjectIdFromSocketFilename(filename);
+  return extracted !== null && extracted === projectId.trim().toLowerCase();
+}
+function extractIdeTypeFromSocketFilename(filename) {
+  const match = path.basename(filename).match(SOCKET_PROJECT_ID_RE);
+  if (!match) return null;
+  const suffix = match[2];
+  if (suffix === void 0) return "legacy";
+  if (IDE_TYPE_SET.has(suffix)) return suffix;
+  return null;
+}
+function isSocketFilenameForProjectAndIde(filename, projectId, ide) {
+  if (!isSocketFilenameForProject(filename, projectId)) return false;
+  if (ide === void 0) return true;
+  const socketIde = extractIdeTypeFromSocketFilename(filename);
+  if (socketIde === null) return false;
+  if (ide === "cursor") {
+    return socketIde === "cursor" || socketIde === "legacy";
+  }
+  return socketIde === ide;
+}
 
 // src/projectBinding.ts
 var fs2 = __toESM(require("fs/promises"), 1);
@@ -230,25 +292,447 @@ function encodeResolvedBinding(binding) {
 }
 
 // src/setupIdeFiles.ts
+var fs4 = __toESM(require("fs/promises"), 1);
+var path4 = __toESM(require("path"), 1);
+
+// src/cleanup.ts
 var fs3 = __toESM(require("fs/promises"), 1);
 var path3 = __toESM(require("path"), 1);
+var readline = __toESM(require("readline/promises"), 1);
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var import_node_process = require("process");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var DAEMON_PROJECT_ID_RE = /--project-id\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+var PROJECT_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var MEMORAONE_MCP_COMMAND_RE = /memoraone-mcp|memoraOne-mcp|@memoraone\/mcp/;
+var CLEANUP_PROJECT_ID_REQUIRED_ERROR = "Provide --project-id <id> or run from a folder containing memoraone.m1.";
+function isMemoraoneMcpCommandLine(commandLine) {
+  return MEMORAONE_MCP_COMMAND_RE.test(commandLine);
+}
+function parseDaemonProjectIdFromCommandLine(commandLine) {
+  if (!commandLine.includes("--daemon")) {
+    return null;
+  }
+  const match = commandLine.match(DAEMON_PROJECT_ID_RE);
+  return match ? match[1].toLowerCase() : null;
+}
+function parseDaemonIdeFromCommandLine(commandLine) {
+  if (!commandLine.includes("--daemon")) {
+    return void 0;
+  }
+  return parseIdeTypeFromCommandLine(commandLine);
+}
+function parseDaemonProcessLines(lines) {
+  const processes = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const spaceIdx = trimmed.indexOf(" ");
+    if (spaceIdx <= 0) continue;
+    const pid = Number.parseInt(trimmed.slice(0, spaceIdx), 10);
+    if (!Number.isFinite(pid) || pid <= 0) continue;
+    const command = trimmed.slice(spaceIdx + 1);
+    if (!isMemoraoneMcpCommandLine(command)) continue;
+    const projectId = parseDaemonProjectIdFromCommandLine(command);
+    if (projectId === null) continue;
+    const ide = parseDaemonIdeFromCommandLine(command);
+    processes.push({ pid, command, projectId, ...ide !== void 0 ? { ide } : {} });
+  }
+  return processes;
+}
+function normalizeCleanupProjectId(projectId) {
+  const trimmed = projectId.trim();
+  if (!PROJECT_ID_RE.test(trimmed)) {
+    return { error: `Invalid project id: ${projectId}` };
+  }
+  return trimmed.toLowerCase();
+}
+async function defaultListDaemonProcesses() {
+  const { stdout } = await execFileAsync("ps", ["-eo", "pid=,args="], {
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return parseDaemonProcessLines(stdout.split("\n"));
+}
+async function defaultListSocketPaths(projectId) {
+  const baseDir = getMcpBaseDir();
+  let entries;
+  try {
+    entries = await fs3.readdir(baseDir);
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+    if (code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
+  const paths = [];
+  for (const name of entries) {
+    if (projectId === null) {
+      if (isMemoraoneSocketFilename(name)) {
+        paths.push(path3.join(baseDir, name));
+      }
+    } else if (isSocketFilenameForProject(name, projectId)) {
+      paths.push(path3.join(baseDir, name));
+    }
+  }
+  return paths.sort();
+}
+function filterSocketPathsByIde(socketPaths, projectId, ide) {
+  if (ide === void 0) return socketPaths;
+  return socketPaths.filter(
+    (socketPath) => isSocketFilenameForProjectAndIde(path3.basename(socketPath), projectId, ide)
+  );
+}
+async function defaultKillProcess(pid) {
+  process.kill(pid, "SIGTERM");
+}
+async function defaultRemoveSocket(socketPath) {
+  await fs3.unlink(socketPath);
+}
+async function defaultConfirm(message) {
+  if (!import_node_process.stdin.isTTY) {
+    return false;
+  }
+  const rl = readline.createInterface({ input: import_node_process.stdin, output: import_node_process.stdout });
+  try {
+    const answer = await rl.question(`${message} [y/N] `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function resolveCleanupTarget(cwd) {
+  try {
+    const binding = await resolveAuthoritativeBinding([path3.resolve(cwd)]);
+    return {
+      workspaceRoot: binding.workspaceRoot,
+      m1Path: binding.m1Path,
+      projectId: binding.projectId
+    };
+  } catch {
+    return { error: CLEANUP_PROJECT_ID_REQUIRED_ERROR };
+  }
+}
+function filterProcessesForScope(processes, projectId) {
+  if (projectId === null) {
+    return { matching: processes, skipped: [] };
+  }
+  const normalized = projectId.toLowerCase();
+  const matching = [];
+  const skipped = [];
+  for (const proc of processes) {
+    if (proc.projectId === normalized) {
+      matching.push(proc);
+    } else {
+      skipped.push(proc);
+    }
+  }
+  return { matching, skipped };
+}
+function logPrefix(dryRun) {
+  return dryRun ? "[cleanup][dry-run]" : "[cleanup]";
+}
+function logReconnectNotice(prefix, ide) {
+  if (ide) {
+    console.log(
+      `${prefix} Note: Valid ${ide} connections for this project may disconnect temporarily; they should reconnect automatically. Stale connections will remain cleared.`
+    );
+  } else {
+    console.log(
+      `${prefix} Note: Valid IDE connections for this project may disconnect temporarily; they should reconnect automatically. Stale connections will remain cleared.`
+    );
+  }
+}
+async function runCleanup(opts) {
+  const listProcesses = opts.listProcesses ?? defaultListDaemonProcesses;
+  const listSocketPaths = opts.listSocketPaths ?? defaultListSocketPaths;
+  const killProcess = opts.killProcess ?? defaultKillProcess;
+  const removeSocket = opts.removeSocket ?? defaultRemoveSocket;
+  const confirm = opts.confirm ?? defaultConfirm;
+  const prefix = logPrefix(opts.dryRun);
+  let targetProjectId = null;
+  let workspaceRoot;
+  let m1Path;
+  if (opts.allProjects) {
+    if (opts.projectId) {
+      return {
+        exitCode: 1,
+        killedPids: [],
+        removedSockets: [],
+        skippedProcesses: [],
+        error: "Cannot combine --all-projects with --project-id."
+      };
+    }
+    console.log(`${prefix} Mode: all projects (--all-projects)`);
+    console.warn(
+      `${prefix} WARNING: This stops every MemoraOne MCP daemon and removes all project sockets under ${getMcpBaseDir()}.`
+    );
+  } else if (opts.projectId) {
+    const normalized = normalizeCleanupProjectId(opts.projectId);
+    if (typeof normalized !== "string") {
+      return { exitCode: 1, killedPids: [], removedSockets: [], skippedProcesses: [], error: normalized.error };
+    }
+    targetProjectId = normalized;
+    console.log(`${prefix} Project id: ${targetProjectId}`);
+    if (opts.ide) {
+      console.log(`${prefix} IDE filter: ${opts.ide}`);
+    }
+  } else {
+    const target = await resolveCleanupTarget(opts.cwd);
+    if ("error" in target) {
+      return { exitCode: 1, killedPids: [], removedSockets: [], skippedProcesses: [], error: target.error };
+    }
+    targetProjectId = target.projectId;
+    workspaceRoot = target.workspaceRoot;
+    m1Path = target.m1Path;
+    console.log(`${prefix} Workspace root: ${workspaceRoot}`);
+    console.log(`${prefix} memoraone.m1: ${m1Path}`);
+    console.log(`${prefix} Project id: ${targetProjectId}`);
+    if (opts.ide) {
+      console.log(`${prefix} IDE filter: ${opts.ide}`);
+    }
+  }
+  if (targetProjectId !== null || opts.ide) {
+    logReconnectNotice(prefix, opts.ide);
+  }
+  const allDaemonProcesses = await listProcesses();
+  const { matching: projectProcesses, skipped: skippedProcesses } = filterProcessesForScope(
+    allDaemonProcesses,
+    targetProjectId
+  );
+  let processesToStop = projectProcesses;
+  const ideSkippedProcesses = [];
+  if (opts.ide && targetProjectId !== null) {
+    processesToStop = [];
+    for (const proc of projectProcesses) {
+      if (proc.ide === opts.ide) {
+        processesToStop.push(proc);
+      } else if (proc.ide === void 0) {
+        ideSkippedProcesses.push(proc);
+        console.log(
+          `${prefix} Skipped daemon pid=${proc.pid} because IDE could not be safely determined.`
+        );
+      } else {
+        ideSkippedProcesses.push(proc);
+        console.log(
+          `${prefix} Skipped daemon pid=${proc.pid} (IDE ${proc.ide} does not match filter ${opts.ide}).`
+        );
+      }
+    }
+  }
+  const allSocketPaths = await listSocketPaths(targetProjectId);
+  const socketPaths = targetProjectId === null ? allSocketPaths : filterSocketPathsByIde(allSocketPaths, targetProjectId, opts.ide);
+  if (opts.allProjects) {
+    const projectIds = /* @__PURE__ */ new Set();
+    for (const proc of processesToStop) {
+      projectIds.add(proc.projectId);
+    }
+    for (const socketPath of socketPaths) {
+      const id = extractProjectIdFromSocketFilename(path3.basename(socketPath));
+      if (id) projectIds.add(id);
+    }
+    console.log(`${prefix} Projects affected: ${projectIds.size ? [...projectIds].sort().join(", ") : "(none found)"}`);
+  }
+  if (processesToStop.length) {
+    console.log(`${prefix} Daemon processes to stop:`);
+    for (const proc of processesToStop) {
+      const ideLabel = proc.ide ? ` ide=${proc.ide}` : "";
+      console.log(`${prefix}   pid=${proc.pid} project=${proc.projectId}${ideLabel}`);
+    }
+  } else if (ideSkippedProcesses.length) {
+    console.log(`${prefix} No matching daemon processes for IDE filter ${opts.ide}.`);
+  } else {
+    console.log(`${prefix} No matching daemon processes found.`);
+  }
+  if (socketPaths.length) {
+    console.log(`${prefix} Sockets to remove:`);
+    for (const socketPath of socketPaths) {
+      console.log(`${prefix}   ${socketPath}`);
+    }
+  } else {
+    console.log(`${prefix} No matching sockets found under ${getMcpBaseDir()}.`);
+  }
+  if (skippedProcesses.length) {
+    console.log(`${prefix} Skipped unrelated daemon processes:`);
+    for (const proc of skippedProcesses) {
+      console.log(`${prefix}   pid=${proc.pid} project=${proc.projectId}`);
+    }
+  }
+  if (opts.allProjects && !opts.dryRun) {
+    const ok = opts.assumeYes ? true : await confirm(`${prefix} Proceed with cleanup for ALL projects?`);
+    if (!ok) {
+      console.log(`${prefix} Aborted.`);
+      return {
+        exitCode: 1,
+        workspaceRoot,
+        m1Path,
+        projectId: targetProjectId ?? void 0,
+        killedPids: [],
+        removedSockets: [],
+        skippedProcesses: [...skippedProcesses, ...ideSkippedProcesses],
+        error: opts.assumeYes ? void 0 : "Aborted (--all requires --yes in non-interactive mode)"
+      };
+    }
+  }
+  const killedPids = [];
+  const removedSockets = [];
+  if (opts.dryRun) {
+    console.log(`${prefix} Dry run complete \u2014 no processes stopped, no sockets removed.`);
+    return {
+      exitCode: 0,
+      workspaceRoot,
+      m1Path,
+      projectId: targetProjectId ?? void 0,
+      killedPids: processesToStop.map((p) => p.pid),
+      removedSockets: socketPaths,
+      skippedProcesses: [...skippedProcesses, ...ideSkippedProcesses]
+    };
+  }
+  for (const proc of processesToStop) {
+    try {
+      await killProcess(proc.pid);
+      killedPids.push(proc.pid);
+      console.log(`${prefix} Stopped daemon pid=${proc.pid} project=${proc.projectId}`);
+    } catch (err) {
+      console.warn(`${prefix} Could not stop pid=${proc.pid}: ${String(err)}`);
+    }
+  }
+  if (killedPids.length) {
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  for (const socketPath of socketPaths) {
+    try {
+      await removeSocket(socketPath);
+      removedSockets.push(socketPath);
+      console.log(`${prefix} Removed socket ${socketPath}`);
+    } catch (err) {
+      const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+      if (code !== "ENOENT") {
+        console.warn(`${prefix} Could not remove socket ${socketPath}: ${String(err)}`);
+      }
+    }
+  }
+  console.log(`${prefix} Done. stopped=${killedPids.length} socketsRemoved=${removedSockets.length}`);
+  return {
+    exitCode: 0,
+    workspaceRoot,
+    m1Path,
+    projectId: targetProjectId ?? void 0,
+    killedPids,
+    removedSockets,
+    skippedProcesses: [...skippedProcesses, ...ideSkippedProcesses]
+  };
+}
+function parseCleanupFlags(argv) {
+  let dryRun = false;
+  let allProjects = false;
+  let assumeYes = false;
+  let projectId;
+  let ide;
+  let invalidIde;
+  const unknown = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--dry-run") dryRun = true;
+    else if (arg === "--all-projects" || arg === "--all") allProjects = true;
+    else if (arg === "--yes" || arg === "-y") assumeYes = true;
+    else if (arg === "--project-id") {
+      if (i + 1 >= argv.length) {
+        unknown.push("--project-id (missing value)");
+      } else {
+        projectId = argv[++i];
+      }
+    } else if (arg === "--ide") {
+      if (i + 1 >= argv.length) {
+        unknown.push("--ide (missing value)");
+      } else {
+        const value = argv[++i];
+        if (IDE_TYPES.includes(value)) {
+          ide = value;
+        } else {
+          invalidIde = value;
+        }
+      }
+    } else if (arg.startsWith("-")) unknown.push(arg);
+    else unknown.push(arg);
+  }
+  return { dryRun, allProjects, assumeYes, projectId, ide, invalidIde, unknown };
+}
+async function cliCleanup(argv) {
+  const { dryRun, allProjects, assumeYes, projectId, ide, invalidIde, unknown } = parseCleanupFlags(argv);
+  if (invalidIde) {
+    console.error(
+      `[cleanup] Invalid --ide value: ${invalidIde}. Expected one of: ${IDE_TYPES.join(", ")}.`
+    );
+    return 1;
+  }
+  if (unknown.length) {
+    console.error(`[cleanup] Unknown option(s): ${unknown.join(", ")}`);
+    return 1;
+  }
+  const result = await runCleanup({
+    cwd: process.cwd(),
+    dryRun,
+    allProjects,
+    assumeYes,
+    projectId,
+    ide
+  });
+  if (result.error) {
+    console.error(`[cleanup] ${result.error}`);
+  }
+  return result.exitCode;
+}
+
+// src/configUtils.ts
+var PROD_API_URL = "https://api.memoraone.com";
+
+// 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"]
-};
+var MCP_PACKAGE_ARG = "@memoraone/mcp@latest";
+var VSCODE_MCP_SERVERS_KEY = "servers";
+function isProdBoundEnvironment(environment) {
+  if (environment === void 0) return true;
+  const lower = environment.toLowerCase();
+  return lower === "production" || lower === "prod";
+}
+async function readMemoraoneM1Environment(repoRoot) {
+  const m1Path = path4.join(repoRoot, "memoraone.m1");
+  try {
+    const content = await fs4.readFile(m1Path, "utf8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed?.environment === "string") {
+      const trimmed = parsed.environment.trim();
+      if (trimmed !== "") return trimmed;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function buildMemoraoneMcpServerEntry(repoRoot) {
+  const entry = {
+    command: "npx",
+    args: ["-y", MCP_PACKAGE_ARG]
+  };
+  const environment = await readMemoraoneM1Environment(repoRoot);
+  if (isProdBoundEnvironment(environment)) {
+    entry.env = { MEMORAONE_API_URL: PROD_API_URL };
+  }
+  return entry;
+}
 function assertUnderRepoRoot(repoRoot, absPath) {
-  const normRoot = path3.resolve(repoRoot) + path3.sep;
-  const normPath = path3.resolve(absPath);
-  if (normPath !== path3.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
+  const normRoot = path4.resolve(repoRoot) + path4.sep;
+  const normPath = path4.resolve(absPath);
+  if (normPath !== path4.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
     throw new Error(`[setup-ide-files] Refusing to write outside repo root: ${absPath}`);
   }
 }
 async function pathExists(filePath) {
   try {
-    await fs3.access(filePath);
+    await fs4.access(filePath);
     return true;
   } catch {
     return false;
@@ -269,12 +753,12 @@ ${GITIGNORE_MEMORAONE_ENTRY}
 }
 async function ensureGitignoreMemoraone(repoRoot, opts) {
   if (opts.noGitignore) return "skipped";
-  const abs = path3.join(repoRoot, ".gitignore");
+  const abs = path4.join(repoRoot, ".gitignore");
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs3.readFile(abs, "utf8");
+    prior = await fs4.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
@@ -285,22 +769,22 @@ 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 fs3.writeFile(abs, next, "utf8");
+  await fs4.writeFile(abs, next, "utf8");
   return existed ? "updated" : "created";
 }
 async function findRepoRoot(startDir) {
-  let current = path3.resolve(startDir);
-  const root = path3.parse(current).root;
+  let current = path4.resolve(startDir);
+  const root = path4.parse(current).root;
   while (true) {
-    const gitPath = path3.join(current, ".git");
-    const m1Path = path3.join(current, "memoraone.m1");
+    const gitPath = path4.join(current, ".git");
+    const m1Path = path4.join(current, "memoraone.m1");
     if (await pathExists(gitPath) || await pathExists(m1Path)) {
       return current;
     }
     if (current === root) {
       return null;
     }
-    current = path3.dirname(current);
+    current = path4.dirname(current);
   }
 }
 function stripLeadingLineComments(text) {
@@ -346,59 +830,70 @@ function mcpJsonHeader() {
   return `// ${MANAGED_MARKER}
 `;
 }
-function buildMcpJsonBody(existing) {
-  const base = existing && typeof existing === "object" ? { ...existing } : { mcpServers: {} };
-  const servers = typeof base.mcpServers === "object" && base.mcpServers !== null && !Array.isArray(base.mcpServers) ? { ...base.mcpServers } : {};
-  servers.memoraone = { ...MEMORAONE_MCP_SERVER };
-  const merged = { ...base, mcpServers: servers };
+function extractExistingMcpServers(existing) {
+  if (typeof existing.servers === "object" && existing.servers !== null && !Array.isArray(existing.servers)) {
+    return { ...existing.servers };
+  }
+  if (typeof existing.mcpServers === "object" && existing.mcpServers !== null && !Array.isArray(existing.mcpServers)) {
+    return { ...existing.mcpServers };
+  }
+  return {};
+}
+function buildMcpJsonBody(existing, memoraoneServer) {
+  const base = existing && typeof existing === "object" ? { ...existing } : { [VSCODE_MCP_SERVERS_KEY]: {} };
+  const servers = extractExistingMcpServers(base);
+  servers.memoraone = memoraoneServer;
+  const { mcpServers: _legacy, ...rest } = base;
+  const merged = { ...rest, [VSCODE_MCP_SERVERS_KEY]: servers };
   return mcpJsonHeader() + JSON.stringify(merged, null, 2) + "\n";
 }
 async function writeManagedMarkdown(repoRoot, relPath, fullContent, opts) {
-  const abs = path3.join(repoRoot, relPath);
+  const abs = path4.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs3.readFile(abs, "utf8");
+    prior = await fs4.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
   if (!existed) {
     if (opts.dryRun) return "created";
-    await fs3.mkdir(path3.dirname(abs), { recursive: true });
-    await fs3.writeFile(abs, fullContent, "utf8");
+    await fs4.mkdir(path4.dirname(abs), { recursive: true });
+    await fs4.writeFile(abs, fullContent, "utf8");
     return "created";
   }
   if (prior.includes(MANAGED_MARKER)) {
     if (prior === fullContent) return "skipped";
     if (opts.dryRun) return "updated";
-    await fs3.mkdir(path3.dirname(abs), { recursive: true });
-    await fs3.writeFile(abs, fullContent, "utf8");
+    await fs4.mkdir(path4.dirname(abs), { recursive: true });
+    await fs4.writeFile(abs, fullContent, "utf8");
     return "updated";
   }
   if (!opts.force) return "skipped-untracked";
   if (opts.dryRun) return "updated";
-  await fs3.mkdir(path3.dirname(abs), { recursive: true });
-  await fs3.writeFile(abs, fullContent, "utf8");
+  await fs4.mkdir(path4.dirname(abs), { recursive: true });
+  await fs4.writeFile(abs, fullContent, "utf8");
   return "updated";
 }
 async function writeMcpJson(repoRoot, opts) {
-  const abs = path3.join(repoRoot, ".vscode/mcp.json");
+  const abs = path4.join(repoRoot, ".vscode/mcp.json");
   assertUnderRepoRoot(repoRoot, abs);
   let raw = "";
   let existed = false;
   try {
-    raw = await fs3.readFile(abs, "utf8");
+    raw = await fs4.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
+  const memoraoneServer = await buildMemoraoneMcpServerEntry(repoRoot);
   if (!existed) {
-    const body = buildMcpJsonBody(null);
+    const body = buildMcpJsonBody(null, memoraoneServer);
     if (opts.dryRun) return "created";
-    await fs3.mkdir(path3.dirname(abs), { recursive: true });
-    await fs3.writeFile(abs, body, "utf8");
+    await fs4.mkdir(path4.dirname(abs), { recursive: true });
+    await fs4.writeFile(abs, body, "utf8");
     return "created";
   }
   const managed = raw.includes(MANAGED_MARKER);
@@ -410,11 +905,11 @@ async function writeMcpJson(repoRoot, opts) {
     parsed = null;
   }
   if (!parsed && !opts.force) return "skipped-untracked";
-  const next = buildMcpJsonBody(parsed);
+  const next = buildMcpJsonBody(parsed, memoraoneServer);
   if (managed && next === raw) return "skipped";
   if (opts.dryRun) return "updated";
-  await fs3.mkdir(path3.dirname(abs), { recursive: true });
-  await fs3.writeFile(abs, next, "utf8");
+  await fs4.mkdir(path4.dirname(abs), { recursive: true });
+  await fs4.writeFile(abs, next, "utf8");
   return "updated";
 }
 function parseSetupIdeFlags(argv) {
@@ -425,6 +920,7 @@ function parseSetupIdeFlags(argv) {
   let force = false;
   let dryRun = false;
   let noGitignore = false;
+  let cleanup = false;
   const unknown = [];
   for (const a of argv) {
     if (a === "--cursor") cursor = true;
@@ -434,6 +930,7 @@ function parseSetupIdeFlags(argv) {
     else if (a === "--force") force = true;
     else if (a === "--dry-run") dryRun = true;
     else if (a === "--no-gitignore") noGitignore = true;
+    else if (a === "--cleanup") cleanup = true;
     else if (a.startsWith("-")) unknown.push(a);
   }
   const specific = cursor || vscode || jetbrains;
@@ -443,7 +940,7 @@ function parseSetupIdeFlags(argv) {
   } else {
     targets = { cursor, vscode, jetbrains };
   }
-  return { targets, force, dryRun, noGitignore, unknown };
+  return { targets, force, dryRun, noGitignore, cleanup, unknown };
 }
 function summarizeOutcomes(outcomes) {
   const created = [];
@@ -516,7 +1013,7 @@ description: MemoraOne MCP \u2014 IDE agent instructions
   return { exitCode: 0, repoRoot, outcomes };
 }
 async function cliSetupIdeFiles(argv) {
-  const { targets, force, dryRun, noGitignore, unknown } = parseSetupIdeFlags(argv);
+  const { targets, force, dryRun, noGitignore, cleanup, unknown } = parseSetupIdeFlags(argv);
   if (unknown.length) {
     console.error(`[setup-ide-files] Unknown option(s): ${unknown.join(", ")}`);
     return 1;
@@ -539,6 +1036,26 @@ async function cliSetupIdeFiles(argv) {
   if (dryRun) {
     console.log("[setup-ide-files] Dry run: no files written.");
   }
+  if (cleanup) {
+    console.log("[setup-ide-files] Running project-scoped cleanup...");
+    const cleanupResult = await runCleanup({
+      cwd: process.cwd(),
+      dryRun,
+      allProjects: false,
+      assumeYes: true
+    });
+    if (cleanupResult.error) {
+      console.error(`[setup-ide-files] cleanup failed: ${cleanupResult.error}`);
+      return cleanupResult.exitCode;
+    }
+  } else {
+    console.log(
+      "[setup-ide-files] If Studio shows stale connections, run: npx -y @memoraone/mcp@latest cleanup --project-id <projectId>"
+    );
+    console.log(
+      "[setup-ide-files] From this repo (uses memoraone.m1): npx -y @memoraone/mcp@latest cleanup"
+    );
+  }
   return 0;
 }
 
@@ -551,11 +1068,17 @@ if (args.includes("--version") || args.includes("-v")) {
 }
 if (args.includes("--help") || args.includes("-h")) {
   console.log(
-    "Usage: memoraone-mcp [--version] [--help] [--daemon --project-id <uuid>]\n       memoraone-mcp setup-ide-files [--all|--cursor|--vscode|--jetbrains] [--force] [--dry-run] [--no-gitignore]"
+    "Usage: memoraone-mcp [--version] [--help] [--daemon --project-id <uuid> [--ide cursor|copilot-vscode|jetbrains]]\n       memoraone-mcp setup-ide-files [--all|--cursor|--vscode|--jetbrains] [--force] [--dry-run] [--no-gitignore] [--cleanup]\n       memoraone-mcp cleanup [--project-id <uuid>] [--ide cursor|copilot-vscode|jetbrains] [--dry-run] [--all-projects] [--yes]"
   );
   process.exit(0);
 }
-if (args[0] === "setup-ide-files") {
+if (args[0] === "cleanup") {
+  cliCleanup(args.slice(1)).then((code) => process.exit(code)).catch((err) => {
+    process.stderr.write(`[memoraone-mcp] cleanup fatal: ${String(err)}
+`);
+    process.exit(1);
+  });
+} else if (args[0] === "setup-ide-files") {
   cliSetupIdeFiles(args.slice(1)).then((code) => process.exit(code)).catch((err) => {
     process.stderr.write(`[memoraone-mcp] setup-ide-files fatal: ${String(err)}
 `);
@@ -572,8 +1095,8 @@ if (args[0] === "setup-ide-files") {
     const raw = process.env.WORKSPACE_FOLDER_PATHS;
     const parts = [];
     if (raw !== void 0 && raw.trim() !== "") {
-      for (const p of raw.split(path4.delimiter).map((s) => s.trim()).filter(Boolean)) {
-        parts.push(path4.resolve(p));
+      for (const p of raw.split(path5.delimiter).map((s) => s.trim()).filter(Boolean)) {
+        parts.push(path5.resolve(p));
       }
     }
     parts.push(process.cwd());
@@ -587,10 +1110,10 @@ if (args[0] === "setup-ide-files") {
     }
     return deduped;
   }, connectWithRetry = function(socketPath) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const tryConnect = (attempt) => {
         const socket = net.connect(socketPath, () => {
-          resolve4(socket);
+          resolve5(socket);
         });
         socket.on("error", (err) => {
           if (attempt >= MAX_RETRIES) {
@@ -616,7 +1139,7 @@ if (args[0] === "setup-ide-files") {
   async function runBridge() {
     ensureBaseDir();
     const binding = await resolveBinding();
-    const socketPath = getSocketPath(binding.projectId);
+    const socketPath = getDaemonSocketPath(binding.projectId);
     const environmentLog = binding.environment !== void 0 ? ` environment=${binding.environment}` : "";
     log(
       `authoritative binding project=${binding.projectId} workspace=${binding.workspaceRoot} m1=${binding.m1Path} source=${binding.bindingSource} apiKeySource=${binding.apiKeySource}${environmentLog}`
@@ -626,14 +1149,18 @@ if (args[0] === "setup-ide-files") {
       socket = await connectWithRetry(socketPath);
     } catch {
       log("daemon not running, spawning...");
-      const child = (0, import_node_child_process.spawn)(process.execPath, [process.argv[1], "--daemon", "--project-id", binding.projectId], {
-        detached: true,
-        stdio: "ignore",
-        env: {
-          ...process.env,
-          MEMORAONE_DAEMON_BINDING_B64: encodeResolvedBinding(binding)
+      const child = (0, import_node_child_process2.spawn)(
+        process.execPath,
+        buildDaemonSpawnArgs(process.argv[1], binding.projectId),
+        {
+          detached: true,
+          stdio: "ignore",
+          env: {
+            ...process.env,
+            MEMORAONE_DAEMON_BINDING_B64: encodeResolvedBinding(binding)
+          }
         }
-      });
+      );
       child.unref();
       await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
       socket = await connectWithRetry(socketPath);