moneyswitch 0.5.0

package/dist/desktop.js

@@ -0,0 +1,2699 @@
+// src/desktop/ui.ts
+import { spawn } from "node:child_process";
+import path6 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../connect/dist/lib/runner.js
+import { spawnSync } from "node:child_process";
+function quoteWinArg(arg) {
+  if (arg.length > 0 && !/[\s"&|<>^%()!,;=]/.test(arg))
+    return arg;
+  return `"${arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1")}"`;
+}
+var RealCommandRunner = class {
+  opts;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  run(cmd, args) {
+    const win = process.platform === "win32";
+    try {
+      const res = win ? spawnSync([cmd, ...args].map(quoteWinArg).join(" "), {
+        encoding: "utf8",
+        shell: true,
+        env: this.opts.env ?? process.env,
+        cwd: this.opts.cwd,
+        timeout: this.opts.timeoutMs
+      }) : spawnSync(cmd, args, {
+        encoding: "utf8",
+        env: this.opts.env ?? process.env,
+        cwd: this.opts.cwd,
+        timeout: this.opts.timeoutMs
+      });
+      if (res.error) {
+        return { ok: false, code: null, stdout: "", stderr: String(res.error.message ?? res.error) };
+      }
+      return {
+        ok: (res.status ?? 1) === 0,
+        code: res.status,
+        stdout: res.stdout ?? "",
+        stderr: res.stderr ?? ""
+      };
+    } catch (e) {
+      return { ok: false, code: null, stdout: "", stderr: e.message };
+    }
+  }
+};
+
+// src/desktop/server.ts
+import http from "node:http";
+import fs4 from "node:fs";
+import path5 from "node:path";
+
+// src/desktop/session.ts
+import crypto from "node:crypto";
+var COOKIE_NAME = "ms_desktop_session";
+function randomToken(bytes = 32) {
+  return crypto.randomBytes(bytes).toString("base64url");
+}
+function safeEqual(a, b) {
+  const ab = Buffer.from(a);
+  const bb = Buffer.from(b);
+  return ab.length === bb.length && crypto.timingSafeEqual(ab, bb);
+}
+var SessionManager = class {
+  constructor(port, token = randomToken()) {
+    this.port = port;
+    this.oneTimeToken = token;
+  }
+  port;
+  oneTimeToken;
+  sessions = /* @__PURE__ */ new Map();
+  /** The token to put in the launch URL fragment. Null once it has been used. */
+  get pendingToken() {
+    return this.oneTimeToken;
+  }
+  /** Mint a fresh one-time token (e.g. `moneyswitch ui` asked to re-open the browser). */
+  rotateToken() {
+    this.oneTimeToken = randomToken();
+    return this.oneTimeToken;
+  }
+  /** Exchange the one-time token for a session id. Returns null if wrong or already used. */
+  exchange(token) {
+    if (typeof token !== "string" || !this.oneTimeToken) return null;
+    if (!safeEqual(token, this.oneTimeToken)) return null;
+    this.oneTimeToken = null;
+    const sid = randomToken();
+    this.sessions.set(sid, { createdAt: Date.now() });
+    return sid;
+  }
+  isValid(sid) {
+    return typeof sid === "string" && this.sessions.has(sid);
+  }
+  revoke(sid) {
+    this.sessions.delete(sid);
+  }
+  cookieHeader(sid) {
+    return `${COOKIE_NAME}=${sid}; HttpOnly; SameSite=Strict; Path=/`;
+  }
+  /** Origins this server accepts (exact match, scheme+host+port). */
+  allowedOrigins() {
+    return [`http://127.0.0.1:${this.port}`, `http://localhost:${this.port}`];
+  }
+  allowedHosts() {
+    return [`127.0.0.1:${this.port}`, `localhost:${this.port}`];
+  }
+};
+function readCookie(header, name) {
+  if (!header) return null;
+  for (const part of header.split(";")) {
+    const i = part.indexOf("=");
+    if (i === -1) continue;
+    if (part.slice(0, i).trim() === name) return part.slice(i + 1).trim();
+  }
+  return null;
+}
+function guardRequest(sm, req) {
+  const host = String(req.headers.host ?? "").toLowerCase();
+  if (!sm.allowedHosts().includes(host)) {
+    return { status: 421, code: "BAD_HOST", message: "unexpected Host header" };
+  }
+  const method = (req.method ?? "GET").toUpperCase();
+  const url = req.url ?? "/";
+  const isApi = url.startsWith("/api/");
+  const mutating = method !== "GET" && method !== "HEAD" && method !== "OPTIONS";
+  if (isApi && mutating) {
+    const origin = req.headers.origin;
+    if (typeof origin !== "string" || !sm.allowedOrigins().includes(origin)) {
+      return { status: 403, code: "BAD_ORIGIN", message: "cross-origin request refused" };
+    }
+    const ct = String(req.headers["content-type"] ?? "");
+    if (!ct.toLowerCase().startsWith("application/json")) {
+      return { status: 415, code: "JSON_REQUIRED", message: "Content-Type must be application/json" };
+    }
+  }
+  if (isApi && !(method === "POST" && url.split("?")[0] === "/api/session")) {
+    const sid = readCookie(req.headers.cookie, COOKIE_NAME);
+    if (!sm.isValid(sid)) return { status: 401, code: "NO_SESSION", message: "open the link printed by `moneyswitch ui`" };
+  }
+  return null;
+}
+
+// src/desktop/service.ts
+import os2 from "node:os";
+
+// ../connect/dist/lib/mcp-entry.js
+import { createRequire } from "node:module";
+function resolveMcpCommand(fromUrl = import.meta.url) {
+  const require2 = createRequire(fromUrl);
+  try {
+    const entry = require2.resolve("@moneyswitch/mcp");
+    return { command: "node", args: [entry] };
+  } catch {
+    return { command: "npx", args: ["-y", "moneyswitch", "mcp"] };
+  }
+}
+function isNpmRegistryFallback(cmd) {
+  return cmd.command === "npx" && cmd.args.length === 3 && cmd.args[0] === "-y" && cmd.args[1] === "moneyswitch" && cmd.args[2] === "mcp";
+}
+async function resolvePortableMcpCommand(server, fetchImpl = fetch) {
+  const base = server.replace(/\/+$/, "");
+  const tarballUrl = `${base}/dl/moneyswitch.tgz`;
+  try {
+    const res = await fetchImpl(tarballUrl, { method: "HEAD" });
+    if (res.ok)
+      return { command: "npx", args: ["-y", `--package=${tarballUrl}`, "moneyswitch", "mcp"] };
+  } catch {
+  }
+  return { command: "npx", args: ["-y", "moneyswitch", "mcp"] };
+}
+
+// src/desktop/agents.ts
+import fs from "node:fs";
+import path2 from "node:path";
+
+// src/desktop/paths.ts
+import path from "node:path";
+import os from "node:os";
+function homeDir(env) {
+  if (process.platform === "win32") {
+    if (env.USERPROFILE) return env.USERPROFILE;
+    if (env.HOME) return env.HOME;
+  } else if (env.HOME) {
+    return env.HOME;
+  }
+  return os.homedir();
+}
+function claudeConfigDir(env) {
+  return env.CLAUDE_CONFIG_DIR ? env.CLAUDE_CONFIG_DIR : path.join(homeDir(env), ".claude");
+}
+function claudeSettingsPath(env) {
+  return path.join(claudeConfigDir(env), "settings.json");
+}
+function claudeJsonPath(env) {
+  return env.CLAUDE_CONFIG_DIR ? path.join(env.CLAUDE_CONFIG_DIR, ".claude.json") : path.join(homeDir(env), ".claude.json");
+}
+function codexConfigFile(env) {
+  const home = env.CODEX_HOME ? env.CODEX_HOME : path.join(homeDir(env), ".codex");
+  return path.join(home, "config.toml");
+}
+function desktopDir(env) {
+  return path.join(homeDir(env), ".moneyswitch");
+}
+function desktopStorePath(env) {
+  return path.join(desktopDir(env), "desktop.json");
+}
+function displayPath(p, env) {
+  const home = homeDir(env);
+  const norm = (s) => s.replace(/\\/g, "/");
+  const np = norm(p);
+  const nh = norm(home).replace(/\/+$/, "");
+  if (np.toLowerCase().startsWith(nh.toLowerCase() + "/")) return "~" + np.slice(nh.length);
+  return np;
+}
+
+// src/desktop/plan.ts
+import crypto2 from "node:crypto";
+function maskSecret(value) {
+  if (value == null) return "";
+  const v = String(value);
+  if (v.length <= 10) return "\u2022\u2022\u2022\u2022";
+  const head = v.startsWith("mk_live_") ? 12 : Math.min(7, Math.floor(v.length / 4));
+  return `${v.slice(0, head)}\u2026${v.slice(-4)}`;
+}
+var AUTO_AGENTS = ["claude", "codex"];
+var ALL_AGENTS = ["claude", "codex", "workbuddy", "openclaw", "cherry"];
+function fieldChange(field, before, after, secret = false) {
+  const b = before ?? null;
+  const a = after ?? null;
+  const op = b === a ? "same" : b === null ? "add" : a === null ? "remove" : "update";
+  return {
+    field,
+    op,
+    before: secret && b !== null ? maskSecret(b) : b,
+    after: secret && a !== null ? maskSecret(a) : a,
+    ...secret ? { secret: true } : {}
+  };
+}
+function sha256(text) {
+  return crypto2.createHash("sha256").update(text).digest("hex");
+}
+function stableStringify(v) {
+  if (v === null || typeof v !== "object") return JSON.stringify(v);
+  if (Array.isArray(v)) return `[${v.map(stableStringify).join(",")}]`;
+  const o = v;
+  return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(o[k])}`).join(",")}}`;
+}
+function deepEqual(a, b) {
+  return stableStringify(a) === stableStringify(b);
+}
+
+// src/desktop/agents.ts
+var AGENT_INFO = {
+  claude: { id: "claude", name: "Claude Code", mode: "auto" },
+  codex: { id: "codex", name: "Codex", mode: "auto" },
+  workbuddy: { id: "workbuddy", name: "WorkBuddy", mode: "manual" },
+  openclaw: { id: "openclaw", name: "OpenClaw", mode: "manual" },
+  cherry: { id: "cherry", name: "Cherry Studio", mode: "manual" }
+};
+function firstLine(s) {
+  return s.split(/\r?\n/).find((l) => l.trim())?.trim() ?? "";
+}
+function viaCli(runner, cmd) {
+  const r = runner.run(cmd, ["--version"]);
+  if (!r.ok) return null;
+  return { installed: true, version: firstLine(r.stdout) || null, via: `${cmd} --version` };
+}
+function viaPath(env, candidates) {
+  const home = homeDir(env);
+  for (const c of candidates) {
+    const abs = c.startsWith("~") ? path2.join(home, c.slice(2)) : c;
+    if (fs.existsSync(abs)) return { installed: true, version: null, via: c };
+  }
+  return null;
+}
+var NONE = { installed: false, version: null, via: null };
+function detectAgents(env, runner) {
+  const appData = env.APPDATA ?? path2.join(homeDir(env), "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA ?? path2.join(homeDir(env), "AppData", "Local");
+  const cherryDirs = process.platform === "win32" ? [path2.join(appData, "CherryStudio")] : process.platform === "darwin" ? ["~/Library/Application Support/CherryStudio"] : ["~/.config/CherryStudio"];
+  return {
+    claude: viaCli(runner, "claude") ?? NONE,
+    codex: viaCli(runner, "codex") ?? NONE,
+    workbuddy: viaPath(env, ["~/.workbuddy", path2.join(localAppData, "Programs", "WorkBuddy")]) ?? NONE,
+    openclaw: viaPath(env, ["~/.openclaw"]) ?? viaCli(runner, "openclaw") ?? NONE,
+    cherry: viaPath(env, cherryDirs) ?? NONE
+  };
+}
+function mcpJson(server, key, mcp, mask) {
+  return JSON.stringify(
+    { mcpServers: { moneyswitch: { command: mcp.command, args: mcp.args, env: { MONEY_API_BASE: server, MONEY_API_KEY: mask ? maskSecret(key) : key } } } },
+    null,
+    2
+  );
+}
+function openclawPatch(brain, server, key, mcp, mask) {
+  const parts = ["{"];
+  if (brain) {
+    const model = brain.model || "<model>";
+    parts.push(
+      `  models: { mode: "merge", providers: { moneyswitch_brain: { baseUrl: ${JSON.stringify(brain.baseUrl || "<base url>")}, apiKey: ${JSON.stringify(mask ? "<API key>" : brain.apiKey || "<API key>")}, api: "openai-completions", models: [{ id: ${JSON.stringify(model)}, name: ${JSON.stringify(model)} }] } } },`,
+      `  agents: { defaults: { model: { primary: ${JSON.stringify(`moneyswitch_brain/${model}`)} } } },`
+    );
+  }
+  if (server && key) {
+    parts.push(
+      `  mcp: { servers: { moneyswitch: { command: ${JSON.stringify(mcp.command)}, args: ${JSON.stringify(mcp.args)}, env: { MONEY_API_BASE: ${JSON.stringify(server)}, MONEY_API_KEY: ${JSON.stringify(mask ? maskSecret(key) : key)} } } } },`
+    );
+  }
+  parts.push("}");
+  return parts.join("\n");
+}
+function manualSteps(agent, ctx) {
+  const { server, walletKey, mcp } = ctx;
+  const openaiBase = server ? `${server.replace(/\/+$/, "")}/v1` : "<server>/v1";
+  if (agent === "openclaw") {
+    if (!walletKey && !ctx.brain) return [];
+    const steps = [
+      {
+        titleKey: "stepOpenclawSave",
+        code: openclawPatch(ctx.brain, server, walletKey, mcp, true),
+        copy: openclawPatch(ctx.brain, server, walletKey, mcp, false)
+      },
+      { titleKey: "stepOpenclawDryRun", code: "openclaw config patch --file moneyswitch.json5 --dry-run", copy: "openclaw config patch --file moneyswitch.json5 --dry-run" },
+      { titleKey: "stepOpenclawApply", code: "openclaw config patch --file moneyswitch.json5\nopenclaw config validate\nopenclaw mcp list", copy: "openclaw config patch --file moneyswitch.json5" }
+    ];
+    return steps;
+  }
+  if (agent === "workbuddy" || agent === "cherry") {
+    const steps = [];
+    if (server && walletKey) {
+      steps.push({
+        titleKey: agent === "cherry" ? "stepCherryMcp" : "stepWorkbuddyMcp",
+        code: mcpJson(server, walletKey, mcp, true),
+        copy: mcpJson(server, walletKey, mcp, false)
+      });
+    }
+    steps.push({
+      titleKey: agent === "cherry" ? "stepCherryModel" : "stepWorkbuddyModel",
+      rows: [
+        { labelKey: "rowBaseUrl", value: openaiBase, copy: openaiBase },
+        ...walletKey ? [{ labelKey: "rowApiKey", value: maskSecret(walletKey), copy: walletKey }] : []
+      ]
+    });
+    return steps;
+  }
+  return [];
+}
+
+// ../connect/dist/lib/claude.js
+var SERVER_NAME = "moneyswitch";
+function applyClaude(runner, server, key, mcpCommand) {
+  const removed = runner.run("claude", ["mcp", "remove", SERVER_NAME, "-s", "user"]);
+  const added = runner.run("claude", [
+    "mcp",
+    "add",
+    SERVER_NAME,
+    "-s",
+    "user",
+    "-e",
+    `MONEY_API_BASE=${server}`,
+    "-e",
+    `MONEY_API_KEY=${key}`,
+    "--",
+    mcpCommand.command,
+    ...mcpCommand.args
+  ]);
+  return { removed, added };
+}
+function removeClaude(runner) {
+  return runner.run("claude", ["mcp", "remove", SERVER_NAME, "-s", "user"]);
+}
+
+// src/desktop/filetx.ts
+import fs2 from "node:fs";
+import path3 from "node:path";
+var FileTransaction = class {
+  touched = /* @__PURE__ */ new Map();
+  backups = [];
+  stamp;
+  constructor(stamp = Date.now()) {
+    this.stamp = stamp;
+  }
+  /** Take a backup of `file` (once per transaction). Call before anything modifies it, including agent CLIs. */
+  snapshot(file) {
+    const known = this.touched.get(file);
+    if (known) return known.backup;
+    const existed = fs2.existsSync(file);
+    let backup = null;
+    if (existed) {
+      backup = `${file}.bak-${this.stamp}`;
+      let n = 1;
+      while (fs2.existsSync(backup)) backup = `${file}.bak-${this.stamp}-${n++}`;
+      fs2.copyFileSync(file, backup);
+      this.backups.push(backup);
+    }
+    this.touched.set(file, { backup, existed });
+    return backup;
+  }
+  /** Write `content` to `file` (snapshotting first), then re-read and run `verify` on what is actually on disk. */
+  write(file, content, verify) {
+    this.snapshot(file);
+    fs2.mkdirSync(path3.dirname(file), { recursive: true });
+    fs2.writeFileSync(file, content, "utf8");
+    const back = fs2.readFileSync(file, "utf8");
+    if (back !== content) throw new Error(`read-back mismatch for ${file}`);
+    verify?.(back);
+  }
+  /** Delete `file` (snapshotting first). */
+  remove(file) {
+    this.snapshot(file);
+    if (fs2.existsSync(file)) fs2.rmSync(file);
+  }
+  /** Restore every touched file to its pre-transaction state. Never throws; returns what failed. */
+  rollback() {
+    const errors = [];
+    for (const [file, { backup, existed }] of this.touched) {
+      try {
+        if (existed && backup) fs2.copyFileSync(backup, file);
+        else if (!existed && fs2.existsSync(file)) fs2.rmSync(file);
+      } catch (e) {
+        errors.push(`${file}: ${e.message}`);
+      }
+    }
+    return errors;
+  }
+};
+function readIfExists(file) {
+  try {
+    return fs2.readFileSync(file, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
+}
+
+// src/desktop/presets.ts
+var CLAUDE_PRESETS = [
+  {
+    id: "anthropic",
+    label: "Anthropic",
+    baseUrl: "https://api.anthropic.com",
+    models: ["claude-sonnet-4-5", "claude-haiku-4-5"],
+    authVar: "ANTHROPIC_API_KEY",
+    keyHint: "sk-ant-\u2026"
+  },
+  {
+    id: "openrouter",
+    label: "OpenRouter",
+    baseUrl: "https://openrouter.ai/api",
+    models: ["anthropic/claude-sonnet-4.5"],
+    authVar: "ANTHROPIC_AUTH_TOKEN",
+    keyHint: "sk-or-\u2026"
+  },
+  {
+    id: "deepseek",
+    label: "DeepSeek",
+    baseUrl: "https://api.deepseek.com/anthropic",
+    models: ["deepseek-chat", "deepseek-reasoner"],
+    authVar: "ANTHROPIC_AUTH_TOKEN",
+    keyHint: "sk-\u2026"
+  },
+  {
+    id: "custom",
+    label: "Custom",
+    baseUrl: "",
+    models: [],
+    authVar: "ANTHROPIC_AUTH_TOKEN",
+    noteKey: "presetCustomClaude"
+  }
+];
+var CODEX_PRESETS = [
+  {
+    id: "openai",
+    label: "OpenAI",
+    baseUrl: "https://api.openai.com/v1",
+    models: ["gpt-6-sol", "gpt-5-codex"],
+    keyHint: "sk-\u2026"
+  },
+  {
+    id: "openrouter",
+    label: "OpenRouter",
+    baseUrl: "https://openrouter.ai/api/v1",
+    models: ["openai/gpt-5", "anthropic/claude-sonnet-4.5"],
+    keyHint: "sk-or-\u2026"
+  },
+  {
+    id: "deepseek",
+    label: "DeepSeek",
+    baseUrl: "https://api.deepseek.com/v1",
+    models: ["deepseek-chat"],
+    keyHint: "sk-\u2026",
+    noteKey: "presetDeepseekCodex"
+  },
+  {
+    id: "custom",
+    label: "Custom",
+    baseUrl: "",
+    models: [],
+    noteKey: "presetCustomCodex"
+  }
+];
+function presetsFor(agent) {
+  if (agent === "claude") return CLAUDE_PRESETS;
+  if (agent === "codex") return CODEX_PRESETS;
+  return [];
+}
+function claudeAuthVar(presetId) {
+  return CLAUDE_PRESETS.find((p) => p.id === presetId)?.authVar ?? "ANTHROPIC_AUTH_TOKEN";
+}
+
+// src/desktop/claude.ts
+function toMcpEntry(j) {
+  if (!j || typeof j.command !== "string") return null;
+  const env = {};
+  for (const [k, v] of Object.entries(j.env ?? {})) if (typeof v === "string") env[k] = v;
+  return { command: j.command, args: Array.isArray(j.args) ? j.args.map(String) : [], env };
+}
+function addMcpEntry(runner, e) {
+  const envArgs = Object.entries(e.env).flatMap(([k, v]) => ["-e", `${k}=${v}`]);
+  return runner.run("claude", ["mcp", "add", "moneyswitch", "-s", "user", ...envArgs, "--", e.command, ...e.args]);
+}
+function parseJsonObject(text, file) {
+  if (text === null || text.trim() === "") return {};
+  let v;
+  try {
+    v = JSON.parse(text);
+  } catch (e) {
+    throw new AgentConfigError("PARSE_FAILED", `${file} is not valid JSON (${e.message}); fix it by hand first \u2014 nothing was written.`);
+  }
+  if (!v || typeof v !== "object" || Array.isArray(v)) throw new AgentConfigError("PARSE_FAILED", `${file} is not a JSON object; nothing was written.`);
+  return v;
+}
+var AgentConfigError = class extends Error {
+  constructor(code, message, detail) {
+    super(message);
+    this.code = code;
+    this.detail = detail;
+  }
+  code;
+  detail;
+};
+function envOf(settings) {
+  const e = settings.env;
+  return e && typeof e === "object" && !Array.isArray(e) ? e : {};
+}
+function str(v) {
+  return typeof v === "string" ? v : v == null ? null : String(v);
+}
+function brainEnv(brain) {
+  const authVar = claudeAuthVar(brain.preset);
+  const other = authVar === "ANTHROPIC_API_KEY" ? "ANTHROPIC_AUTH_TOKEN" : "ANTHROPIC_API_KEY";
+  const out = {
+    ANTHROPIC_BASE_URL: brain.baseUrl.replace(/\/+$/, ""),
+    [authVar]: brain.apiKey,
+    // Remove the other auth variable so Claude Code cannot pick a stale key for this endpoint.
+    [other]: null
+  };
+  if (brain.model.trim()) out.ANTHROPIC_MODEL = brain.model.trim();
+  return out;
+}
+function readMcpEntry(env) {
+  const file = claudeJsonPath(env);
+  const text = readIfExists(file);
+  if (text === null) return null;
+  try {
+    const j = JSON.parse(text);
+    const servers = j.mcpServers;
+    const entry = servers?.moneyswitch;
+    return entry && typeof entry === "object" ? entry : null;
+  } catch {
+    return null;
+  }
+}
+function mcpFields(entry) {
+  if (!entry) return { command: null, base: null, key: null };
+  const args = Array.isArray(entry.args) ? entry.args.map(String) : [];
+  const e = entry.env ?? {};
+  return {
+    command: [str(entry.command) ?? "", ...args].join(" ").trim() || null,
+    base: str(e.MONEY_API_BASE),
+    key: str(e.MONEY_API_KEY)
+  };
+}
+function prevOf(applied) {
+  return applied ? applied.previous : null;
+}
+function desiredEnv(target, prev) {
+  const want = target.brain ? brainEnv(target.brain) : {};
+  for (const [k, v] of Object.entries(prev?.env ?? {})) if (!(k in want)) want[k] = v;
+  return want;
+}
+function planClaude(env, action, target, applied) {
+  const settingsPath = claudeSettingsPath(env);
+  const settingsText = readIfExists(settingsPath);
+  const settings = parseJsonObject(settingsText, displayPath(settingsPath, env));
+  const curEnv = envOf(settings);
+  const prev = prevOf(applied);
+  const warnings = [];
+  const want = action === "enable" && target ? desiredEnv(target, prev) : { ...prev?.env ?? {} };
+  const envChanges = Object.keys(want).sort().map((k) => fieldChange(`env.${k}`, str(curEnv[k]), want[k], /KEY|TOKEN/.test(k)));
+  const files = [];
+  if (envChanges.some((c) => c.op !== "same")) {
+    files.push({ path: settingsPath, display: displayPath(settingsPath, env), exists: settingsText !== null, writer: "moneyswitch", changes: envChanges });
+  }
+  const commands = [];
+  const cur = mcpFields(readMcpEntry(env));
+  const jsonPath = claudeJsonPath(env);
+  const wantWallet = action === "enable" && target?.wallet ? target.wallet : null;
+  if (wantWallet && target) {
+    const cmd = [target.mcpCommand.command, ...target.mcpCommand.args].join(" ");
+    const changes = [
+      fieldChange("mcpServers.moneyswitch.command", cur.command, cmd),
+      fieldChange("mcpServers.moneyswitch.env.MONEY_API_BASE", cur.base, wantWallet.server),
+      fieldChange("mcpServers.moneyswitch.env.MONEY_API_KEY", cur.key, wantWallet.key, true)
+    ];
+    if (changes.some((c) => c.op !== "same")) {
+      files.push({ path: jsonPath, display: displayPath(jsonPath, env), exists: readIfExists(jsonPath) !== null, writer: "agent-cli", changes });
+      commands.push({
+        display: `claude mcp remove moneyswitch -s user`,
+        why: "replace"
+      });
+      commands.push({
+        display: `claude mcp add moneyswitch -s user -e MONEY_API_BASE=${wantWallet.server} -e MONEY_API_KEY=${maskSecret(wantWallet.key)} -- ${cmd}`,
+        why: "add"
+      });
+      if (cur.key && !prev?.mcpExisted && !applied?.parts.wallet) warnings.push("claudeReplacesExistingMcp");
+    }
+  } else if (applied?.parts.wallet && cur.key !== null) {
+    const restore = prev?.mcpEntry ?? null;
+    const r = restore ? { command: [restore.command, ...restore.args].join(" "), base: restore.env.MONEY_API_BASE ?? null, key: restore.env.MONEY_API_KEY ?? null } : { command: null, base: null, key: null };
+    files.push({
+      path: jsonPath,
+      display: displayPath(jsonPath, env),
+      exists: true,
+      writer: "agent-cli",
+      changes: [
+        fieldChange("mcpServers.moneyswitch.command", cur.command, r.command),
+        fieldChange("mcpServers.moneyswitch.env.MONEY_API_BASE", cur.base, r.base),
+        fieldChange("mcpServers.moneyswitch.env.MONEY_API_KEY", cur.key, r.key, true)
+      ]
+    });
+    commands.push({ display: "claude mcp remove moneyswitch -s user", why: "remove" });
+    if (restore) {
+      const envShown = Object.entries(restore.env).map(([k, v]) => `-e ${k}=${/KEY|TOKEN/.test(k) ? maskSecret(v) : v}`).join(" ");
+      commands.push({ display: `claude mcp add moneyswitch -s user ${envShown} -- ${r.command}`, why: "restore" });
+    }
+  }
+  const noop = files.length === 0 && commands.length === 0;
+  const inputHash = sha256(stableStringify({ settings: settingsText, mcp: cur }));
+  return { plan: { agent: "claude", action, files, commands, warnings, noop }, inputHash };
+}
+function claudeFingerprint(env, managedEnvKeys, walletManaged) {
+  const settings = (() => {
+    try {
+      return parseJsonObject(readIfExists(claudeSettingsPath(env)), "settings.json");
+    } catch {
+      return {};
+    }
+  })();
+  const e = envOf(settings);
+  const vals = {};
+  for (const k of [...managedEnvKeys].sort()) vals[k] = str(e[k]);
+  const mcp = walletManaged ? mcpFields(readMcpEntry(env)) : null;
+  return sha256(stableStringify({ env: vals, mcp: mcp ? { base: mcp.base, key: mcp.key } : null }));
+}
+function applyClaudePlan(env, action, target, applied, runner, now = /* @__PURE__ */ new Date()) {
+  const settingsPath = claudeSettingsPath(env);
+  const jsonPath = claudeJsonPath(env);
+  const settingsText = readIfExists(settingsPath);
+  const settings = parseJsonObject(settingsText, displayPath(settingsPath, env));
+  const curEnv = { ...envOf(settings) };
+  const prevRec = prevOf(applied);
+  const previous = prevRec ? { ...prevRec, env: { ...prevRec.env } } : { settingsExisted: settingsText !== null, hadEnv: settings.env !== void 0, env: {}, mcpExisted: readMcpEntry(env) !== null, mcpEntry: toMcpEntry(readMcpEntry(env)) };
+  const want = action === "enable" && target ? desiredEnv(target, prevRec) : { ...prevRec?.env ?? {} };
+  if (action === "enable") {
+    for (const k of Object.keys(want)) if (!(k in previous.env)) previous.env[k] = str(curEnv[k]);
+  }
+  const tx = new FileTransaction(now.getTime());
+  try {
+    const nextEnv = { ...curEnv };
+    for (const [k, v] of Object.entries(want)) {
+      if (v === null) delete nextEnv[k];
+      else nextEnv[k] = v;
+    }
+    const envChanged = stableStringify(nextEnv) !== stableStringify(curEnv);
+    if (envChanged) {
+      const next = { ...settings };
+      if (Object.keys(nextEnv).length === 0 && action === "disable" && !previous.hadEnv) delete next.env;
+      else next.env = nextEnv;
+      const restoreToNothing = action === "disable" && !previous.settingsExisted && Object.keys(next).length === 0;
+      if (restoreToNothing) {
+        tx.remove(settingsPath);
+      } else {
+        tx.write(settingsPath, JSON.stringify(next, null, 2) + "\n", (onDisk) => {
+          const back = envOf(JSON.parse(onDisk));
+          for (const [k, v] of Object.entries(want)) {
+            if (v === null && k in back || v !== null && back[k] !== v) {
+              throw new AgentConfigError("VERIFY_FAILED", `settings.json read-back: ${k} is not what was written`);
+            }
+          }
+        });
+      }
+    }
+    const wallet = action === "enable" && target?.wallet ? target.wallet : null;
+    const hadOurWallet = applied?.parts.wallet ?? false;
+    if (wallet && target) {
+      const cur = mcpFields(readMcpEntry(env));
+      const cmd = [target.mcpCommand.command, ...target.mcpCommand.args].join(" ");
+      if (cur.key !== wallet.key || cur.base !== wallet.server || cur.command !== cmd) {
+        tx.snapshot(jsonPath);
+        const res = applyClaude(runner, wallet.server, wallet.key, target.mcpCommand);
+        if (!res.added.ok) {
+          throw new AgentConfigError(
+            /not recognized|not found|ENOENT|不是内部或外部命令/i.test(res.added.stderr) ? "NOT_INSTALLED" : "CLI_FAILED",
+            `claude mcp add failed: ${(res.added.stderr || res.added.stdout).trim().slice(0, 400)}`
+          );
+        }
+        const after = mcpFields(readMcpEntry(env));
+        if (after.key !== wallet.key || after.base !== wallet.server) {
+          throw new AgentConfigError("VERIFY_FAILED", `claude mcp add reported success but ${displayPath(jsonPath, env)} has no matching mcpServers.moneyswitch`);
+        }
+      }
+    } else if (hadOurWallet && readMcpEntry(env) !== null) {
+      tx.snapshot(jsonPath);
+      const res = removeClaude(runner);
+      if (!res.ok || readMcpEntry(env) !== null) {
+        throw new AgentConfigError("CLI_FAILED", `claude mcp remove failed: ${(res.stderr || res.stdout).trim().slice(0, 400)}`);
+      }
+      const restore = previous.mcpEntry ?? null;
+      if (restore) {
+        const r = addMcpEntry(runner, restore);
+        const back = toMcpEntry(readMcpEntry(env));
+        if (!r.ok || !back || back.env.MONEY_API_KEY !== restore.env.MONEY_API_KEY) {
+          throw new AgentConfigError("CLI_FAILED", `restoring the previous moneyswitch MCP entry failed: ${(r.stderr || r.stdout).trim().slice(0, 400)}`);
+        }
+      }
+    }
+    if (action === "disable") return { applied: null, backups: tx.backups };
+    const managedKeys = Object.keys(want);
+    const record = {
+      at: now.toISOString(),
+      backups: [...applied?.backups ?? [], ...tx.backups],
+      fingerprint: claudeFingerprint(env, managedKeys, Boolean(wallet)),
+      previous,
+      parts: { brain: Boolean(target?.brain), wallet: Boolean(wallet) },
+      server: wallet?.server
+    };
+    return { applied: record, backups: tx.backups };
+  } catch (e) {
+    const rbErrors = tx.rollback();
+    if (rbErrors.length) e.message += ` (rollback problems: ${rbErrors.join("; ")})`;
+    throw e;
+  }
+}
+function claudeManagedKeys(applied) {
+  return Object.keys(applied.previous.env ?? {});
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r?\n/);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r?\n/);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class _TomlError extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+  /** @internal */
+  static x(message, ctx, ptr) {
+    throw new _TomlError(message, { toml: ctx.s, ptr: ptr ?? ctx.p });
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/primitive.js
+function parseString(ctx) {
+  let startPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
+  let first = c;
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+  if (isMultiline) {
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
+  }
+  let parsed = "";
+  let sliceStart = ctx.p;
+  let state = 0;
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
+      state = state && 3;
+    } else if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in strings", ctx);
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+      if (isMultiline) {
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+      }
+      if (!state) {
+        let s = ctx.s.slice(sliceStart, ctx.p);
+        parsed = parsed ? parsed + s : s;
+      }
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
+    } else if (!state) {
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === 120 || c === 117 || c === 85) {
+        let errPtr = ctx.p++ - 1;
+        let value = 0;
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0; j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p);
+          let digit = (
+            /* 0-9 */
+            hex >= 48 && hex <= 57 ? hex - 48 : (
+              /* A-F */
+              hex >= 65 && hex <= 70 ? hex - 65 + 10 : (
+                /* a-f */
+                hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1
+              )
+            )
+          );
+          if (digit < 0)
+            TomlError.x("invalid non-hex character in unicode escape", ctx);
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          TomlError.x("invalid unicode escape", ctx, errPtr);
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = ctx.p--;
+        state = 0;
+      } else if (isMultiline && (c === 32 || c === 9)) {
+        state = 2;
+      } else {
+        if (c === 98)
+          parsed += "\b";
+        else if (c === 116)
+          parsed += "	";
+        else if (c === 110)
+          parsed += "\n";
+        else if (c === 102)
+          parsed += "\f";
+        else if (c === 114)
+          parsed += "\r";
+        else if (c === 101)
+          parsed += "\x1B";
+        else if (c === 34)
+          parsed += '"';
+        else if (c === 92)
+          parsed += "\\";
+        else
+          TomlError.x("unrecognised escape sequence", ctx);
+        sliceStart = ctx.p + 1;
+        state = 0;
+      }
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2)
+        TomlError.x("invalid escape: only line-ending whitespace may be escaped", ctx, sliceStart);
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
+    }
+  }
+  TomlError.x("unfinished string", ctx, startPtr);
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date, fasttype, unsafeDelim) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    let c;
+    if (typeof date === "string") {
+      if (fasttype)
+        prep: {
+          if (fasttype < 3) {
+            if (+date.slice(11, 13) > 23) {
+              date = "";
+              break prep;
+            }
+            if (fasttype === 2) {
+              offset = null;
+              date += "Z";
+            } else if ((c = date.charCodeAt(date.length - 1)) !== 90 && c !== 122) {
+              offset = date.slice(date.length - 6);
+            }
+            if (unsafeDelim)
+              date = date.slice(0, 10) + "T" + date.slice(11);
+          } else if (fasttype === 4) {
+            date = +date.slice(0, 2) > 23 ? "" : `0000-01-01T${date}Z`;
+          }
+          hasDate = fasttype !== 4;
+          hasTime = fasttype !== 3;
+        }
+      else {
+        let match = date.match(DATE_TIME_RE);
+        if (match) {
+          if (!match[1]) {
+            hasDate = false;
+            date = `0000-01-01T${date}`;
+          }
+          hasTime = !!match[2];
+          hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+          if (match[2] && +match[2] > 23) {
+            date = "";
+          } else {
+            offset = match[3] || null;
+            if (!offset && hasTime)
+              date += "Z";
+          }
+        } else {
+          date = "";
+        }
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z" || this.#offset === "z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/extract.js
+function isDigit(char, base = 10) {
+  return base === 16 ? char > 47 && char < 58 || char > 64 && char < 71 || char > 96 && char < 103 : char > 47 && char < 48 + base;
+}
+function isEndOfValue(char, delim) {
+  return char === 32 || char === 9 || char === 10 || char === 13 || // Structure end or next value delimiter
+  delim && (char === delim || char === 44) || // Comment
+  char === 35;
+}
+function extractValue(ctx, end) {
+  let errPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p);
+  if (c === 91 || c === 123) {
+    ctx.d-- || TomlError.x("document contains excessively nested structures. aborting.", ctx);
+    let value = c === 91 ? parseArray(ctx) : parseInlineTable(ctx);
+    ctx.d++;
+    return value;
+  }
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, false;
+  }
+  if (c === 43 || c === 45) {
+    return parseNumber(ctx, ctx.p, ctx.s.charCodeAt(++ctx.p), 44 - c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 4) === 45 && ctx.s.charCodeAt(ctx.p + 7) === 45) {
+    return parseDate(ctx, c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 2) === 58) {
+    return parseTime(ctx, c, end);
+  }
+  return parseNumber(ctx, ctx.p, c, 0, end);
+}
+function parseNumber(ctx, startPtr, startChr, sign, endChr) {
+  let c = startChr;
+  let state = 0;
+  let hasUnderscores = false;
+  if (c === 105) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 110 || ctx.s.charCodeAt(++ctx.p) !== 102)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, (sign || 1) / 0;
+  }
+  if (c === 110) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 110)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, NaN;
+  }
+  if (c === 48) {
+    if (++ctx.p >= ctx.s.length || isEndOfValue(c = ctx.s.charCodeAt(ctx.p), endChr))
+      return ctx.bi === true ? 0n : 0;
+    if (!sign) {
+      if (c === 120)
+        return parseIntegerBaseN(ctx, startPtr, 16, endChr);
+      else if (c === 98)
+        return parseIntegerBaseN(ctx, startPtr, 2, endChr);
+      else if (c === 111)
+        return parseIntegerBaseN(ctx, startPtr, 8, endChr);
+    }
+    if (c === 46)
+      state = 2;
+    else if (c === 101 || c === 69)
+      state = 4;
+    else
+      TomlError.x("illegal leading zero", ctx, startPtr);
+  } else if (!isDigit(c))
+    TomlError.x("invalid value", ctx, startPtr);
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (!state)
+      state = 1;
+    if (c === 95) {
+      if (!(state & 1))
+        TomlError.x("illegal underscore", ctx);
+      state += 11;
+      hasUnderscores = true;
+    } else if (state === 1 && c === 46)
+      state = 2;
+    else if ((state === 1 || state === 3) && (c === 101 || c === 69))
+      state = 4;
+    else if (state === 4 && (c === 43 || c === 45)) {
+    } else if (!isDigit(c))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (state > 9)
+      state -= 11;
+    else if (!(state & 1))
+      state++;
+  }
+  if (!state) {
+    let val = (startChr - 48) * (sign || 1);
+    return ctx.bi === true ? BigInt(val) : val;
+  }
+  if (!(state & 1))
+    TomlError.x("unfinished numeric value", ctx, startPtr);
+  let str2 = ctx.s.slice(startPtr, ctx.p);
+  if (hasUnderscores)
+    str2 = str2.replaceAll("_", "");
+  return state > 1 ? parseFloat(str2) : parseInteger(ctx, str2, 10, startPtr);
+}
+function parseIntegerBaseN(ctx, startPtr, base, endChr) {
+  let c, underscore = 1;
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (c === 95) {
+      if (underscore & 1)
+        TomlError.x("illegal underscore", ctx);
+      underscore = 3;
+    } else if (!isDigit(c, base))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (underscore & 1)
+      underscore--;
+  }
+  if (underscore & 1)
+    TomlError.x("unfinished numeric value", ctx);
+  let str2 = ctx.s.slice(startPtr + 2, ctx.p);
+  if (underscore)
+    str2 = str2.replaceAll("_", "");
+  return parseInteger(ctx, str2, base, startPtr);
+}
+function parseInteger(ctx, str2, base, startPtr) {
+  if (ctx.bi !== true)
+    int: {
+      let val = parseInt(str2, base);
+      if (!Number.isSafeInteger(val)) {
+        if (ctx.bi)
+          break int;
+        TomlError.x("integer value cannot be represented losslessly", ctx, startPtr);
+      }
+      return val;
+    }
+  return base === 10 ? BigInt(str2) : BigInt((base === 2 ? "0b" : base === 8 ? "0o" : "0x") + str2);
+}
+function parseDate(ctx, c, endChr) {
+  let startPtr = ctx.p++, unsafeSeparator;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++))) {
+    return parseNumber(ctx, ctx.p = startPtr, c, 0, endChr);
+  }
+  ctx.p += 5;
+  if (!isDigit(ctx.s.charCodeAt(ctx.p++)))
+    TomlError.x("invalid date-time: date part is malformed", ctx, startPtr);
+  if (ctx.p >= ctx.s.length || ((c = ctx.s.charCodeAt(ctx.p)) !== 32 || (unsafeSeparator = true, !isDigit(ctx.s.charCodeAt(ctx.p + 1)))) && c !== 84 && c !== 116) {
+    let t2 = ctx.s.slice(startPtr, ctx.p);
+    return readDate(ctx, t2, 3, false, startPtr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 3) !== 58)
+    TomlError.x("invalid date-time: time part is malformed", ctx, startPtr);
+  if (ctx.s.charCodeAt(ctx.p += 3) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  if (c = ctx.s.charCodeAt(ctx.p)) {
+    if (c === 90 || c === 122) {
+      let t2 = ctx.s.slice(startPtr, ++ctx.p);
+      return readDate(ctx, t2, 1, unsafeSeparator, startPtr, "[+00:00]");
+    }
+    if (c === 43 || c === 45) {
+      let t2 = ctx.s.slice(startPtr, ctx.p += 6);
+      return readDate(ctx, t2, 1, unsafeSeparator, startPtr, !ctx.ld && "[" + ctx.s.slice(ctx.p - 6, ctx.p) + "]");
+    }
+  }
+  let t = ctx.s.slice(startPtr, ctx.p);
+  return readDate(ctx, t, 2, unsafeSeparator, startPtr);
+}
+function parseTime(ctx, c, endChr) {
+  let start = ctx.p;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(++ctx.p))) {
+    return parseNumber(ctx, --ctx.p, c, 0, endChr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 4) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  let t = ctx.s.slice(start, ctx.p);
+  return readDate(ctx, t, 4, false, start);
+}
+function readDate(ctx, str2, type, unsafeDelim, errPtr, temporalSuffix) {
+  if (ctx.ld) {
+    let date = new TomlDate(str2, type, unsafeDelim);
+    if (!date.isValid())
+      TomlError.x("invalid date", ctx, errPtr);
+    return date;
+  }
+  try {
+    if (temporalSuffix)
+      str2 += temporalSuffix;
+    switch (type) {
+      case 1:
+        return Temporal.ZonedDateTime.from(str2);
+      case 2:
+        return Temporal.PlainDateTime.from(str2);
+      case 3:
+        return Temporal.PlainDate.from(str2);
+      case 4:
+        return Temporal.PlainTime.from(str2);
+    }
+  } catch (e) {
+    TomlError.x(e instanceof Error ? e.message : "" + e, ctx, errPtr);
+  }
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/util.js
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in comments", ctx);
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (ctx.p < ctx.s.length) {
+    while (ctx.p < ctx.s.length && ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
+  }
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/struct.js
+function parseKey(ctx, end = 61) {
+  let startPtr;
+  let state = 0;
+  let parsed = [];
+  let sliceStart;
+  let c = ctx.s.charCodeAt(startPtr = ctx.p);
+  do {
+    if (c === end) {
+      if (!state)
+        TomlError.x("unexpected end of key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      return ctx.p++, parsed;
+    } else if (c === 46) {
+      if (!state)
+        TomlError.x("illegal empty bare key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      state = 0;
+    } else if (!state && (c === 34 || c === 39)) {
+      if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2))
+        TomlError.x("illegal quoted key: multiline strings are not allowed", ctx);
+      parsed.push(parseString(ctx));
+      state = 2;
+      ctx.p--;
+    } else if (c === 32 || c === 9) {
+      if (state === 1) {
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+        state = 2;
+      }
+    } else if (state === 2 || c < 48 && c !== 45 || c > 57 && c < 65 || c > 90 && c < 97 && c !== 95 || c > 122) {
+      TomlError.x("illegal character in key", ctx);
+    } else if (!state) {
+      state = 1;
+      sliceStart = ctx.p;
+    }
+  } while (c = ctx.s.charCodeAt(++ctx.p));
+  TomlError.x("incomplete key-value: cannot find end of key", ctx, startPtr);
+}
+function parseInlineTable(ctx) {
+  let startPtr = ctx.p++;
+  let res = /* @__PURE__ */ Object.create(null);
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let errPtr = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0; i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+        TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+      }
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor")) {
+        t = ctx.uk !== 1 && TomlError.x("document contains an unsafe property", ctx, errPtr);
+        break;
+      }
+      if (!hasOwn && unsafe) {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (hasOwn) {
+      TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+    }
+    skipVoid(ctx, true, true);
+    let value = extractValue(
+      ctx,
+      125
+      /* } */
+    );
+    if (t && typeof (t[k] = value) === "object")
+      seen.add(value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished table", ctx, startPtr);
+}
+function parseArray(ctx) {
+  let startPtr = ctx.p++;
+  let res = [];
+  let c;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(
+      ctx,
+      93
+      /* ] */
+    ));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished array", ctx, startPtr);
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/parse.js
+function peekTable(ctx, key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor"))
+        return false;
+      if (unsafe) {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: /* @__PURE__ */ Object.create(null)
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = /* @__PURE__ */ Object.create(null));
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: /* @__PURE__ */ Object.create(null) };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function validateTablePeek(ctx, peek, ptr) {
+  if (peek === null || ctx.uk === 2)
+    TomlError.x(peek === null ? "trying to redefine an already defined table or value" : "document contains an unsafe property", ctx, ptr);
+}
+function parse(toml, options = {}) {
+  let ctx = {
+    s: toml,
+    p: 0,
+    d: options.maxDepth ?? 1e3,
+    bi: options.integersAsBigInt ?? false,
+    ld: options.useLegacyDate ?? true,
+    uk: options.unsafeKeyBehaviour === "throw" ? 2 : options.unsafeKeyBehaviour === "drop" ? 1 : 0
+  };
+  let res = /* @__PURE__ */ Object.create(null);
+  let meta = /* @__PURE__ */ Object.create(null);
+  let tmp;
+  let skipping = false;
+  let tbl = res;
+  let m = meta;
+  if (toml.charCodeAt(0) === 65279)
+    ctx.p++;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      skipping = false;
+      let k = parseKey(
+        ctx,
+        93
+        /* ] */
+      );
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p) !== 93) {
+          TomlError.x("expected end of table array declaration", ctx);
+        }
+        ctx.p++;
+      }
+      let p = peekTable(
+        ctx,
+        k,
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        validateTablePeek(ctx, p, tmp);
+        skipping = true;
+      } else {
+        m = p[2];
+        tbl = p[1];
+      }
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(
+        ctx,
+        k,
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p && !skipping)
+        validateTablePeek(ctx, p, tmp);
+      skipVoid(ctx, true, true);
+      let v = extractValue(ctx, void 0);
+      if (p && !skipping)
+        p[1][p[0]] = v;
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && (tmp !== 13 || toml.charCodeAt(ctx.p + 1) !== 10)) {
+      TomlError.x("each key-value declaration must be followed by an end-of-line", ctx);
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/stringify.js
+var HAS_WELLFORMED = !!"".isWellFormed;
+
+// ../connect/dist/lib/codex.js
+var TABLE = "mcp_servers.moneyswitch";
+function tomlEscape(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function buildMcpSection(server, key, mcpCommand) {
+  const argsToml = mcpCommand.args.map((a) => `"${tomlEscape(a)}"`).join(", ");
+  return [
+    `[${TABLE}]`,
+    `command = "${tomlEscape(mcpCommand.command)}"`,
+    `args = [${argsToml}]`,
+    "",
+    `[${TABLE}.env]`,
+    `MONEY_API_BASE = "${tomlEscape(server)}"`,
+    `MONEY_API_KEY = "${tomlEscape(key)}"`
+  ].join("\n");
+}
+
+// src/desktop/toml-edit.ts
+var HEADER_RE = /^\s*\[\[?\s*([^\]]*?)\s*\]\]?\s*(#.*)?$/;
+function tomlString(v) {
+  return JSON.stringify(v);
+}
+function normName(raw) {
+  return raw.split(".").map((p) => p.trim().replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1")).join(".");
+}
+function scan(text) {
+  const out = [];
+  let table = "";
+  let inMulti = null;
+  for (const text_ of text.split(/\r?\n/)) {
+    const startsInString = inMulti !== null;
+    let isHeader = false;
+    if (!startsInString) {
+      const m = HEADER_RE.exec(text_);
+      if (m) {
+        table = normName(m[1]);
+        isHeader = true;
+      }
+    }
+    let i = 0;
+    while (i < text_.length) {
+      if (inMulti) {
+        const end = text_.indexOf(inMulti, i);
+        if (end === -1) break;
+        inMulti = null;
+        i = end + 3;
+      } else {
+        const a = text_.indexOf('"""', i);
+        const b = text_.indexOf("'''", i);
+        const hash = text_.indexOf("#", i);
+        const cands = [a, b].filter((x) => x !== -1);
+        if (!cands.length) break;
+        const first = Math.min(...cands);
+        if (hash !== -1 && hash < first) break;
+        inMulti = first === a ? '"""' : "'''";
+        i = first + 3;
+      }
+    }
+    out.push({ text: text_, header: table, isHeader, inString: startsInString });
+  }
+  return out;
+}
+function belongsTo(table, name) {
+  return table === name || table.startsWith(`${name}.`);
+}
+function getTable(text, name) {
+  const lines = scan(text).filter((l) => belongsTo(l.header ?? "", name));
+  if (!lines.length) return null;
+  return lines.map((l) => l.text).join("\n").replace(/\s+$/, "");
+}
+function removeTable(text, name) {
+  const kept = scan(text).filter((l) => !belongsTo(l.header ?? "", name)).map((l) => l.text);
+  return tidy(kept.join(eol(text)), eol(text));
+}
+function appendTable(text, block) {
+  const nl = eol(text);
+  const base = text.replace(/\s+$/, "");
+  const b = block.replace(/\s+$/, "").replace(/\r?\n/g, nl);
+  return base.length ? `${base}${nl}${nl}${b}${nl}` : `${b}${nl}`;
+}
+function tidy(s, nl) {
+  const t = s.replace(/\s+$/, "");
+  return t.length ? `${t}${nl}` : "";
+}
+function eol(text) {
+  return text.includes("\r\n") ? "\r\n" : "\n";
+}
+var keyRe = (key) => new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*=`);
+function getRootLine(text, key) {
+  const re = keyRe(key);
+  for (const l of scan(text)) {
+    if (l.isHeader) return null;
+    if (!l.inString && re.test(l.text)) return l.text;
+  }
+  return null;
+}
+function setRootLine(text, key, line) {
+  const re = keyRe(key);
+  const lines = scan(text);
+  const firstHeader = lines.findIndex((l) => l.isHeader);
+  const rootEnd = firstHeader === -1 ? lines.length : firstHeader;
+  const idx = lines.slice(0, rootEnd).findIndex((l) => !l.inString && re.test(l.text));
+  const texts = lines.map((l) => l.text);
+  if (idx !== -1) {
+    if (line === null) texts.splice(idx, 1);
+    else texts[idx] = line;
+  } else if (line !== null) {
+    let at = rootEnd;
+    while (at > 0 && texts[at - 1].trim() === "") at--;
+    texts.splice(at, 0, line);
+  }
+  return tidy(texts.join(eol(text)), eol(text));
+}
+
+// src/desktop/codex.ts
+var PROVIDER_ID = "moneyswitch_brain";
+var PROVIDER_TABLE = `model_providers.${PROVIDER_ID}`;
+var MCP_TABLE = "mcp_servers.moneyswitch";
+function parse2(text, label) {
+  try {
+    return parse(text);
+  } catch (e) {
+    throw new AgentConfigError("PARSE_FAILED", `${label} is not valid TOML (${e.message.split("\n")[0]}); fix it by hand first \u2014 nothing was written.`);
+  }
+}
+function providerBlock(brain) {
+  return [
+    `[${PROVIDER_TABLE}]`,
+    `name = ${tomlString(`MoneySwitch \xB7 ${brain.preset}`)}`,
+    `base_url = ${tomlString(brain.baseUrl.replace(/\/+$/, ""))}`,
+    `wire_api = "responses"`,
+    `experimental_bearer_token = ${tomlString(brain.apiKey)}`
+  ].join("\n");
+}
+function stripManaged(doc) {
+  const out = JSON.parse(JSON.stringify(doc));
+  delete out.model;
+  delete out.model_provider;
+  const mp = out.model_providers;
+  if (mp) {
+    delete mp[PROVIDER_ID];
+    if (Object.keys(mp).length === 0) delete out.model_providers;
+  }
+  const ms = out.mcp_servers;
+  if (ms) {
+    delete ms.moneyswitch;
+    if (Object.keys(ms).length === 0) delete out.mcp_servers;
+  }
+  return out;
+}
+function get(doc, path7) {
+  let cur = doc;
+  for (const p of path7.split(".")) {
+    if (!cur || typeof cur !== "object") return null;
+    cur = cur[p];
+  }
+  if (cur === void 0 || cur === null) return null;
+  return Array.isArray(cur) ? cur.map(String).join(" ") : String(cur);
+}
+function computeEdit(text, action, target, applied) {
+  const prevRec = applied ? applied.previous : null;
+  const previous = prevRec ? { fileExisted: prevRec.fileExisted, root: { ...prevRec.root }, tables: { ...prevRec.tables } } : { fileExisted: text.length > 0, root: {}, tables: {} };
+  const wantRoot = {};
+  const wantTables = {};
+  if (action === "enable" && target) {
+    if (target.brain) {
+      if (target.brain.model.trim()) wantRoot.model = `model = ${tomlString(target.brain.model.trim())}`;
+      wantRoot.model_provider = `model_provider = ${tomlString(PROVIDER_ID)}`;
+      wantTables[PROVIDER_TABLE] = providerBlock(target.brain);
+    }
+    if (target.wallet) wantTables[MCP_TABLE] = buildMcpSection(target.wallet.server, target.wallet.key, target.mcpCommand);
+  }
+  for (const [k, v] of Object.entries(prevRec?.root ?? {})) if (!(k in wantRoot)) wantRoot[k] = v;
+  for (const [k, v] of Object.entries(prevRec?.tables ?? {})) if (!(k in wantTables)) wantTables[k] = v;
+  if (action === "enable") {
+    for (const k of Object.keys(wantRoot)) if (!(k in previous.root)) previous.root[k] = getRootLine(text, k);
+    for (const k of Object.keys(wantTables)) if (!(k in previous.tables)) previous.tables[k] = getTable(text, k);
+  }
+  let after = text;
+  for (const [k, line] of Object.entries(wantRoot)) after = setRootLine(after, k, line);
+  for (const [name, block] of Object.entries(wantTables)) {
+    after = removeTable(after, name);
+    if (block !== null) after = appendTable(after, block);
+  }
+  return { before: text, after, previous, managedRoot: Object.keys(wantRoot), managedTables: Object.keys(wantTables) };
+}
+function diffFields(before, after) {
+  const fields = [
+    ["model", "model", false],
+    ["model_provider", "model_provider", false],
+    [`[${PROVIDER_TABLE}].base_url`, `model_providers.${PROVIDER_ID}.base_url`, false],
+    [`[${PROVIDER_TABLE}].wire_api`, `model_providers.${PROVIDER_ID}.wire_api`, false],
+    [`[${PROVIDER_TABLE}].experimental_bearer_token`, `model_providers.${PROVIDER_ID}.experimental_bearer_token`, true],
+    [`[${MCP_TABLE}].command`, "mcp_servers.moneyswitch.command", false],
+    [`[${MCP_TABLE}].args`, "mcp_servers.moneyswitch.args", false],
+    [`[${MCP_TABLE}.env].MONEY_API_BASE`, "mcp_servers.moneyswitch.env.MONEY_API_BASE", false],
+    [`[${MCP_TABLE}.env].MONEY_API_KEY`, "mcp_servers.moneyswitch.env.MONEY_API_KEY", true]
+  ];
+  return fields.map(([label, p, secret]) => fieldChange(label, get(before, p), get(after, p), secret)).filter((c) => c.op !== "same");
+}
+function assertOnlyManagedChanged(beforeDoc, afterText, label) {
+  let afterDoc;
+  try {
+    afterDoc = parse(afterText);
+  } catch {
+    throw new AgentConfigError("VERIFY_FAILED", `refusing to write ${label}: the edited file would not parse (unusual file layout). Nothing was written.`);
+  }
+  if (!deepEqual(stripManaged(beforeDoc), stripManaged(afterDoc))) {
+    throw new AgentConfigError("VERIFY_FAILED", `refusing to write ${label}: the edit would change settings MoneySwitch does not own (unusual file layout). Nothing was written.`);
+  }
+  return afterDoc;
+}
+function planCodex(env, action, target, applied) {
+  const file = codexConfigFile(env);
+  const label = displayPath(file, env);
+  const raw = readIfExists(file);
+  const text = raw ?? "";
+  const beforeDoc = parse2(text, label);
+  const edit = computeEdit(text, action, target, applied);
+  const afterDoc = assertOnlyManagedChanged(beforeDoc, edit.after, label);
+  const changes = diffFields(beforeDoc, afterDoc);
+  const warnings = [];
+  if (action === "enable" && target?.brain?.preset === "deepseek") warnings.push("codexNeedsResponsesApi");
+  if (action === "enable" && target?.brain && get(beforeDoc, "model_provider") && get(beforeDoc, "model_provider") !== PROVIDER_ID) {
+    warnings.push("codexReplacesProvider");
+  }
+  const files = changes.length ? [{ path: file, display: label, exists: raw !== null, writer: "moneyswitch", changes }] : [];
+  return {
+    plan: { agent: "codex", action, files, commands: [], warnings, noop: files.length === 0 },
+    inputHash: sha256(text)
+  };
+}
+function codexFingerprint(env, applied) {
+  const prev = applied.previous;
+  const text = readIfExists(codexConfigFile(env)) ?? "";
+  const vals = {};
+  for (const k of Object.keys(prev.root ?? {}).sort()) vals[`root:${k}`] = getRootLine(text, k);
+  for (const k of Object.keys(prev.tables ?? {}).sort()) {
+    const t = getTable(text, k);
+    vals[`table:${k}`] = t === null ? null : t.replace(/\r\n/g, "\n");
+  }
+  return sha256(stableStringify(vals));
+}
+function applyCodexPlan(env, action, target, applied, now = /* @__PURE__ */ new Date()) {
+  const file = codexConfigFile(env);
+  const label = displayPath(file, env);
+  const raw = readIfExists(file);
+  const text = raw ?? "";
+  const beforeDoc = parse2(text, label);
+  const edit = computeEdit(text, action, target, applied);
+  assertOnlyManagedChanged(beforeDoc, edit.after, label);
+  const tx = new FileTransaction(now.getTime());
+  try {
+    if (edit.after !== text) {
+      if (action === "disable" && !edit.previous.fileExisted && edit.after.trim() === "") {
+        tx.remove(file);
+      } else {
+        tx.write(file, edit.after, (onDisk) => {
+          const doc = assertOnlyManagedChanged(beforeDoc, onDisk, label);
+          if (action === "enable" && target?.wallet && get(doc, "mcp_servers.moneyswitch.env.MONEY_API_KEY") !== target.wallet.key) {
+            throw new AgentConfigError("VERIFY_FAILED", `${label} read-back: [mcp_servers.moneyswitch] is not what was written`);
+          }
+          if (action === "enable" && target?.brain && get(doc, "model_provider") !== PROVIDER_ID) {
+            throw new AgentConfigError("VERIFY_FAILED", `${label} read-back: model_provider is not what was written`);
+          }
+        });
+      }
+    }
+    if (action === "disable") return { applied: null, backups: tx.backups };
+    const record = {
+      at: now.toISOString(),
+      backups: [...applied?.backups ?? [], ...tx.backups],
+      fingerprint: "",
+      previous: edit.previous,
+      parts: { brain: Boolean(target?.brain), wallet: Boolean(target?.wallet) },
+      server: target?.wallet?.server
+    };
+    record.fingerprint = codexFingerprint(env, record);
+    return { applied: record, backups: tx.backups };
+  } catch (e) {
+    const rb = tx.rollback();
+    if (rb.length) e.message += ` (rollback problems: ${rb.join("; ")})`;
+    throw e;
+  }
+}
+
+// src/desktop/money-api.ts
+var MoneyApiError = class extends Error {
+  constructor(httpStatus, code, message, body) {
+    super(message);
+    this.httpStatus = httpStatus;
+    this.code = code;
+    this.body = body;
+  }
+  httpStatus;
+  code;
+  body;
+};
+function normalizeServer(server) {
+  const s = server.trim().replace(/\/+$/, "");
+  const u = new URL(s);
+  if (u.protocol !== "http:" && u.protocol !== "https:") throw new Error("server must be an http(s) URL");
+  return s.replace(/\/v1$/, "");
+}
+var MoneyApi = class {
+  constructor(server, key, fetchImpl = fetch, timeoutMs = 1e4) {
+    this.server = server;
+    this.key = key;
+    this.fetchImpl = fetchImpl;
+    this.timeoutMs = timeoutMs;
+  }
+  server;
+  key;
+  fetchImpl;
+  timeoutMs;
+  async call(method, path7, body) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    let res;
+    try {
+      res = await this.fetchImpl(`${this.server}${path7}`, {
+        method,
+        headers: { Authorization: `Bearer ${this.key}`, ...body !== void 0 ? { "Content-Type": "application/json" } : {} },
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: ctrl.signal
+      });
+    } catch (e) {
+      const msg = e.name === "AbortError" ? `timed out after ${this.timeoutMs} ms` : e.message;
+      throw new MoneyApiError(0, "UNREACHABLE", `cannot reach ${this.server}: ${msg}`, null);
+    } finally {
+      clearTimeout(timer);
+    }
+    let json = null;
+    try {
+      json = await res.json();
+    } catch {
+      json = null;
+    }
+    if (!res.ok) {
+      const b = json ?? {};
+      const code = String(b.code ?? b.error ?? `HTTP_${res.status}`);
+      const message = String(b.message ?? b.error ?? `HTTP ${res.status}`);
+      throw new MoneyApiError(res.status, code, message, json);
+    }
+    return json;
+  }
+  status() {
+    return this.call("GET", "/v1/status");
+  }
+  createChild(input) {
+    return this.call("POST", "/v1/keys/children", { ...input, can_delegate: input.can_delegate ?? false });
+  }
+  async listChildren() {
+    const r = await this.call("GET", "/v1/keys/children");
+    return r.children ?? [];
+  }
+  revokeChild(id) {
+    return this.call("POST", `/v1/keys/children/${encodeURIComponent(id)}/revoke`, {});
+  }
+};
+function toMicros(v) {
+  const m = /^\s*(\d+)(?:\.(\d{0,6}))?\s*$/.exec(v);
+  if (!m) throw new Error(`not a USDC amount: ${v}`);
+  return BigInt(m[1]) * 1000000n + BigInt((m[2] ?? "").padEnd(6, "0") || "0");
+}
+function fromMicros(m) {
+  const neg = m < 0n;
+  const a = neg ? -m : m;
+  const whole = a / 1000000n;
+  const frac = (a % 1000000n).toString().padStart(6, "0").replace(/0+$/, "");
+  return `${neg ? "-" : ""}${whole}.${frac.length >= 2 ? frac : frac.padEnd(2, "0")}`;
+}
+function suggestChildBudgets(parent, n) {
+  const share = (v) => {
+    if (!v) return 0n;
+    const each = toMicros(v) / BigInt(Math.max(1, n));
+    return each / 10000n * 10000n;
+  };
+  const daily = share(parent.remaining_today);
+  const total = share(parent.remaining_total);
+  const perParent = parent.per_request_limit ? toMicros(parent.per_request_limit) : daily;
+  const per = [daily, perParent].reduce((a, b) => a < b ? a : b);
+  return { daily_budget: fromMicros(daily), per_request_limit: fromMicros(per), total_budget: fromMicros(total) };
+}
+
+// src/desktop/model-test.ts
+async function testBrain(agent, brain, fetchImpl = fetch, timeoutMs = 2e4) {
+  const base = brain.baseUrl.replace(/\/+$/, "");
+  let url;
+  let init;
+  if (agent === "claude") {
+    url = `${base}/v1/messages`;
+    const authVar = claudeAuthVar(brain.preset);
+    init = {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "anthropic-version": "2023-06-01",
+        ...authVar === "ANTHROPIC_API_KEY" ? { "x-api-key": brain.apiKey } : { authorization: `Bearer ${brain.apiKey}` }
+      },
+      body: JSON.stringify({ model: brain.model || "claude-sonnet-4-5", max_tokens: 1, messages: [{ role: "user", content: "ping" }] })
+    };
+  } else {
+    url = `${base}/responses`;
+    init = {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${brain.apiKey}` },
+      body: JSON.stringify({ model: brain.model, input: "ping", max_output_tokens: 16 })
+    };
+  }
+  const started = Date.now();
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, { ...init, signal: ctrl.signal });
+    const text = await res.text().catch(() => "");
+    let message = res.ok ? "OK" : `HTTP ${res.status}`;
+    if (!res.ok) {
+      try {
+        const j = JSON.parse(text);
+        const m = typeof j.error === "string" ? j.error : j.error?.message ?? j.message;
+        if (m) message = `HTTP ${res.status}: ${m}`;
+      } catch {
+        if (text) message = `HTTP ${res.status}: ${text.slice(0, 160)}`;
+      }
+    }
+    return { ok: res.ok, httpStatus: res.status, message: message.slice(0, 300), ms: Date.now() - started, url };
+  } catch (e) {
+    const err = e;
+    const reason = err.name === "AbortError" ? `timed out after ${timeoutMs} ms` : err.cause?.code ?? err.cause?.message ?? err.message;
+    return { ok: false, httpStatus: null, message: `network error: ${reason}`, ms: Date.now() - started, url };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/desktop/store.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+function emptyStore() {
+  return { version: 1, agents: {} };
+}
+function loadStore(env) {
+  const p = desktopStorePath(env);
+  if (!fs3.existsSync(p)) return emptyStore();
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(p, "utf8"));
+    if (!parsed || typeof parsed !== "object") return emptyStore();
+    return { version: 1, server: parsed.server, key: parsed.key, agents: parsed.agents ?? {} };
+  } catch {
+    fs3.copyFileSync(p, `${p}.corrupt-${Date.now()}`);
+    return emptyStore();
+  }
+}
+function restrictToCurrentUser(file, env = process.env) {
+  if (process.platform !== "win32") {
+    try {
+      fs3.chmodSync(file, 384);
+      return { ok: true, how: "chmod 600" };
+    } catch (e) {
+      return { ok: false, how: `chmod failed: ${e.message}` };
+    }
+  }
+  const user = env.USERNAME ?? process.env.USERNAME;
+  if (!user) return { ok: false, how: "USERNAME unknown" };
+  const domain = env.USERDOMAIN ?? process.env.USERDOMAIN;
+  const principal = domain ? `${domain}\\${user}` : user;
+  const res = spawnSync2("icacls", [file, "/inheritance:r", "/grant:r", `${principal}:F`], {
+    encoding: "utf8",
+    windowsHide: true
+  });
+  return res.status === 0 ? { ok: true, how: `icacls ${principal}:F (inheritance removed)` } : { ok: false, how: `icacls failed: ${res.stderr || res.stdout}` };
+}
+function saveStore(env, store) {
+  const p = desktopStorePath(env);
+  fs3.mkdirSync(path4.dirname(p), { recursive: true });
+  const tmp = `${p}.tmp-${process.pid}`;
+  fs3.writeFileSync(tmp, JSON.stringify(store, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+  restrictToCurrentUser(tmp, env);
+  fs3.renameSync(tmp, p);
+}
+
+// src/desktop/service.ts
+var NEW_CHILD_PLACEHOLDER = "mk_live_NEWCHILDKEY_WILL_BE_CREATED";
+var NEW_CHILD_MARK = "@@NEW_CHILD@@";
+var UserError = class extends Error {
+  constructor(status, code, message, detail) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.detail = detail;
+  }
+  status;
+  code;
+  detail;
+};
+function isAuto(agent) {
+  return AUTO_AGENTS.includes(agent);
+}
+function maskBrain(b) {
+  if (!b) return null;
+  return { preset: b.preset, baseUrl: b.baseUrl, model: b.model, apiKeyMasked: b.apiKey ? maskSecret(b.apiKey) : "", hasApiKey: Boolean(b.apiKey) };
+}
+function maskWallet(w) {
+  if (!w) return null;
+  const { key, ...rest } = w;
+  return { ...rest, keyMasked: maskSecret(key) };
+}
+function validateUsd(v, field) {
+  if (typeof v !== "string" && typeof v !== "number") throw new UserError(400, "INVALID_AMOUNT", `${field} is required`, { field });
+  const s = String(v).trim();
+  if (!/^\d+(\.\d{1,6})?$/.test(s) || toMicros(s) <= 0n) throw new UserError(400, "INVALID_AMOUNT", `${field} must be a positive amount like 1.50`, { field });
+  return s;
+}
+var DesktopService = class {
+  env;
+  runner;
+  fetchImpl;
+  now;
+  detection = null;
+  mcpCache = /* @__PURE__ */ new Map();
+  fixedMcp;
+  /** Serialise every write: one config change at a time. */
+  chain = Promise.resolve();
+  constructor(deps) {
+    this.env = deps.env;
+    this.runner = deps.runner;
+    this.fetchImpl = deps.fetchImpl ?? fetch;
+    this.fixedMcp = deps.mcpCommand;
+    this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  exclusive(fn) {
+    const run = this.chain.then(fn, fn);
+    this.chain = run.catch(() => void 0);
+    return run;
+  }
+  store() {
+    return loadStore(this.env);
+  }
+  save(s) {
+    saveStore(this.env, s);
+  }
+  agentState(s, agent) {
+    s.agents[agent] ??= {};
+    return s.agents[agent];
+  }
+  detect(force = false) {
+    if (!this.detection || force) this.detection = detectAgents(this.env, this.runner);
+    return this.detection;
+  }
+  async mcpCommand(server) {
+    if (this.fixedMcp) return this.fixedMcp;
+    const cached = this.mcpCache.get(server);
+    if (cached) return cached;
+    let cmd = resolveMcpCommand(import.meta.url);
+    if (isNpmRegistryFallback(cmd)) cmd = await resolvePortableMcpCommand(server, this.fetchImpl);
+    this.mcpCache.set(server, cmd);
+    return cmd;
+  }
+  api(s) {
+    if (!s.server || !s.key) throw new UserError(400, "NO_ACCOUNT", "connect your MoneySwitch account first");
+    return new MoneyApi(s.server, s.key, this.fetchImpl);
+  }
+  // ---------------------------------------------------------------- status
+  agentStatus(agent, st) {
+    const applied = st?.applied;
+    if (!applied || !isAuto(agent)) return "disabled";
+    try {
+      const fp = agent === "claude" ? claudeFingerprint(this.env, claudeManagedKeys(applied), applied.parts.wallet) : codexFingerprint(this.env, applied);
+      return fp === applied.fingerprint ? "enabled" : "drifted";
+    } catch {
+      return "drifted";
+    }
+  }
+  async state() {
+    const s = this.store();
+    const det = this.detect();
+    const mcp = s.server ? await this.mcpCommand(s.server).catch(() => ({ command: "npx", args: ["-y", "moneyswitch", "mcp"] })) : { command: "npx", args: ["-y", "moneyswitch", "mcp"] };
+    const agents = ALL_AGENTS.map((id) => {
+      const st = s.agents[id];
+      return {
+        id,
+        name: AGENT_INFO[id].name,
+        mode: AGENT_INFO[id].mode,
+        detection: det[id],
+        brain: maskBrain(st?.brain),
+        wallet: maskWallet(st?.wallet),
+        status: this.agentStatus(id, st),
+        applied: st?.applied ? { at: st.applied.at, backups: st.applied.backups, parts: st.applied.parts } : null,
+        presets: presetsFor(id),
+        manual: AGENT_INFO[id].mode === "manual" ? manualSteps(id, { server: s.server ?? null, walletKey: st?.wallet?.key ?? null, brain: st?.brain ?? null, mcp }) : []
+      };
+    });
+    return {
+      account: s.server && s.key ? { server: s.server, keyMasked: maskSecret(s.key) } : null,
+      agents,
+      host: os2.hostname()
+    };
+  }
+  /** Live numbers from the server: my budget + today's spend of each agent's key. Never throws. */
+  async usage() {
+    const s = this.store();
+    if (!s.server || !s.key) return { account: null, agents: {}, error: null };
+    const api = this.api(s);
+    let account = null;
+    let error = null;
+    try {
+      account = await api.status();
+    } catch (e) {
+      const err = e;
+      error = { code: err.code ?? "ERROR", message: err.message };
+    }
+    const agents = {};
+    let children = [];
+    if (account) children = await api.listChildren().catch(() => []);
+    for (const id of ALL_AGENTS) {
+      const w = s.agents[id]?.wallet;
+      if (!w) continue;
+      const child = w.childId ? children.find((c) => c.id === w.childId) : void 0;
+      if (child) {
+        agents[id] = { used_today: child.used_today ?? null, status: child.status ?? null };
+      } else {
+        try {
+          const st = await new MoneyApi(s.server, w.key, this.fetchImpl).status();
+          agents[id] = { used_today: st.used_today ?? null, status: "active" };
+        } catch (e) {
+          agents[id] = { used_today: null, status: null, error: e.code };
+        }
+      }
+    }
+    return { account, agents, error };
+  }
+  // --------------------------------------------------------------- account
+  setAccount(server, key) {
+    return this.exclusive(async () => {
+      if (typeof server !== "string" || !server.trim()) throw new UserError(400, "INVALID_SERVER", "server URL is required");
+      if (typeof key !== "string" || !/^mk_live_[A-Za-z0-9_-]{8,}$/.test(key.trim())) throw new UserError(400, "INVALID_KEY", "paste a MoneyKey that starts with mk_live_");
+      let norm;
+      try {
+        norm = normalizeServer(server);
+      } catch {
+        throw new UserError(400, "INVALID_SERVER", "server must be an http(s) URL");
+      }
+      let status;
+      try {
+        status = await new MoneyApi(norm, key.trim(), this.fetchImpl).status();
+      } catch (e) {
+        const err = e;
+        throw new UserError(err.httpStatus === 401 ? 401 : 502, err.code, err.message);
+      }
+      const s = this.store();
+      s.server = norm;
+      s.key = key.trim();
+      this.save(s);
+      return { server: norm, keyMasked: maskSecret(s.key), status };
+    });
+  }
+  clearAccount() {
+    return this.exclusive(() => {
+      const s = this.store();
+      delete s.server;
+      delete s.key;
+      this.save(s);
+      return { ok: true };
+    });
+  }
+  // ----------------------------------------------------------------- brain
+  saveBrain(agent, body) {
+    return this.exclusive(() => {
+      if (!isAuto(agent)) throw new UserError(400, "NOT_SUPPORTED", "model settings for this agent are manual in v0.4");
+      const s = this.store();
+      const st = this.agentState(s, agent);
+      if (body.clear === true) {
+        st.brain = null;
+        this.save(s);
+        return { brain: null };
+      }
+      const brain = this.parseBrain(agent, body, st.brain ?? null);
+      st.brain = brain;
+      this.save(s);
+      return { brain: maskBrain(brain) };
+    });
+  }
+  parseBrain(agent, body, existing) {
+    const presets = presetsFor(agent);
+    const preset = presets.find((p) => p.id === body.preset);
+    if (!preset) throw new UserError(400, "INVALID_PRESET", "unknown provider preset");
+    const baseUrl = String(body.baseUrl ?? preset.baseUrl).trim();
+    try {
+      const u = new URL(baseUrl);
+      if (u.protocol !== "https:" && u.protocol !== "http:") throw new Error();
+    } catch {
+      throw new UserError(400, "INVALID_BASE_URL", "Base URL must be an http(s) URL", { field: "baseUrl" });
+    }
+    const model = String(body.model ?? "").trim();
+    if (agent === "codex" && !model) throw new UserError(400, "MODEL_REQUIRED", "Codex needs a model name", { field: "model" });
+    let apiKey = typeof body.apiKey === "string" ? body.apiKey.trim() : "";
+    if (!apiKey && existing) apiKey = existing.apiKey;
+    if (!apiKey) throw new UserError(400, "API_KEY_REQUIRED", "API key is required", { field: "apiKey" });
+    if (/[\r\n"]/.test(apiKey) || /[\r\n"]/.test(model)) throw new UserError(400, "INVALID_INPUT", "unexpected characters");
+    return { preset: preset.id, baseUrl, apiKey, model };
+  }
+  async testBrain(agent, body) {
+    if (!isAuto(agent)) throw new UserError(400, "NOT_SUPPORTED", "not supported for this agent");
+    const s = this.store();
+    const brain = this.parseBrain(agent, body, s.agents[agent]?.brain ?? null);
+    return testBrain(agent, brain, this.fetchImpl);
+  }
+  // ---------------------------------------------------------------- wallet
+  createChild(agent, body) {
+    return this.exclusive(async () => {
+      const s = this.store();
+      const api = this.api(s);
+      const daily = validateUsd(body.daily_budget, "daily_budget");
+      const per = validateUsd(body.per_request_limit, "per_request_limit");
+      const total = validateUsd(body.total_budget, "total_budget");
+      if (toMicros(per) > toMicros(daily)) throw new UserError(400, "PER_REQUEST_ABOVE_DAILY", "the per-request limit cannot be above the daily limit", { field: "per_request_limit" });
+      const name = `${AGENT_INFO[agent].name} @ ${os2.hostname()}`.slice(0, 80);
+      let child;
+      try {
+        child = await api.createChild({ name, daily_budget: daily, total_budget: total, per_request_limit: per });
+      } catch (e) {
+        const err = e;
+        throw new UserError(err.httpStatus >= 400 && err.httpStatus < 500 ? err.httpStatus : 502, err.code, err.message, err.body);
+      }
+      const st = this.agentState(s, agent);
+      st.wallet = {
+        key: child.key,
+        source: "child",
+        childId: child.id,
+        keyPrefix: child.key_prefix,
+        name: child.name,
+        dailyBudget: child.daily_budget,
+        perRequestLimit: child.per_request_limit,
+        totalBudget: child.total_budget,
+        createdAt: this.now().toISOString()
+      };
+      this.save(s);
+      return { wallet: maskWallet(st.wallet) };
+    });
+  }
+  pasteWallet(agent, body) {
+    return this.exclusive(async () => {
+      const s = this.store();
+      if (!s.server) throw new UserError(400, "NO_ACCOUNT", "connect your MoneySwitch account first");
+      const key = typeof body.key === "string" ? body.key.trim() : "";
+      if (!/^mk_live_[A-Za-z0-9_-]{8,}$/.test(key)) throw new UserError(400, "INVALID_KEY", "paste a MoneyKey that starts with mk_live_");
+      let st;
+      try {
+        st = await new MoneyApi(s.server, key, this.fetchImpl).status();
+      } catch (e) {
+        const err = e;
+        throw new UserError(err.httpStatus === 401 ? 400 : 502, err.code, err.message);
+      }
+      const a = this.agentState(s, agent);
+      a.wallet = {
+        key,
+        source: "pasted",
+        keyPrefix: st.key_prefix,
+        name: st.key_name,
+        dailyBudget: st.daily_budget,
+        perRequestLimit: st.per_request_limit,
+        totalBudget: st.total_budget,
+        createdAt: this.now().toISOString()
+      };
+      this.save(s);
+      return { wallet: maskWallet(a.wallet) };
+    });
+  }
+  /** Forget the wallet key locally; optionally revoke the child on the server. Refused while it is written into the agent. */
+  clearWallet(agent, body) {
+    return this.exclusive(async () => {
+      const s = this.store();
+      const st = this.agentState(s, agent);
+      if (st.applied?.parts.wallet) throw new UserError(409, "STILL_ENABLED", "turn this agent off first, then remove its key");
+      const w = st.wallet;
+      let revoked = false;
+      if (w && body.revoke === true && w.childId) {
+        try {
+          await this.api(s).revokeChild(w.childId);
+          revoked = true;
+        } catch (e) {
+          const err = e;
+          throw new UserError(502, err.code, err.message);
+        }
+      }
+      st.wallet = null;
+      this.save(s);
+      return { revoked };
+    });
+  }
+  // ------------------------------------------------------- preview / apply
+  async target(s, agent, walletOverride) {
+    const st = s.agents[agent] ?? {};
+    const wallet = walletOverride !== void 0 ? walletOverride : st.wallet;
+    if (wallet && !s.server) throw new UserError(400, "NO_ACCOUNT", "connect your MoneySwitch account first");
+    const mcp = await this.mcpCommand(s.server ?? "");
+    return { brain: st.brain ?? null, wallet: wallet && s.server ? { server: s.server, key: wallet.key } : null, mcpCommand: mcp };
+  }
+  planFor(agent, action, target, st) {
+    try {
+      return agent === "claude" ? planClaude(this.env, action, target, st.applied) : planCodex(this.env, action, target, st.applied);
+    } catch (e) {
+      if (e instanceof AgentConfigError) throw new UserError(422, e.code, e.message);
+      throw e;
+    }
+  }
+  planId(agent, action, inputHash, target, st) {
+    return sha256(
+      stableStringify({
+        agent,
+        action,
+        inputHash,
+        brain: target?.brain ? { ...target.brain, apiKey: sha256(target.brain.apiKey) } : null,
+        wallet: target?.wallet ? { server: target.wallet.server, key: sha256(target.wallet.key) } : null,
+        mcp: target?.mcpCommand ?? null,
+        appliedAt: st.applied?.at ?? null
+      })
+    ).slice(0, 32);
+  }
+  async preview(agent, action) {
+    if (!isAuto(agent)) throw new UserError(400, "NOT_SUPPORTED", "this agent is configured by hand (see the steps on its card)");
+    if (action !== "enable" && action !== "disable") throw new UserError(400, "INVALID_ACTION", "action must be enable or disable");
+    const s = this.store();
+    const st = s.agents[agent] ?? {};
+    if (action === "enable" && !st.brain && !st.wallet) throw new UserError(400, "NOTHING_TO_ENABLE", "set a model or a MoneyKey for this agent first");
+    if (action === "disable" && !st.applied) throw new UserError(400, "NOT_ENABLED", "nothing to turn off");
+    const target = action === "enable" ? await this.target(s, agent) : null;
+    const { plan, inputHash } = this.planFor(agent, action, target, st);
+    return { plan, planId: this.planId(agent, action, inputHash, target, st) };
+  }
+  apply(agent, action, planId) {
+    return this.exclusive(async () => {
+      const { planId: current } = await this.preview(agent, action);
+      if (planId !== current) throw new UserError(409, "PLAN_CHANGED", "the configuration changed since the preview; review the new diff and confirm again");
+      return this.applyNow(agent, action);
+    });
+  }
+  async applyNow(agent, action) {
+    const s = this.store();
+    const st = this.agentState(s, agent);
+    const target = action === "enable" ? await this.target(s, agent) : null;
+    let result;
+    try {
+      result = agent === "claude" ? applyClaudePlan(this.env, action, target, st.applied, this.runner, this.now()) : applyCodexPlan(this.env, action, target, st.applied, this.now());
+    } catch (e) {
+      if (e instanceof AgentConfigError) throw new UserError(e.code === "NOT_INSTALLED" ? 424 : 500, e.code, e.message);
+      throw e;
+    }
+    st.applied = result.applied;
+    this.save(s);
+    return { status: this.agentStatus(agent, st), backups: result.backups, applied: st.applied ? { at: st.applied.at, backups: st.applied.backups, parts: st.applied.parts } : null };
+  }
+  // ---------------------------------------------------------------- bulk
+  bulkAgents() {
+    const det = this.detect();
+    return AUTO_AGENTS.filter((a) => det[a].installed);
+  }
+  async bulkPreview() {
+    const s = this.store();
+    const api = this.api(s);
+    const agents = this.bulkAgents();
+    if (!agents.length) throw new UserError(400, "NO_AGENTS", "no Claude Code or Codex found on this computer");
+    let parent;
+    try {
+      parent = await api.status();
+    } catch (e) {
+      const err = e;
+      throw new UserError(502, err.code, err.message);
+    }
+    if (parent.can_create_children === false) throw new UserError(403, "CANNOT_DELEGATE", "this MoneyKey is not allowed to create child keys");
+    const budgets = suggestChildBudgets(parent, agents.length);
+    if (toMicros(budgets.daily_budget) <= 0n) throw new UserError(400, "NO_BUDGET_LEFT", "nothing left to split today");
+    const items = [];
+    const ids = [];
+    for (const agent of agents) {
+      const st = s.agents[agent] ?? {};
+      const target = await this.target(s, agent, { key: NEW_CHILD_PLACEHOLDER, source: "child" });
+      const { plan, inputHash } = this.planFor(agent, "enable", target, st);
+      for (const f of plan.files) for (const c of f.changes) if (c.after === maskSecret(NEW_CHILD_PLACEHOLDER)) c.after = NEW_CHILD_MARK;
+      for (const c of plan.commands) c.display = c.display.replace(maskSecret(NEW_CHILD_PLACEHOLDER), NEW_CHILD_MARK);
+      ids.push(this.planId(agent, "bulk", inputHash, target, st));
+      items.push({ agent, budgets, plan, replacesWallet: Boolean(st.wallet) });
+    }
+    return { planId: sha256(stableStringify({ ids, budgets })).slice(0, 32), budgets, items };
+  }
+  bulkApply(planId) {
+    return this.exclusive(async () => {
+      const pv = await this.bulkPreview();
+      if (pv.planId !== planId) throw new UserError(409, "PLAN_CHANGED", "something changed since the preview; review the new diff and confirm again");
+      const done = [];
+      for (const item of pv.items) {
+        try {
+          const s = this.store();
+          const child = await this.api(s).createChild({
+            name: `${AGENT_INFO[item.agent].name} @ ${os2.hostname()}`.slice(0, 80),
+            ...item.budgets
+          });
+          const st = this.agentState(s, item.agent);
+          st.wallet = {
+            key: child.key,
+            source: "child",
+            childId: child.id,
+            keyPrefix: child.key_prefix,
+            name: child.name,
+            dailyBudget: child.daily_budget,
+            perRequestLimit: child.per_request_limit,
+            totalBudget: child.total_budget,
+            createdAt: this.now().toISOString()
+          };
+          this.save(s);
+          const r = await this.applyNow(item.agent, "enable");
+          done.push({ agent: item.agent, status: r.status, backups: r.backups });
+        } catch (e) {
+          const err = e;
+          throw new UserError(
+            err.status ?? 502,
+            err.code ?? "BULK_FAILED",
+            `${AGENT_INFO[item.agent].name}: ${err.message}`,
+            { done }
+          );
+        }
+      }
+      return { done };
+    });
+  }
+};
+
+// src/desktop/server.ts
+var MAX_BODY = 64 * 1024;
+var SECURITY_HEADERS = {
+  "X-Content-Type-Options": "nosniff",
+  "X-Frame-Options": "DENY",
+  "Referrer-Policy": "no-referrer",
+  "Cache-Control": "no-store",
+  "Content-Security-Policy": "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; connect-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'"
+};
+function send(res, status, body, extra = {}) {
+  const text = JSON.stringify(body);
+  res.writeHead(status, { ...SECURITY_HEADERS, "Content-Type": "application/json; charset=utf-8", ...extra });
+  res.end(text);
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let size = 0;
+    const chunks = [];
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > MAX_BODY) {
+        reject(new UserError(413, "TOO_LARGE", "request body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      if (!raw) return resolve({});
+      try {
+        const v = JSON.parse(raw);
+        resolve(v && typeof v === "object" && !Array.isArray(v) ? v : {});
+      } catch {
+        reject(new UserError(400, "BAD_JSON", "invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml"
+};
+function serveAsset(res, assetsDir, urlPath) {
+  const rel = urlPath === "/" ? "index.html" : urlPath.replace(/^\/+/, "");
+  if (!/^[A-Za-z0-9._-]+$/.test(rel)) return send(res, 404, { error: "NOT_FOUND" });
+  const file = path5.join(assetsDir, rel);
+  if (!fs4.existsSync(file)) return send(res, 404, { error: "NOT_FOUND" });
+  res.writeHead(200, { ...SECURITY_HEADERS, "Content-Type": MIME[path5.extname(file)] ?? "application/octet-stream" });
+  fs4.createReadStream(file).pipe(res);
+}
+function agentParam(v) {
+  if (!ALL_AGENTS.includes(v)) throw new UserError(404, "UNKNOWN_AGENT", "unknown agent");
+  return v;
+}
+function createUiServer(opts) {
+  const sessions = opts.sessions ?? new SessionManager(opts.port);
+  const svc = opts.service;
+  const log = opts.log ?? (() => void 0);
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const p = url.pathname;
+    const method = (req.method ?? "GET").toUpperCase();
+    try {
+      const denied = guardRequest(sessions, { method, headers: req.headers, url: p });
+      if (denied) return send(res, denied.status, { error: denied.code, message: denied.message });
+      if (!p.startsWith("/api/")) {
+        if (method !== "GET" && method !== "HEAD") return send(res, 405, { error: "METHOD_NOT_ALLOWED" });
+        return serveAsset(res, opts.assetsDir, p);
+      }
+      log(`${method} ${p}`);
+      const body = method === "GET" ? {} : await readBody(req);
+      const m = (re) => re.exec(p);
+      let r;
+      if (method === "POST" && p === "/api/session") {
+        const sid = sessions.exchange(body.token);
+        if (!sid) return send(res, 401, { error: "BAD_TOKEN", message: "this link was already used or is wrong; run `moneyswitch ui` again" });
+        return send(res, 200, { ok: true }, { "Set-Cookie": sessions.cookieHeader(sid) });
+      }
+      if (method === "POST" && p === "/api/logout") {
+        const sid = readCookie(req.headers.cookie, COOKIE_NAME);
+        if (sid) sessions.revoke(sid);
+        return send(res, 200, { ok: true }, { "Set-Cookie": `${COOKIE_NAME}=; HttpOnly; SameSite=Strict; Path=/; Max-Age=0` });
+      }
+      if (method === "GET" && p === "/api/state") return send(res, 200, await svc.state());
+      if (method === "GET" && p === "/api/usage") return send(res, 200, await svc.usage());
+      if (method === "POST" && p === "/api/detect") {
+        svc.detect(true);
+        return send(res, 200, await svc.state());
+      }
+      if (method === "PUT" && p === "/api/account") return send(res, 200, await svc.setAccount(body.server, body.key));
+      if (method === "DELETE" && p === "/api/account") return send(res, 200, await svc.clearAccount());
+      if (method === "POST" && p === "/api/bulk/preview") return send(res, 200, await svc.bulkPreview());
+      if (method === "POST" && p === "/api/bulk/apply") return send(res, 200, await svc.bulkApply(body.planId));
+      if (r = m(/^\/api\/agents\/([a-z]+)\/(brain|brain\/test|wallet|wallet\/child|preview|apply)$/)) {
+        const agent = agentParam(r[1]);
+        const what = r[2];
+        if (method === "PUT" && what === "brain") return send(res, 200, await svc.saveBrain(agent, body));
+        if (method === "POST" && what === "brain/test") return send(res, 200, await svc.testBrain(agent, body));
+        if (method === "POST" && what === "wallet/child") return send(res, 200, await svc.createChild(agent, body));
+        if (method === "PUT" && what === "wallet") return send(res, 200, await svc.pasteWallet(agent, body));
+        if (method === "DELETE" && what === "wallet") return send(res, 200, await svc.clearWallet(agent, body));
+        if (method === "POST" && what === "preview") return send(res, 200, await svc.preview(agent, body.action));
+        if (method === "POST" && what === "apply") return send(res, 200, await svc.apply(agent, body.action, body.planId));
+      }
+      return send(res, 404, { error: "NOT_FOUND" });
+    } catch (e) {
+      if (e instanceof UserError) return send(res, e.status, { error: e.code, message: e.message, detail: e.detail ?? null });
+      log(`error ${method} ${p}: ${e.message}`);
+      return send(res, 500, { error: "INTERNAL", message: e.message });
+    }
+  });
+  return { server, sessions };
+}
+
+// src/desktop/ui.ts
+var UI_HELP = `moneyswitch ui - local desktop console (SPEC-v0.4 \xA7B)
+
+Usage:
+  moneyswitch ui [--port 4318] [--no-open]
+
+Starts a web console on http://127.0.0.1:<port> (loopback only) and opens it
+with a one-time login link. Configure Claude Code / Codex: model key ("brain")
++ MoneyKey ("wallet"), preview the exact config diff, then enable.
+
+Environment: MONEYSWITCH_UI_PORT, MONEYSWITCH_UI_NO_OPEN=1.
+All paths follow HOME/USERPROFILE, CLAUDE_CONFIG_DIR and CODEX_HOME.`;
+function parseUiArgs(argv, env = process.env) {
+  let port = env.MONEYSWITCH_UI_PORT ? Number(env.MONEYSWITCH_UI_PORT) : 4318;
+  let open = env.MONEYSWITCH_UI_NO_OPEN !== "1";
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--port") {
+      port = Number(argv[++i]);
+    } else if (a.startsWith("--port=")) {
+      port = Number(a.slice(7));
+    } else if (a === "--no-open") {
+      open = false;
+    } else if (a === "--help" || a === "-h") {
+      help = true;
+    } else {
+      return { error: `unknown argument: ${a}` };
+    }
+  }
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return { error: "--port must be 1-65535" };
+  return { port, open, help };
+}
+function openBrowser(url) {
+  const opts = { detached: true, stdio: "ignore", windowsHide: true };
+  const child = process.platform === "win32" ? spawn("cmd", ["/c", "start", '""', `"${url}"`], { ...opts, windowsVerbatimArguments: true }) : spawn(process.platform === "darwin" ? "open" : "xdg-open", [url], opts);
+  child.on("error", () => void 0);
+  child.unref();
+}
+async function runUi(argv) {
+  const parsed = parseUiArgs(argv);
+  if ("error" in parsed) {
+    process.stderr.write(`moneyswitch ui: ${parsed.error}
+
+${UI_HELP}
+`);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(UI_HELP + "\n");
+    return 0;
+  }
+  const env = process.env;
+  const service = new DesktopService({ env, runner: new RealCommandRunner({ env, timeoutMs: 6e4 }) });
+  const sessions = new SessionManager(parsed.port);
+  const assetsDir = path6.join(path6.dirname(fileURLToPath(import.meta.url)), "ui");
+  const { server } = createUiServer({
+    port: parsed.port,
+    service,
+    assetsDir,
+    sessions,
+    log: env.MONEYSWITCH_UI_DEBUG ? (l) => process.stderr.write(`[ui] ${l}
+`) : void 0
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(parsed.port, "127.0.0.1", () => resolve());
+  }).catch((e) => {
+    if (e.code === "EADDRINUSE") {
+      process.stderr.write(`moneyswitch ui: port ${parsed.port} is already in use (another console running?). Try --port ${parsed.port + 1}.
+`);
+    } else {
+      process.stderr.write(`moneyswitch ui: ${e.message}
+`);
+    }
+    process.exit(1);
+  });
+  const url = `http://127.0.0.1:${parsed.port}/#${sessions.pendingToken}`;
+  process.stdout.write(
+    `MoneySwitch desktop console: http://127.0.0.1:${parsed.port}
+One-time login link (do not share): ${url}
+Press Ctrl+C to stop.
+`
+  );
+  if (parsed.open) openBrowser(url);
+  await new Promise((resolve) => {
+    const stop = () => server.close(() => resolve());
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  return 0;
+}
+export {
+  UI_HELP,
+  parseUiArgs,
+  runUi
+};
+/*! Bundled license information:
+
+smol-toml/dist/error.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/date.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/util.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/