@tekmidian/pai 0.13.3 → 0.13.5

package/dist/cli/index.mjs

@@ -6,7 +6,7 @@ import "../db-CmYbAVCD.mjs";
 import "../helpers-IjZkXBhj.mjs";
 import "../embeddings-BJPOcbik.mjs";
 import "../search-HcdKtMla.mjs";
-import "../pick-DhF8-WFT.mjs";
+import "../pick-CsHZ8Abv.mjs";
 import "../kg-extraction-C8DEUHTS.mjs";
 import "../factory-Q88X1bAN.mjs";
 import "../config-C8m-tPhP.mjs";

package/dist/cli/program.mjs

@@ -5,7 +5,7 @@ import "../db-CmYbAVCD.mjs";
 import "../helpers-IjZkXBhj.mjs";
 import "../embeddings-BJPOcbik.mjs";
 import "../search-HcdKtMla.mjs";
-import { C as registerDaemonCommands, D as registerProjectsCommands, E as registerRegistryCommands, O as findMovedPath, S as registerBackupCommands, T as registerMemoryCommands, _ as registerObservationCommands, a as cmdPauseAll, b as registerSetupCommand, c as cmdPause, d as registerKgCommands, f as registerTopicCommands, g as registerSkillCommands, h as registerUpdateCommand, i as cmdClearNames, k as resolveIdentifier, l as registerHelpCommand, m as registerNotifyCommands, n as cmdFind, o as cmdGoto, p as registerTaskCommands, r as cmdList, s as cmdEnd, t as cmdPick, u as registerDbCommands, v as registerZettelCommands, w as registerMcpCommands, x as registerRestoreCommands, y as registerObsidianCommands } from "../pick-DhF8-WFT.mjs";
+import { C as registerDaemonCommands, D as registerProjectsCommands, E as registerRegistryCommands, O as findMovedPath, S as registerBackupCommands, T as registerMemoryCommands, _ as registerObservationCommands, a as cmdPauseAll, b as registerSetupCommand, c as cmdPause, d as registerKgCommands, f as registerTopicCommands, g as registerSkillCommands, h as registerUpdateCommand, i as cmdClearNames, k as resolveIdentifier, l as registerHelpCommand, m as registerNotifyCommands, n as cmdFind, o as cmdGoto, p as registerTaskCommands, r as cmdList, s as cmdEnd, t as cmdPick, u as registerDbCommands, v as registerZettelCommands, w as registerMcpCommands, x as registerRestoreCommands, y as registerObsidianCommands } from "../pick-CsHZ8Abv.mjs";
 import "../kg-extraction-C8DEUHTS.mjs";
 import "../factory-Q88X1bAN.mjs";
 import "../config-C8m-tPhP.mjs";

package/dist/{pick-DhF8-WFT.mjs → pick-CsHZ8Abv.mjs}

@@ -1898,9 +1898,80 @@ function registerMemoryCommands(memoryCmd, getDb) {
 	registerStatsCommands(memoryCmd, getDb);
 }
 
+//#endregion
+//#region src/config/claude-json.ts
+/**
+* claude-json.ts — safe read/write for ~/.claude.json
+*
+* This file is not ours. It holds every MCP server registration plus Claude
+* Code's own per-project state — on a working machine, hundreds of kilobytes
+* that no one can reconstruct by hand. PAI only ever adds one key to it.
+*
+* The previous implementation (duplicated in mcp.ts and daemon.ts) did:
+*
+*     try { return JSON.parse(read(path)); } catch { return {}; }
+*
+* followed by a full-file write. A malformed or transiently unreadable file
+* therefore became an empty object, and the next write replaced the user's
+* entire config with just PAI's entry. No error, no backup, exit code 0.
+*
+* The precondition is unlikely, which is exactly the problem: `pai setup` is
+* advertised as idempotent and safe to re-run, so it is what people run when
+* something is already broken — the state in which the file is most likely to
+* be malformed.
+*/
+const CLAUDE_JSON_PATH = join(homedir(), ".claude.json");
+const BACKUP_PATH = `${CLAUDE_JSON_PATH}.bak-pai`;
+/**
+* Read ~/.claude.json.
+*
+* A missing file is a legitimate first-run state and yields {}. Anything else
+* — malformed JSON, permissions, a half-written file — throws. Returning {}
+* for an unreadable file is what turns a read problem into data loss on the
+* next write.
+*/
+function readClaudeJson() {
+	if (!existsSync(CLAUDE_JSON_PATH)) return {};
+	let raw;
+	try {
+		raw = readFileSync(CLAUDE_JSON_PATH, "utf8");
+	} catch (e) {
+		throw new Error(`Could not read ${CLAUDE_JSON_PATH}: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — writing now would replace your MCP registrations with PAI's alone.`);
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (e) {
+		throw new Error(`${CLAUDE_JSON_PATH} is not valid JSON: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — overwriting it would destroy every MCP server registration it holds.\nFix the file, or move it aside and let Claude Code recreate it, then re-run this command.`);
+	}
+}
+/**
+* Write ~/.claude.json, keeping a backup and never leaving it half-written.
+*
+* Writes to a temp file and renames: rename is atomic within a filesystem, so
+* a crash mid-write leaves the original intact rather than truncated. The
+* previous direct writeFileSync could truncate the file and then fail.
+*/
+function writeClaudeJson(data) {
+	const serialized = JSON.stringify(data, null, 2) + "\n";
+	if (existsSync(CLAUDE_JSON_PATH)) try {
+		copyFileSync(CLAUDE_JSON_PATH, BACKUP_PATH);
+	} catch (e) {
+		throw new Error(`Could not back up ${CLAUDE_JSON_PATH} to ${BACKUP_PATH}: ${e instanceof Error ? e.message : String(e)}\nRefusing to write without a backup.`);
+	}
+	const tmp = `${CLAUDE_JSON_PATH}.tmp-pai-${process.pid}`;
+	try {
+		writeFileSync(tmp, serialized, "utf8");
+		renameSync(tmp, CLAUDE_JSON_PATH);
+	} catch (e) {
+		try {
+			if (existsSync(tmp)) unlinkSync(tmp);
+		} catch {}
+		throw new Error(`Failed to write ${CLAUDE_JSON_PATH}: ${e instanceof Error ? e.message : String(e)}\nThe original is unchanged${existsSync(BACKUP_PATH) ? `; a backup is at ${BACKUP_PATH}` : ""}.`);
+	}
+}
+
 //#endregion
 //#region src/cli/commands/mcp.ts
-const CLAUDE_JSON_PATH$1 = join(homedir(), ".claude.json");
 /**
 * Resolve the absolute path to the built MCP entry point.
 *
@@ -1911,21 +1982,9 @@ const CLAUDE_JSON_PATH$1 = join(homedir(), ".claude.json");
 function getMcpBinPath() {
 	return join(dirname(fileURLToPath(import.meta.url)), "../mcp/index.mjs");
 }
-function readClaudeJson$1() {
-	if (!existsSync(CLAUDE_JSON_PATH$1)) return {};
-	try {
-		const raw = readFileSync(CLAUDE_JSON_PATH$1, "utf8");
-		return JSON.parse(raw);
-	} catch {
-		return {};
-	}
-}
-function writeClaudeJson$1(data) {
-	writeFileSync(CLAUDE_JSON_PATH$1, JSON.stringify(data, null, 2) + "\n", "utf8");
-}
 function cmdInstall$1() {
 	const mcpBin = getMcpBinPath();
-	const config = readClaudeJson$1();
+	const config = readClaudeJson();
 	if (typeof config.mcpServers !== "object" || config.mcpServers === null) config.mcpServers = {};
 	const servers = config.mcpServers;
 	if ("pai" in servers) {
@@ -1939,7 +1998,7 @@ function cmdInstall$1() {
 		args: [mcpBin]
 	};
 	try {
-		writeClaudeJson$1(config);
+		writeClaudeJson(config);
 	} catch (e) {
 		console.error(err(`Failed to write ~/.claude.json: ${e}`));
 		process.exit(1);
@@ -1958,7 +2017,7 @@ function cmdInstall$1() {
 }
 function cmdStatus$3() {
 	const mcpBin = getMcpBinPath();
-	const config = readClaudeJson$1();
+	const config = readClaudeJson();
 	const servers = typeof config.mcpServers === "object" && config.mcpServers !== null ? config.mcpServers : {};
 	const registered = "pai" in servers;
 	const binExists = existsSync(mcpBin);
@@ -1997,7 +2056,6 @@ function registerMcpCommands(mcpCmd) {
 //#endregion
 //#region src/cli/commands/daemon.ts
 const HOME$2 = homedir();
-const CLAUDE_JSON_PATH = join(HOME$2, ".claude.json");
 const PLIST_LABEL = "com.pai.pai-daemon";
 const LAUNCH_AGENTS_DIR = join(HOME$2, "Library", "LaunchAgents");
 const PLIST_PATH = join(LAUNCH_AGENTS_DIR, `${PLIST_LABEL}.plist`);
@@ -2017,18 +2075,6 @@ function getDaemonBinPath() {
 function getShimBinPath() {
 	return join(dirname(fileURLToPath(import.meta.url)), "../daemon-mcp/index.mjs");
 }
-function readClaudeJson() {
-	if (!existsSync(CLAUDE_JSON_PATH)) return {};
-	try {
-		const raw = readFileSync(CLAUDE_JSON_PATH, "utf8");
-		return JSON.parse(raw);
-	} catch {
-		return {};
-	}
-}
-function writeClaudeJson(data) {
-	writeFileSync(CLAUDE_JSON_PATH, JSON.stringify(data, null, 2) + "\n", "utf8");
-}
 function generatePlist(daemonBin) {
 	return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -2624,6 +2670,86 @@ function registerRestoreCommands(program) {
 	});
 }
 
+//#endregion
+//#region src/config/json-store.ts
+/**
+* json-store.ts — read/write JSON config files without destroying them
+*
+* The failure this exists to prevent:
+*
+*     try { return JSON.parse(read(path)); } catch { return {}; }
+*     ... later ...
+*     write(path, JSON.stringify(ourData));
+*
+* An unreadable file becomes an empty object, and the next write makes that
+* permanent. Silently, exit code 0. This shape appeared three times in this
+* repo against three different files, and twice in AIBroker.
+*
+* The distinction that matters is between *missing* and *unreadable*:
+*
+*   missing     — legitimate first run. Start fresh; writing is safe.
+*   unreadable  — the file exists and we could not parse it. Those bytes are
+*                 the only copy of something. Never overwrite them.
+*
+* Collapsing the second into the first is the bug.
+*
+* NOT everything deserves this guard. For a transient buffer — an undelivered
+* message queue, a cache — starting fresh IS the correct recovery, and
+* refusing to write would disable the feature permanently. Use `writeJsonAtomic`
+* alone there: it still prevents a crash from truncating a good file, without
+* blocking recovery. Reserve `readJsonStrict` for data a user cannot rebuild.
+*/
+/**
+* Read a JSON file, distinguishing "absent" from "damaged".
+*
+* @param path   file to read
+* @param label  how to name it to the user, e.g. "~/.claude.json"
+* @throws if the file exists but cannot be read or parsed
+*/
+function readJsonStrict(path, label = path) {
+	if (!existsSync(path)) return {};
+	let raw;
+	try {
+		raw = readFileSync(path, "utf8");
+	} catch (e) {
+		throw new Error(`Could not read ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — writing now would replace its contents with ours alone.`);
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (e) {
+		throw new Error(`${label} exists but is not valid JSON: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — overwriting it would destroy whatever it holds.\nRepair the file, or move it aside and re-run this command.`);
+	}
+}
+/**
+* Write JSON without risking the existing file.
+*
+* Keeps a `.bak-pai` copy of the previous contents, then writes to a temp file
+* and renames. Rename is atomic within a filesystem, so a crash mid-write
+* leaves the original intact rather than truncated — which is how these files
+* become corrupt in the first place.
+*/
+function writeJsonAtomic(path, data, opts = {}) {
+	const { backup = true, label = path } = opts;
+	const serialized = JSON.stringify(data, null, 2) + "\n";
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	if (backup && existsSync(path)) try {
+		copyFileSync(path, `${path}.bak-pai`);
+	} catch (e) {
+		throw new Error(`Could not back up ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to write without a backup.`);
+	}
+	const tmp = `${path}.tmp-pai-${process.pid}`;
+	try {
+		writeFileSync(tmp, serialized, "utf8");
+		renameSync(tmp, path);
+	} catch (e) {
+		try {
+			if (existsSync(tmp)) unlinkSync(tmp);
+		} catch {}
+		throw new Error(`Failed to write ${label}: ${e instanceof Error ? e.message : String(e)}\nThe original is unchanged.`);
+	}
+}
+
 //#endregion
 //#region src/cli/commands/setup/utils.ts
 /**
@@ -2695,17 +2821,18 @@ async function promptYesNo(rl, question, defaultYes = true) {
 	if (answer === "") return defaultYes;
 	return answer.toLowerCase().startsWith("y");
 }
+/**
+* This file holds the Postgres connection string, the storage backend choice,
+* notification routing and any tracker API token — none of which the user can
+* reconstruct from memory. It previously returned {} on a parse failure and
+* then overwrote the file, so a damaged config was replaced by whatever the
+* current command happened to be setting.
+*/
 function readConfigRaw() {
-	if (!existsSync(CONFIG_FILE$2)) return {};
-	try {
-		return JSON.parse(readFileSync(CONFIG_FILE$2, "utf-8"));
-	} catch {
-		return {};
-	}
+	return readJsonStrict(CONFIG_FILE$2, "~/.config/pai/config.json");
 }
 function writeConfigRaw(data) {
-	if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
-	writeFileSync(CONFIG_FILE$2, JSON.stringify(data, null, 2) + "\n", "utf-8");
+	writeJsonAtomic(CONFIG_FILE$2, data, { label: "~/.config/pai/config.json" });
 }
 function mergeConfig(updates) {
 	const current = readConfigRaw();
@@ -3388,27 +3515,18 @@ async function stepTsHooks(rl) {
 
 //#endregion
 //#region src/cli/commands/settings-manager.ts
+const SETTINGS_FILE = join(join(homedir(), ".claude"), "settings.json");
 /**
-* settings-manager — merge-not-overwrite utility for ~/.claude/settings.json
-*
-* Provides safe, idempotent writes to Claude Code's settings.json:
-*   - env vars: added only if the key is absent (never overwrites)
-*   - hooks: appended per hookType, deduplicated by command string
-*   - statusLine: written only if the key is not already present
+* ~/.claude/settings.json is Claude Code's own file, not ours: hooks, env,
+* permissions, statusline, enabled plugins. PAI only ever adds to it. Returning
+* {} for a damaged file and then writing meant a stray parse error could strip
+* every hook registration the user had.
 */
-const CLAUDE_DIR = join(homedir(), ".claude");
-const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
 function readSettingsJson() {
-	if (!existsSync(SETTINGS_FILE)) return {};
-	try {
-		return JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
-	} catch {
-		return {};
-	}
+	return readJsonStrict(SETTINGS_FILE, "~/.claude/settings.json");
 }
 function writeSettingsJson(data) {
-	if (!existsSync(CLAUDE_DIR)) mkdirSync(CLAUDE_DIR, { recursive: true });
-	writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2) + "\n", "utf-8");
+	writeJsonAtomic(SETTINGS_FILE, data, { label: "~/.claude/settings.json" });
 }
 /**
 * Merge env vars — add keys that are absent, never overwrite existing ones.
@@ -6048,7 +6166,7 @@ function stepVerifyRepo() {
 	const gitDir = capture("git rev-parse --show-toplevel", getPaiSrcDir());
 	if (!gitDir) {
 		error("Not a git repository. Cannot update automatically.");
-		info("Install PAI via npm to get automatic updates: npm install -g @mnott/pai");
+		info("Install PAI via npm to get automatic updates: npm install -g @tekmidian/pai");
 		return null;
 	}
 	const remote = capture("git remote get-url origin", gitDir);
@@ -9015,4 +9133,4 @@ async function cmdPick(db, opts = {}) {
 
 //#endregion
 export { registerDaemonCommands as C, registerProjectsCommands as D, registerRegistryCommands as E, findMovedPath as O, registerBackupCommands as S, registerMemoryCommands as T, registerObservationCommands as _, cmdPauseAll as a, registerSetupCommand as b, cmdPause as c, registerKgCommands as d, registerTopicCommands as f, registerSkillCommands as g, registerUpdateCommand as h, cmdClearNames as i, resolveIdentifier as k, registerHelpCommand as l, registerNotifyCommands as m, cmdFind as n, cmdGoto as o, registerTaskCommands as p, cmdList as r, cmdEnd as s, cmdPick as t, registerDbCommands as u, registerZettelCommands as v, registerMcpCommands as w, registerRestoreCommands as x, registerObsidianCommands as y };
-//# sourceMappingURL=pick-DhF8-WFT.mjs.map
+//# sourceMappingURL=pick-CsHZ8Abv.mjs.map