@llmnesia/mcp 0.1.3 → 0.1.6

package/dist/{cli-JFZO44NP.js → cli-LNUL4QWX.js}

@@ -9,13 +9,13 @@ import {
   ingestFile,
   openSearchIndex,
   resolveCorpusDir
-} from "./chunk-7BW63ZTP.js";
+} from "./chunk-3JQ7CGCP.js";
 import {
   VERSION,
   __commonJS,
   __require,
   __toESM
-} from "./chunk-EBVGUZX2.js";
+} from "./chunk-JBCYML3I.js";
 
 // ../node_modules/isexe/windows.js
 var require_windows = __commonJS({
@@ -533,6 +533,7 @@ var HOST_NAME = "com.llmnesia.claude_code";
 var STORE_EXTENSION_ID = "leekfgbdojiaabifbjbbgiiclannjdkf";
 var here = dirname(fileURLToPath(import.meta.url));
 var home = homedir();
+var CLAUDE_PROJECTS_DIR = join(home, ".claude", "projects");
 var osPlatform = process.env.LLMNESIA_FAKE_PLATFORM || platform();
 function expandHome(p) {
   if (p === "~") {
@@ -547,6 +548,11 @@ function resolveCorpusDir2(explicit) {
   const raw = explicit ?? process.env.LLMNESIA_CORPUS_DIR ?? "~/.llmnesia/corpus";
   return expandHome(raw);
 }
+function resolveCodexHome(explicit) {
+  const candidates = [explicit, process.env.CODEX_HOME, "~/.codex"];
+  const raw = candidates.find((value) => typeof value === "string" && value.trim() !== "");
+  return expandHome(raw.trim());
+}
 async function exists(path) {
   try {
     await stat(path);
@@ -573,21 +579,24 @@ async function readExistingConfig(configPath) {
     if (err && typeof err === "object" && err.code === "ENOENT") {
       return null;
     }
-    throw new Error(`Could not read existing native-host config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+    throw new Error(`LLMnesia couldn't read its settings at ${configPath}: ${err instanceof Error ? err.message : String(err)}. Nothing was changed.`);
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
     throw new Error(
-      `Could not parse existing native-host config at ${configPath}: ${err instanceof Error ? err.message : String(err)}. The file was left unchanged.`
+      `LLMnesia found invalid JSON in its settings at ${configPath}: ${err instanceof Error ? err.message : String(err)}. Nothing was changed; repair or move that file aside, then retry.`
     );
   }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`Existing native-host config at ${configPath} must be a JSON object. The file was left unchanged.`);
+    throw new Error(`LLMnesia settings at ${configPath} must contain a JSON object. Nothing was changed.`);
   }
   if ("corpusRoot" in parsed && typeof parsed.corpusRoot !== "string") {
-    throw new Error(`Existing native-host config at ${configPath} has an invalid corpusRoot. The file was left unchanged.`);
+    throw new Error(`LLMnesia settings at ${configPath} contain an invalid conversation-data folder. Nothing was changed.`);
+  }
+  if ("codexHome" in parsed && typeof parsed.codexHome !== "string") {
+    throw new Error(`LLMnesia settings at ${configPath} contain an invalid Codex data folder. Nothing was changed.`);
   }
   return parsed;
 }
@@ -620,7 +629,7 @@ async function installPosix(manifestBase, hostPath, log) {
     await mkdir(dir, { recursive: true });
     await writeFile(join(dir, `${HOST_NAME}.json`), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-    log(`Manifest \u2192 ${label}: ${join(dir, `${HOST_NAME}.json`)}`);
+    log(`\u2713 ${label} connected`);
     installed += 1;
   }
   return installed;
@@ -639,12 +648,11 @@ async function installWindows(manifestBase, hostPath, installDir, log) {
   await writeFile(batPath, `@echo off\r
 "${process.execPath}" "${hostPath}" %*\r
 `, "utf8");
-  log(`Launcher \u2192 ${batPath}`);
+  log("\u2713 Windows launcher ready");
   const manifest = { ...manifestBase, path: batPath };
   const manifestPath = join(installDir, `${HOST_NAME}.json`);
   await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-  log(`Manifest \u2192 ${manifestPath}`);
   let installed = 0;
   for (const [label, userDataDir, vendorKey] of windowsBrowsers()) {
     if (!await exists(userDataDir)) {
@@ -653,23 +661,27 @@ async function installWindows(manifestBase, hostPath, installDir, log) {
     const key = `HKCU\\${vendorKey}\\NativeMessagingHosts\\${HOST_NAME}`;
     const regExe = join(process.env.SystemRoot || "C:\\Windows", "System32", "reg.exe");
     await execFileAsync(regExe, ["add", key, "/ve", "/t", "REG_SZ", "/d", manifestPath, "/f"]);
-    log(`Registry \u2192 ${label}: ${key}`);
+    log(`\u2713 ${label} connected`);
     installed += 1;
   }
   return installed;
 }
-async function installNativeHost({ ids = [], corpus, force = false, quiet = false } = {}) {
+async function installNativeHost({ ids = [], corpus, codexHome, force = false, quiet = false } = {}) {
   const log = quiet ? () => {
   } : console.log;
   const isWindows2 = osPlatform === "win32";
   const invalidId = ids.find((id) => !/^[a-p]{32}$/.test(id));
   if (invalidId) {
-    throw new Error(`Invalid Chromium extension id: ${JSON.stringify(invalidId)}. Expected 32 letters from a through p.`);
+    throw new Error(
+      `${JSON.stringify(invalidId)} is not a Chromium extension ID. Only unpacked/development builds need an ID; it must be 32 letters from a through p. Run with --help for an example.`
+    );
   }
   const allIds = [.../* @__PURE__ */ new Set([STORE_EXTENSION_ID, ...ids])];
   const allowedOrigins = allIds.map((id) => `chrome-extension://${id}/`);
   if (await supportedBrowserCount(isWindows2) === 0) {
-    throw new Error("No supported Chromium browser found (Chrome, Brave, Edge, or Chromium) \u2014 the browser helper was not installed.");
+    throw new Error(
+      "LLMnesia couldn't find Chrome, Brave, Edge, or Chromium. Open your browser once so it creates a profile, then retry. Safari and Firefox are not supported yet. Nothing was installed."
+    );
   }
   const installDir = join(home, ".llmnesia");
   const configPath = join(installDir, "config.json");
@@ -683,38 +695,68 @@ async function installNativeHost({ ids = [], corpus, force = false, quiet = fals
   if (!isWindows2) {
     await chmod(hostPath, 493);
   }
-  log(`Host script \u2192 ${hostPath}`);
+  log("\u2713 Helper installed");
   const manifestBase = {
     name: HOST_NAME,
-    description: "LLMnesia \u2014 reads local Claude Code sessions",
+    description: "LLMnesia \u2014 reads local Claude Code and Codex sessions",
     type: "stdio",
     allowed_origins: allowedOrigins
   };
   const installedCount = isWindows2 ? await installWindows(manifestBase, hostPath, installDir, log) : await installPosix(manifestBase, hostPath, log);
   const corpusRoot = resolveCorpusDir2(corpus);
+  const resolvedCodexHome = resolveCodexHome(codexHome);
   const existingRoot = existing && typeof existing.corpusRoot === "string" ? existing.corpusRoot : null;
   let corpusRootChanged = true;
   if (existingRoot && existingRoot !== corpusRoot && !force) {
     corpusRootChanged = false;
-    log(`Corpus config kept \u2192 ${configPath}`);
-    log(`  already points at: ${existingRoot}`);
-    log(`  to change it: re-run with --corpus <dir> --force`);
+    await writeFile(
+      configPath,
+      `${JSON.stringify({ ...existing, corpusRoot: existingRoot, codexHome: resolvedCodexHome }, null, 2)}
+`,
+      { encoding: "utf8", mode: 384 }
+    );
+    await chmod(configPath, 384);
+    log("\u2713 Kept your existing conversation-data folder");
+    log(`  Conversation data: ${existingRoot}`);
+    log(`  To change it: re-run with --corpus <dir> --force`);
+    log(`  Codex data: ${resolvedCodexHome}`);
   } else {
-    await writeFile(configPath, `${JSON.stringify({ corpusRoot }, null, 2)}
-`, { encoding: "utf8", mode: 384 });
+    await writeFile(
+      configPath,
+      `${JSON.stringify({ ...existing ?? {}, corpusRoot, codexHome: resolvedCodexHome }, null, 2)}
+`,
+      { encoding: "utf8", mode: 384 }
+    );
     await chmod(configPath, 384);
-    log(`Corpus config \u2192 ${configPath}`);
-    log(`  corpus root: ${corpusRoot}`);
+    log("\u2713 Settings saved");
+    log(`  Conversation data: ${corpusRoot}`);
+    log(`  Codex data: ${resolvedCodexHome}`);
+  }
+  const [hasClaudeCode, hasCodex] = await Promise.all([
+    exists(CLAUDE_PROJECTS_DIR),
+    exists(join(resolvedCodexHome, "sessions"))
+  ]);
+  log("");
+  log(
+    hasClaudeCode ? `\u2713 Found Claude Code sessions at ${CLAUDE_PROJECTS_DIR}` : `\u2013 No Claude Code sessions found yet (fine if you don't use Claude Code).`
+  );
+  log(
+    hasCodex ? `\u2713 Found Codex sessions at ${resolvedCodexHome}` : `\u2013 No Codex sessions found yet (fine if you don't use Codex).`
+  );
+  const extraIdCount = allIds.length - 1;
+  if (extraIdCount > 0) {
+    log(`\u2713 Also authorized ${extraIdCount} unpacked extension ${extraIdCount === 1 ? "build" : "builds"}`);
   }
-  log(`
-Done. Allowed extension id(s): ${allIds.join(", ")}`);
-  log("Fully quit and reopen the browser, then open LLMnesia Settings.");
+  log("\nAll set \u2014 LLMnesia can now read your local coding-agent sessions.");
+  log("Next: fully quit your browser (not just close its window), reopen it, then open LLMnesia Settings.");
+  log("If it doesn't connect, run: npx -y @llmnesia/local-agent-host@latest doctor");
   return {
     installedCount,
     allowedIds: allIds,
     configPath,
     corpusRoot: existingRoot && !corpusRootChanged ? existingRoot : corpusRoot,
-    corpusRootChanged
+    corpusRootChanged,
+    codexHome: resolvedCodexHome
   };
 }
 async function uninstallNativeHost() {
@@ -2564,12 +2606,13 @@ async function watchInbox(corpus, onDrain) {
 // src/clientRegistration.ts
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 import { execFile as execFile2 } from "child_process";
-import { access, readFile as readFile2, stat as stat5, writeFile as writeFile2 } from "fs/promises";
+import { access, mkdir as mkdir2, readFile as readFile2, stat as stat5, writeFile as writeFile2 } from "fs/promises";
 import { homedir as homedir2, platform as platform2 } from "os";
 import { dirname as dirname4, join as join4 } from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 var SERVER_NAME = "llmnesia";
+var CODEX_APPROVAL_MODE = "writes";
 async function commandOnPath(name) {
   try {
     const { stdout } = await execFileAsync2(process.platform === "win32" ? "where" : "which", [name]);
@@ -2912,21 +2955,47 @@ claude mcp add --scope user ${SERVER_NAME} -- ${serve.command} ${serve.args.join
 function sameServeCommand(left, right) {
   return left.command === right.command && JSON.stringify(left.args) === JSON.stringify(right.args);
 }
-async function registerCodex(serve, cli, configPath, confirm) {
+async function registerCodex(serve, cli, configPath, confirm, now, prepareMissing = false) {
   if (!await cli.detect()) {
-    if (!await clientDirExists(configPath)) {
+    const configDirExists = await clientDirExists(configPath);
+    if (!configDirExists && !prepareMissing) {
       return {
         client: "Codex",
         action: "skipped",
         detail: `Not installed (no Codex CLI and no ${dirname4(configPath)}).`
       };
     }
-    return {
-      client: "Codex",
-      action: "printed",
-      detail: `Codex's CLI was not found. Add this to ${configPath}:
-${codexBlock(serve)}Then fully quit and reopen Codex.`
-    };
+    if (!configDirExists) {
+      await mkdir2(dirname4(configPath), { recursive: true });
+    }
+    try {
+      const raw = await readFile2(configPath, "utf8");
+      if (renderCodexConfig(raw, serve) === raw) {
+        return { client: "Codex", action: "skipped", detail: `Already registered at ${configPath}.` };
+      }
+    } catch (err) {
+      if (!(isErrnoException(err) && err.code === "ENOENT")) {
+        return { client: "Codex", action: "error", detail: `Could not inspect ${configPath}: ${errorMessage(err)}` };
+      }
+    }
+    const ok2 = await confirm(
+      `Codex: update ${configPath} to register LLMnesia? Existing settings are preserved and backed up.
+Add:
+${codexBlock(serve)}`
+    );
+    if (!ok2) {
+      return { client: "Codex", action: "declined", detail: "Skipped by user." };
+    }
+    try {
+      const update = await writeCodexConfig(configPath, serve, now);
+      return {
+        client: "Codex",
+        action: update.changed ? configDirExists ? "registered" : "prepared" : "skipped",
+        detail: update.changed ? configDirExists ? `Wrote ${configPath}${update.backupPath ? ` (backup: ${update.backupPath})` : ""}.` : `Prepared ${configPath} for a future Codex or ChatGPT installation.` : `Already registered at ${configPath}.`
+      };
+    } catch (err) {
+      return { client: "Codex", action: "error", detail: `Could not update ${configPath}: ${errorMessage(err)}` };
+    }
   }
   let existing;
   try {
@@ -2935,7 +3004,20 @@ ${codexBlock(serve)}Then fully quit and reopen Codex.`
     return { client: "Codex", action: "error", detail: `Could not inspect Codex MCP settings: ${errorMessage(err)}` };
   }
   if (existing?.serve && sameServeCommand(existing.serve, serve)) {
-    return { client: "Codex", action: "skipped", detail: "Already registered." };
+    try {
+      const update = await writeCodexConfig(configPath, serve, now);
+      return {
+        client: "Codex",
+        action: update.changed ? "registered" : "skipped",
+        detail: update.changed ? `Already registered; updated tool approval policy in ${configPath}.` : "Already registered."
+      };
+    } catch (err) {
+      return {
+        client: "Codex",
+        action: "error",
+        detail: `Already registered, but could not set its tool approval policy: ${errorMessage(err)}`
+      };
+    }
   }
   if (existing && !existing.serve) {
     return {
@@ -2975,20 +3057,37 @@ codex mcp add ${SERVER_NAME} -- ${serve.command} ${serve.args.join(" ")}`
     }
     return { client: "Codex", action: "error", detail: `codex mcp add failed: ${errorMessage(err)}` };
   }
+  try {
+    await writeCodexConfig(configPath, serve, now);
+  } catch (err) {
+    return {
+      client: "Codex",
+      action: "error",
+      detail: `Registered the server, but could not set its tool approval policy in ${configPath}: ${errorMessage(err)}`
+    };
+  }
   return {
     client: "Codex",
     action: "registered",
     detail: `Ran: codex mcp add ${SERVER_NAME} -- ${serve.command} ${serve.args.join(" ")}`
   };
 }
-async function registerJsonClient(clientLabel, configPath, serve, confirm, now) {
-  if (!await clientDirExists(configPath)) {
+async function registerJsonClient(clientLabel, configPath, serve, confirm, now, prepareMissing = false) {
+  const configDirExists = await clientDirExists(configPath);
+  if (!configDirExists && !prepareMissing) {
     return {
       client: clientLabel,
       action: "skipped",
       detail: `Not installed (no ${dirname4(configPath)}). Re-run install after setting it up.`
     };
   }
+  if (!configDirExists) {
+    try {
+      await mkdir2(dirname4(configPath), { recursive: true });
+    } catch (err) {
+      return { client: clientLabel, action: "error", detail: `Could not prepare ${configPath}: ${errorMessage(err)}` };
+    }
+  }
   let data;
   let existed;
   let raw;
@@ -3025,7 +3124,11 @@ ${preview}`;
     const nextData = { ...data, mcpServers: { ...servers, [SERVER_NAME]: nextEntry } };
     await writeFile2(configPath, `${JSON.stringify(nextData, null, 2)}
 `, "utf8");
-    return { client: clientLabel, action: "registered", detail: `Wrote ${configPath}.` };
+    return {
+      client: clientLabel,
+      action: configDirExists ? "registered" : "prepared",
+      detail: configDirExists ? `Wrote ${configPath}.` : `Prepared ${configPath} for a future ${clientLabel} installation.`
+    };
   } catch (err) {
     return { client: clientLabel, action: "error", detail: `Could not write ${configPath}: ${errorMessage(err)}` };
   }
@@ -3035,8 +3138,82 @@ function codexBlock(serve) {
   return `[mcp_servers.${SERVER_NAME}]
 command = ${JSON.stringify(serve.command)}
 args = [${argsToml}]
+default_tools_approval_mode = ${JSON.stringify(CODEX_APPROVAL_MODE)}
 `;
 }
+function codexHeaders(raw) {
+  const headers = [];
+  const pattern = /^[ \t]*\[([^\]\r\n]+)\][ \t]*(?:#.*)?$/gm;
+  for (let match = pattern.exec(raw); match; match = pattern.exec(raw)) {
+    headers.push({ start: match.index, name: match[1].replace(/[ \t]/g, "") });
+  }
+  return headers;
+}
+function isCodexRootHeader(name) {
+  return /^mcp_servers\.(?:llmnesia|"llmnesia"|'llmnesia')$/.test(name);
+}
+function isCodexChildHeader(name) {
+  return /^mcp_servers\.(?:llmnesia|"llmnesia"|'llmnesia')\./.test(name);
+}
+function codexSectionRange(raw) {
+  const headers = codexHeaders(raw);
+  const roots = headers.filter((header) => isCodexRootHeader(header.name));
+  if (roots.length > 1) {
+    throw new Error(`found more than one [mcp_servers.${SERVER_NAME}] table; the file was left unchanged`);
+  }
+  const root = roots[0];
+  if (!root) {
+    if (headers.some((header) => isCodexChildHeader(header.name))) {
+      throw new Error(
+        `found LLMnesia MCP subtables without a [mcp_servers.${SERVER_NAME}] table; the file was left unchanged`
+      );
+    }
+    return null;
+  }
+  const rootIndex = headers.indexOf(root);
+  let end = raw.length;
+  for (let i = rootIndex + 1; i < headers.length; i += 1) {
+    if (!isCodexChildHeader(headers[i].name)) {
+      end = headers[i].start;
+      break;
+    }
+  }
+  return { start: root.start, end };
+}
+function renderCodexConfig(raw, serve) {
+  const newline = raw.includes("\r\n") ? "\r\n" : "\n";
+  const block = codexBlock(serve).replace(/\n/g, newline);
+  const range = codexSectionRange(raw);
+  if (range) {
+    return `${raw.slice(0, range.start)}${block}${raw.slice(range.end)}`;
+  }
+  const base = raw.replace(/[ \t\r\n]+$/g, "");
+  return `${base}${base ? `${newline}${newline}` : ""}${block}`;
+}
+async function writeCodexConfig(configPath, serve, now) {
+  let raw = "";
+  let existed = true;
+  try {
+    raw = await readFile2(configPath, "utf8");
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") {
+      existed = false;
+    } else {
+      throw err;
+    }
+  }
+  const next = renderCodexConfig(raw, serve);
+  if (next === raw) {
+    return { changed: false };
+  }
+  let backupPath;
+  if (existed) {
+    backupPath = `${configPath}.bak-${now()}`;
+    await writeFile2(backupPath, raw, "utf8");
+  }
+  await writeFile2(configPath, next, { encoding: "utf8", mode: 384 });
+  return { changed: true, ...backupPath ? { backupPath } : {} };
+}
 function genericBlock(serve) {
   return JSON.stringify({ mcpServers: { [SERVER_NAME]: { command: serve.command, args: serve.args } } }, null, 2);
 }
@@ -3044,6 +3221,7 @@ async function registerClients(options) {
   const home2 = options.home ?? homedir2();
   const osPlatform2 = options.osPlatform ?? platform2();
   const now = options.now ?? (() => Date.now());
+  const prepareMissing = options.prepareMissingDesktopApps === true;
   const { claudeDesktop, cursor, codex } = paths(home2, osPlatform2);
   const results = [];
   const safe = async (client, fn) => {
@@ -3063,13 +3241,18 @@ async function registerClients(options) {
     results.push(
       await safe(
         "Claude Desktop",
-        () => registerJsonClient("Claude Desktop", claudeDesktop, options.serve, options.confirm, now)
+        () => registerJsonClient("Claude Desktop", claudeDesktop, options.serve, options.confirm, now, prepareMissing)
       )
     );
   }
-  results.push(await safe("Cursor", () => registerJsonClient("Cursor", cursor, options.serve, options.confirm, now)));
   results.push(
-    await safe("Codex", () => registerCodex(options.serve, options.codexCli ?? realCodexCli, codex, options.confirm))
+    await safe("Cursor", () => registerJsonClient("Cursor", cursor, options.serve, options.confirm, now, prepareMissing))
+  );
+  results.push(
+    await safe(
+      "Codex",
+      () => registerCodex(options.serve, options.codexCli ?? realCodexCli, codex, options.confirm, now, prepareMissing)
+    )
   );
   results.push({
     client: "Other MCP clients (Windsurf, Zed, LM Studio, ...)",
@@ -3111,20 +3294,27 @@ async function unregisterClaudeCode(cli) {
     };
   }
 }
-async function unregisterCodex(cli, configPath) {
+async function unregisterCodex(cli, configPath, now) {
   if (!await cli.detect()) {
     try {
-      const text = await readFile2(configPath, "utf8");
-      if (new RegExp(`^\\s*\\[mcp_servers\\.${SERVER_NAME}\\]\\s*$`, "m").test(text)) {
-        return {
-          client: "Codex",
-          action: "error",
-          detail: `A registration remains in ${configPath}, but the Codex CLI is unavailable to remove it safely. Restore the CLI and retry. The runtime was retained.`
-        };
+      const raw = await readFile2(configPath, "utf8");
+      const range = codexSectionRange(raw);
+      if (!range) {
+        return { client: "Codex", action: "skipped", detail: "`codex` not found and no registration was detected." };
       }
+      const backupPath = `${configPath}.bak-${now()}`;
+      await writeFile2(backupPath, raw, "utf8");
+      const next = `${raw.slice(0, range.start)}${raw.slice(range.end)}`.replace(/[ \t\r\n]+$/g, "");
+      await writeFile2(configPath, next ? `${next}
+` : "", "utf8");
+      return {
+        client: "Codex",
+        action: "registered",
+        detail: `Removed from ${configPath} (backup: ${backupPath}).`
+      };
     } catch (err) {
       if (!(isErrnoException(err) && err.code === "ENOENT")) {
-        return { client: "Codex", action: "error", detail: `Could not inspect ${configPath}: ${errorMessage(err)}` };
+        return { client: "Codex", action: "error", detail: `Could not update ${configPath}: ${errorMessage(err)}` };
       }
     }
     return { client: "Codex", action: "skipped", detail: "`codex` not found and no registration was detected." };
@@ -3192,7 +3382,7 @@ async function unregisterClients(options = {}) {
     results.push(await safe("Claude Desktop", () => unregisterJsonClient("Claude Desktop", claudeDesktop, now)));
   }
   results.push(await safe("Cursor", () => unregisterJsonClient("Cursor", cursor, now)));
-  results.push(await safe("Codex", () => unregisterCodex(options.codexCli ?? realCodexCli, codex)));
+  results.push(await safe("Codex", () => unregisterCodex(options.codexCli ?? realCodexCli, codex, now)));
   results.push({
     client: "Other MCP clients",
     action: "skipped",
@@ -3207,7 +3397,7 @@ import { delimiter, dirname as dirname6, isAbsolute as isAbsolute2, join as join
 import { homedir as homedir4, platform as platform3 } from "os";
 
 // src/runtimeInstall.ts
-import { cp, mkdir as mkdir2, readdir as readdir3, rename, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { cp, mkdir as mkdir3, readdir as readdir3, rename, rm as rm2, writeFile as writeFile3 } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname5, join as join5 } from "path";
@@ -3233,10 +3423,10 @@ async function installRuntime(options = {}) {
   const nonce = `${process.pid}-${Date.now()}`;
   const stagingDir = join5(parentDir, `.bin-install-${nonce}`);
   const backupDir = join5(parentDir, `.bin-backup-${nonce}`);
-  await mkdir2(parentDir, { recursive: true });
+  await mkdir3(parentDir, { recursive: true });
   await rm2(stagingDir, { recursive: true, force: true });
   await rm2(backupDir, { recursive: true, force: true });
-  await mkdir2(stagingDir, { recursive: true });
+  await mkdir3(stagingDir, { recursive: true });
   try {
     for (const name of await readdir3(sourceDir)) {
       await cp(join5(sourceDir, name), join5(stagingDir, name), { recursive: true });
@@ -3622,64 +3812,90 @@ ${message}
     rl.close();
   }
 }
-function printRegistrationResults(results) {
-  for (const r of results) {
-    if (r.client.startsWith("Other MCP clients")) {
-      continue;
-    }
-    if (r.action === "registered") {
-      process.stdout.write(`\u2713 ${r.client}
-`);
-      continue;
-    }
-    if (r.action === "skipped" && r.detail.startsWith("Already registered")) {
-      process.stdout.write(`\u2713 ${r.client} (already configured)
-`);
-      continue;
-    }
-    if (r.action === "error") {
-      process.stderr.write(`\u2717 ${r.client}: ${r.detail}
-`);
-      continue;
-    }
-    if (r.action === "printed") {
-      process.stdout.write(`\u2022 ${r.client}: ${r.detail}
-`);
-    }
-  }
+function summarizeClientRegistrations(results) {
+  const connected = [];
+  const prepared = [];
+  const errors = [];
+  for (const result of results) {
+    if (result.client.startsWith("Other MCP clients")) continue;
+    if (result.action === "registered" || result.action === "skipped" && result.detail.startsWith("Already registered")) {
+      connected.push(result.client);
+    } else if (result.action === "prepared") {
+      prepared.push(result.client);
+    } else if (result.action === "error") {
+      errors.push({ client: result.client, detail: result.detail });
+    }
+  }
+  return { connected, prepared, errors };
+}
+function naturalList(items) {
+  if (items.length <= 1) return items[0] ?? "";
+  if (items.length === 2) return `${items[0]} and ${items[1]}`;
+  return `${items.slice(0, -1).join(", ")}, and ${items.at(-1)}`;
+}
+function formatInstallSuccess(connectedClients, preparedClients = []) {
+  const apps = naturalList(connectedClients);
+  const restart = apps ? `Fully close and reopen your browser and ${apps}.
+` : "Fully close and reopen your browser.\n";
+  const future = preparedClients.length > 0 ? `${naturalList(preparedClients)} will also be ready if you install ${preparedClients.length === 1 ? "it" : "them"} later.
+` : "";
+  return `
+Setup complete.
+${restart}${future}LLMnesia Settings will confirm when your history is ready.
+`;
 }
 async function runInstall(positionals, options, flags) {
   let hadProblems = false;
-  process.stdout.write("Installing LLMnesia MCP\u2026\n");
+  process.stdout.write("Connecting your browser...\n");
   try {
-    const host = await installNativeHost({
+    await installNativeHost({
       ids: positionals,
       corpus: options.corpus,
       force: flags.has("force"),
       quiet: true
     });
-    process.stdout.write(`\u2713 Browser helper (${host.installedCount} browser${host.installedCount === 1 ? "" : "s"})
-`);
+    process.stdout.write("Browser connected.\n");
   } catch (err) {
     hadProblems = true;
-    process.stderr.write(`\u2717 Browser helper: ${err instanceof Error ? err.message : String(err)}
+    process.stderr.write(`Could not connect your browser: ${err instanceof Error ? err.message : String(err)}
 `);
   }
-  const runtime = await installRuntime();
-  process.stdout.write("\u2713 MCP runtime\n");
-  const results = await registerClients({ serve: runtime.serve, confirm: async () => true });
-  printRegistrationResults(results);
-  hadProblems ||= results.some((result) => result.action === "error");
-  process.stdout.write(
-    "\nDone. Fully quit and reopen your MCP apps (and browser) to load LLMnesia.\nFor browser-history sync, open LLMnesia Settings and click \u2018Enable automatic sync\u2019 once.\n"
-  );
-  process.stdout.write("Then run `npx -y @llmnesia/mcp@latest doctor` to check what's wired up.\n");
-  if (hadProblems) {
+  process.stdout.write("Connecting your desktop AI apps...\n");
+  let runtime;
+  try {
+    runtime = await installRuntime();
+  } catch (err) {
+    process.stderr.write(`Could not install LLMnesia: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.stderr.write("Setup needs attention. Fix the message above, then run the same command again.\n");
+    return 1;
+  }
+  const results = await registerClients({
+    serve: runtime.serve,
+    confirm: async () => true,
+    prepareMissingDesktopApps: true
+  });
+  const registrations = summarizeClientRegistrations(results);
+  for (const client of registrations.connected) {
+    process.stdout.write(`${client} connected.
+`);
+  }
+  for (const error of registrations.errors) {
+    process.stderr.write(`Could not connect ${error.client}: ${error.detail}
+`);
+  }
+  hadProblems ||= registrations.errors.length > 0;
+  if (registrations.connected.length === 0 && registrations.prepared.length === 0) {
+    hadProblems = true;
     process.stderr.write(
-      "\nInstall completed with problems. Review the error messages above; no failure was silently treated as success.\n"
+      "No supported desktop AI app was found. Install or open Codex, Claude Desktop, or Cursor, then run the same command again.\n"
     );
+  }
+  if (hadProblems) {
+    process.stderr.write("\nSetup needs attention. Fix the message above, then run the same command again.\n");
     return 1;
   }
+  process.stdout.write(formatInstallSuccess(registrations.connected, registrations.prepared));
   return 0;
 }
 async function runUninstall(flags) {
@@ -3694,10 +3910,19 @@ async function runUninstall(flags) {
     }
   }
   const results = await unregisterClients();
-  printRegistrationResults(results);
+  for (const result of results) {
+    if (result.client.startsWith("Other MCP clients")) continue;
+    if (result.action === "registered") {
+      process.stdout.write(`${result.client} disconnected.
+`);
+    } else if (result.action === "error") {
+      process.stderr.write(`Could not disconnect ${result.client}: ${result.detail}
+`);
+    }
+  }
   if (results.some((result) => result.action === "error")) {
     process.stderr.write(
-      "Uninstall stopped before removing the runtime or browser host because one or more client registrations could not be removed. Fix the \u2717 messages above and retry.\n"
+      "Uninstall stopped before removing the remaining files. Fix the message above and try again.\n"
     );
     return 1;
   }
@@ -3889,7 +4114,9 @@ function collapse(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 export {
-  main
+  formatInstallSuccess,
+  main,
+  summarizeClientRegistrations
 };
 /*! Bundled license information: