ledung 1.4.0 → 1.6.0

package/dist/cli.js

@@ -2,10 +2,11 @@
 
 // src/cli.ts
 import { spawn as spawn3 } from "node:child_process";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/config.ts
-import path4 from "node:path";
+import fs5 from "node:fs";
+import path7 from "node:path";
 import { z as z6 } from "zod";
 
 // src/platform/paths.ts
@@ -98,7 +99,19 @@ var FORMS = [
   ]
 ];
 
+// src/sessions/sensitive.ts
+function validateSensitive(project) {
+  for (const p of [...project.commandPatterns ?? [], ...project.pathPatterns ?? []]) {
+    try {
+      new RegExp(p, "i");
+    } catch (e) {
+      throw new Error(`The sensitive pattern /${p}/ is not a valid regular expression: ${e.message}`);
+    }
+  }
+}
+
 // src/sessions/profiles.ts
+import path2 from "node:path";
 import { z as z4 } from "zod";
 
 // src/sessions/tools.ts
@@ -213,6 +226,8 @@ var projectSettings = {
 };
 
 // src/sessions/profiles.ts
+var FULL_PROFILE = "full";
+var PROFILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/;
 var McpServer = z4.union([
   z4.object({ type: z4.literal("stdio").optional(), command: z4.string().min(1), args: z4.array(z4.string()).optional(), env: z4.record(z4.string(), z4.string()).optional() }),
   z4.object({ type: z4.enum(["http", "sse"]), url: z4.string().min(1), headers: z4.record(z4.string(), z4.string()).optional() })
@@ -243,7 +258,53 @@ var ProfileSetting = z4.object({
 var withoutComments = (v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).filter(([k]) => !k.startsWith("$"))) : v;
 var ProfilesSetting = z4.preprocess(withoutComments, z4.record(z4.string(), ProfilePatchSetting)).default({});
 var RoleProfilesSetting = z4.object({ manager: z4.string().optional(), session: z4.string().optional() });
+var ledungTool = (name) => name === `mcp__${LEDUNG_SERVER}` || name.startsWith(`mcp__${LEDUNG_SERVER}__`);
 var LEDUNG_NAMES = [`mcp__${LEDUNG_SERVER}`, `mcp__${LEDUNG_SERVER}__ask_user`];
+var takesLedungTool = (rule) => {
+  const tool2 = rule.trim().replace(/\(.*$/s, "").toLowerCase();
+  if (!tool2.includes("*")) return ledungTool(tool2);
+  const glob = new RegExp(`^${tool2.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`);
+  return LEDUNG_NAMES.some((name) => glob.test(name));
+};
+function permissionRules(settings) {
+  const p = settings?.permissions;
+  if (!p || typeof p !== "object" || Array.isArray(p)) return [];
+  return ["deny", "ask"].flatMap((list2) => {
+    const rules = p[list2];
+    return Array.isArray(rules) ? rules.filter((r) => typeof r === "string").map((rule) => ({ list: list2, rule })) : [];
+  });
+}
+function validateProfiles(profiles, defaults) {
+  for (const [name, p] of Object.entries(profiles)) {
+    if (!PROFILE_NAME.test(name)) throw new Error(`profiles: "${name}" is not a usable name (letters, digits, ".", "_" or "-", at most 32).`);
+    if (name === FULL_PROFILE) throw new Error(`profiles: "${FULL_PROFILE}" is built in (the user's whole setup) and can't be redefined.`);
+    const taken = (p.disallowedTools ?? []).filter(takesLedungTool);
+    if (taken.length) throw new Error(`profiles.${name}.disallowedTools: Ledung's own tools always stay (${taken.join(", ")}).`);
+    const rules = permissionRules(p.settings).filter((r) => takesLedungTool(r.rule));
+    if (rules.length) throw new Error(`profiles.${name}.settings.permissions.${rules[0].list}: Ledung's own tools always stay (${rules.map((r) => r.rule).join(", ")}).`);
+    if (p.settingsFile !== void 0) {
+      const problem = settingsFileProblem(p.settingsFile);
+      if (problem) throw new Error(`profiles.${name}.settingsFile: ${problem}`);
+    }
+    if (typeof p.mcpServers === "object") {
+      const clash = Object.keys(p.mcpServers).filter((k) => k === LEDUNG_SERVER);
+      if (clash.length) throw new Error(`profiles.${name}.mcpServers: "${clash[0]}" is Ledung's own server's name.`);
+    }
+  }
+  for (const role of ["manager", "session"]) {
+    if (!defaults) break;
+    const name = defaults[role];
+    if (name !== void 0 && name !== FULL_PROFILE && !profiles[name]) throw new Error(`defaultProfiles.${role}: no profile named "${name}".`);
+  }
+}
+function settingsFileProblem(file) {
+  if (path2.posix.isAbsolute(file) || path2.win32.isAbsolute(file) || /^[A-Za-z]:/.test(file)) return `"${file}" must be relative to the project folder.`;
+  const normal = settingsFilePath(file);
+  if (normal === ".." || normal.startsWith("../")) return `"${file}" must stay inside the project folder.`;
+  if (normal === "." || normal.endsWith("/")) return `"${file}" is a folder, not a file.`;
+  return null;
+}
+var settingsFilePath = (file) => path2.posix.normalize(file.split("\\").join("/"));
 
 // src/sessions/skills.ts
 import { z as z5 } from "zod";
@@ -266,17 +327,34 @@ var STALE_AFTER_MS = 30 * 24 * 60 * 60 * 1e3;
 var USAGE_REPO = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
 
 // src/accounts/store.ts
+import os4 from "node:os";
+import path6 from "node:path";
+
+// src/accounts/signin-store.ts
+import { createHash } from "node:crypto";
+import fs4 from "node:fs";
+import os3 from "node:os";
+import path5 from "node:path";
+
+// src/accounts/signin.ts
+import { execFile as execFile2 } from "node:child_process";
+
+// src/runners/claude-program.ts
+import { execFile } from "node:child_process";
+import fs3 from "node:fs";
+import { createRequire } from "node:module";
 import os2 from "node:os";
-import path3 from "node:path";
+import path4 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/platform/exercised.ts
 import fs2 from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 var EXERCISED_FILE = "exercised.log";
 var MAX_BYTES = 256 * 1024;
 var DEFAULT_TARGET = {
   console: !PACKAGED,
-  file: () => path2.join(userDataDir(), EXERCISED_FILE)
+  file: () => path3.join(userDataDir(), EXERCISED_FILE)
 };
 function exercisedLine(line, target = DEFAULT_TARGET) {
   if (target.console) console.log(line);
@@ -292,11 +370,417 @@ function exercisedLine(line, target = DEFAULT_TARGET) {
   }
 }
 
+// src/runners/claude-program.ts
+var SDK = "@anthropic-ai/claude-agent-sdk";
+function sdkClaudeBinary(resolve = createRequire(import.meta.resolve(SDK)).resolve) {
+  const exe = process.platform === "win32" ? ".exe" : "";
+  const arch = process.arch;
+  let packages = [`${SDK}-${process.platform}-${arch}`];
+  if (process.platform === "linux") {
+    const report = process.report?.getReport?.();
+    const musl = report !== void 0 && report.header?.glibcVersionRuntime === void 0;
+    packages = musl ? [`${SDK}-linux-${arch}-musl`, `${SDK}-linux-${arch}`] : [`${SDK}-linux-${arch}`, `${SDK}-linux-${arch}-musl`];
+  }
+  for (const p of packages) {
+    try {
+      return resolve(`${p}/claude${exe}`);
+    } catch {
+    }
+  }
+  return null;
+}
+function sdkClaudeVersion() {
+  try {
+    const sdk = path4.dirname(fileURLToPath2(import.meta.resolve(SDK)));
+    const v = JSON.parse(fs3.readFileSync(path4.join(sdk, "package.json"), "utf8")).claudeCodeVersion;
+    return typeof v === "string" ? v : null;
+  } catch {
+    return null;
+  }
+}
+function parseVersion(text) {
+  return text.trim().match(/^v?(\d+\.\d+\.\d+)/)?.[1] ?? null;
+}
+function atLeast(have, need) {
+  const a = have.split(".").map(Number);
+  const b = need.split(".").map(Number);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    if ((a[i] ?? 0) !== (b[i] ?? 0)) return (a[i] ?? 0) > (b[i] ?? 0);
+  }
+  return true;
+}
+function commandFor(program) {
+  return /\.(c|m)?js$/i.test(program) ? { command: process.execPath, args: [program] } : { command: program, args: [] };
+}
+var runVersion = (program) => new Promise((resolve) => {
+  const { command, args } = commandFor(program);
+  execFile(command, [...args, "--version"], { windowsHide: true, timeout: 15e3 }, (err, stdout) => resolve(err ? null : String(stdout)));
+});
+function regValue(text, name, env) {
+  const row = text.split(/\r?\n/).map((l) => l.trim().split(/\s{2,}|\t/)).find((cols) => cols[0]?.toLowerCase() === name.toLowerCase() && /^REG_(EXPAND_)?SZ$/i.test(cols[1] ?? ""));
+  const value = row?.slice(2).join("  ");
+  if (!value) return null;
+  return value.replace(/%([^%]+)%/g, (whole, v) => {
+    const key = Object.keys(env).find((k) => k.toLowerCase() === v.toLowerCase());
+    return key ? env[key] ?? whole : whole;
+  });
+}
+var regQuery = (key) => new Promise((resolve) => {
+  execFile("reg", ["query", key, "/v", "Path"], { windowsHide: true, timeout: 5e3 }, (err, stdout) => resolve(err ? "" : String(stdout)));
+});
+async function windowsPath() {
+  const [machine, user] = await Promise.all([
+    regQuery("HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment"),
+    regQuery("HKCU\\Environment")
+  ]);
+  const parts = [regValue(machine, "Path", process.env), regValue(user, "Path", process.env)].filter((v) => !!v);
+  return parts.length ? parts.join(";") : null;
+}
+function realLookup() {
+  return {
+    platform: process.platform,
+    env: process.env,
+    home: os2.homedir(),
+    stat: (file) => {
+      try {
+        const s = fs3.statSync(file);
+        return s.isFile() ? { size: s.size, mtimeMs: s.mtimeMs } : null;
+      } catch {
+        return null;
+      }
+    },
+    readText: (file) => {
+      try {
+        return fs3.readFileSync(file, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    realpath: (file) => {
+      try {
+        return fs3.realpathSync(file);
+      } catch {
+        return file;
+      }
+    },
+    versionText: runVersion,
+    listDir: (dir) => {
+      try {
+        return fs3.readdirSync(dir);
+      } catch {
+        return [];
+      }
+    },
+    ...process.platform === "win32" ? { freshPath: windowsPath } : {},
+    bundled: sdkClaudeBinary(),
+    required: sdkClaudeVersion(),
+    packaged: PACKAGED
+  };
+}
+function noBundledProblem(look) {
+  if (!look.packaged) return `Ledung has no Claude Code of its own for ${look.platform}-${process.arch} ("claudeExecutable": "bundled" in the config). Install Claude Code from ${INSTALL_LINK} and set it back to "installed".`;
+  return `Ledung installed from npm has no Claude Code of its own ("claudeExecutable": "bundled" in the config). Install Claude Code from ${INSTALL_LINK}, then set "claudeExecutable" back to "installed" in the config file (Settings \u2192 Config file says where it is).`;
+}
+function shimTarget(shim, look) {
+  const text = look.readText(shim);
+  if (!text) return null;
+  const dir = path4.win32.dirname(shim);
+  const found = [...text.matchAll(/"%~?dp0%?\\?([^"%]+?\.(?:exe|c?js|mjs))"/gi)].map((m) => path4.win32.join(dir, m[1]));
+  return found.reverse().find((f) => look.stat(f) !== null) ?? null;
+}
+function knownLocations(look) {
+  const { home, env } = look;
+  if (look.platform === "win32") {
+    const p2 = path4.win32;
+    const appData = env.APPDATA ?? p2.join(home, "AppData", "Roaming");
+    const localAppData = env.LOCALAPPDATA ?? p2.join(home, "AppData", "Local");
+    return [
+      p2.join(home, ".local", "bin", "claude.exe"),
+      p2.join(appData, "npm", "claude.cmd"),
+      ...env.npm_config_prefix ? [p2.join(env.npm_config_prefix, "claude.cmd")] : [],
+      // `winget install Anthropic.ClaudeCode` links it here, for the user or for the whole computer (#455).
+      p2.join(localAppData, "Microsoft", "WinGet", "Links", "claude.exe"),
+      p2.join(env.ProgramFiles ?? "C:\\Program Files", "WinGet", "Links", "claude.exe")
+    ];
+  }
+  const p = path4.posix;
+  return [
+    p.join(home, ".local", "bin", "claude"),
+    p.join(home, ".claude", "local", "claude"),
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude",
+    "/home/linuxbrew/.linuxbrew/bin/claude",
+    p.join(home, ".npm-global", "bin", "claude"),
+    ...env.npm_config_prefix ? [p.join(env.npm_config_prefix, "bin", "claude")] : []
+  ];
+}
+function programOf(file, look) {
+  if (look.platform === "win32") {
+    if (/\.exe$/i.test(file)) return file;
+    return /\.cmd$/i.test(file) ? shimTarget(file, look) : null;
+  }
+  const real = look.realpath(file);
+  return /\.(c|m)?js$/i.test(real) ? real : file;
+}
+function isDesktopApp(file) {
+  return /[\\/]AnthropicClaude[\\/](app-[^\\/]+[\\/])?claude\.exe$/i.test(file) || /[\\/]Claude\.app[\\/]Contents[\\/]MacOS[\\/]/.test(file);
+}
+function searchInstalled(look, pathVar = look.env.PATH ?? look.env.Path ?? "") {
+  const win = look.platform === "win32";
+  const sep = win ? ";" : ":";
+  const names = win ? ["claude.exe", "claude.cmd"] : ["claude"];
+  const onPath = pathVar.split(sep).filter(Boolean).flatMap((dir) => names.map((n) => (win ? path4.win32 : path4.posix).join(dir, n)));
+  const bundled = look.bundled ? look.realpath(look.bundled) : null;
+  const same = (a, b) => win ? a.toLowerCase() === b.toLowerCase() : a === b;
+  const looked = [];
+  for (const file of [...onPath, ...knownLocations(look)]) {
+    if (looked.some((l) => same(l, file))) continue;
+    looked.push(file);
+    if (!look.stat(file)) continue;
+    const program = programOf(file, look);
+    if (!program || !look.stat(program)) continue;
+    const real = look.realpath(program);
+    if (bundled && same(real, bundled)) continue;
+    if (/[\\/]node_modules[\\/]@anthropic-ai[\\/]claude-agent-sdk/i.test(real)) continue;
+    if (isDesktopApp(real)) continue;
+    return { program, looked };
+  }
+  return { program: null, looked };
+}
+function desktopAppFolders(look) {
+  const { home, env } = look;
+  if (look.platform === "win32") {
+    const p2 = path4.win32;
+    const appData = env.APPDATA ?? p2.join(home, "AppData", "Roaming");
+    const packages = p2.join(env.LOCALAPPDATA ?? p2.join(home, "AppData", "Local"), "Packages");
+    const store = (look.listDir?.(packages) ?? []).filter((n) => /^Claude_/i.test(n)).map((n) => p2.join(packages, n, "LocalCache", "Roaming", "Claude", "claude-code"));
+    return [p2.join(appData, "Claude", "claude-code"), ...store];
+  }
+  const p = path4.posix;
+  if (look.platform === "darwin") return [p.join(home, "Library", "Application Support", "Claude", "claude-code")];
+  return [p.join(env.XDG_CONFIG_HOME ?? p.join(home, ".config"), "Claude", "claude-code")];
+}
+function appProgramIn(look, versionDir, hash) {
+  if (look.platform === "win32") return path4.win32.join(versionDir, "claude.exe");
+  if (look.platform !== "darwin") return path4.posix.join(versionDir, "claude");
+  const inBundle = (h) => path4.posix.join(versionDir, h, "claude.app", "Contents", "MacOS", "claude");
+  if (hash) return inBundle(hash);
+  return (look.listDir?.(versionDir) ?? []).sort().map(inBundle).find((f) => look.stat(f)) ?? null;
+}
+function desktopAppCopy(look) {
+  const p = look.platform === "win32" ? path4.win32 : path4.posix;
+  const looked = [];
+  let best = null;
+  for (const folder of desktopAppFolders(look)) {
+    looked.push(appProgramIn(look, p.join(folder, "<version>"), "<hash>"));
+    for (const name of look.listDir?.(folder) ?? []) {
+      const version = parseVersion(name);
+      const program = version ? appProgramIn(look, p.join(folder, name)) : null;
+      if (!version || !program || !look.stat(program)) continue;
+      if (!best || !atLeast(best.version, version)) best = { program, version };
+    }
+  }
+  return { program: best?.program ?? null, looked };
+}
+var versions = /* @__PURE__ */ new Map();
+async function programVersion(program, look) {
+  const s = look.stat(program);
+  if (!s) return null;
+  const known = versions.get(program);
+  if (known && known.size === s.size && known.mtimeMs === s.mtimeMs) return known.version;
+  const version = parseVersion(await look.versionText(program) ?? "");
+  versions.set(program, { ...s, version });
+  return version;
+}
+var INSTALL_LINK = "https://code.claude.com/docs/en/setup";
+function installCommand(platform) {
+  return platform === "win32" ? "irm https://claude.ai/install.ps1 | iex" : "curl -fsSL https://claude.ai/install.sh | bash";
+}
+var appCopyLogged = false;
+async function chooseClaude(setting = "installed", look = realLookup()) {
+  const required = look.required;
+  const bundledVersion = look.bundled ? await programVersion(look.bundled, look) ?? required : null;
+  const bundled = look.bundled ? { kind: "bundled", path: look.bundled, version: bundledVersion } : null;
+  const base = { setting, required, bundled };
+  if (setting === "bundled") {
+    return { ...base, installed: null, program: bundled, problem: bundled ? null : noBundledProblem(look) };
+  }
+  const given = setting !== "installed";
+  let found;
+  let looked;
+  let app = false;
+  if (given) {
+    found = look.stat(setting) ? programOf(setting, look) : null;
+    looked = [setting];
+  } else {
+    ({ program: found, looked } = searchInstalled(look));
+    const fresh = found || !look.freshPath ? null : await look.freshPath();
+    if (fresh) {
+      const again = searchInstalled(look, fresh);
+      found = again.program;
+      looked = [...looked, ...again.looked.filter((l) => !looked.includes(l))];
+    }
+    if (!found) {
+      const copy = desktopAppCopy(look);
+      found = copy.program;
+      looked = [...looked, ...copy.looked];
+      app = found !== null;
+      if (app && !appCopyLogged) {
+        appCopyLogged = true;
+        exercisedLine("EXERCISED #455 Claude Code found as the desktop app's own copy");
+      }
+    }
+  }
+  const version = found ? await programVersion(found, look) : null;
+  const installed = found ? { kind: given ? "path" : "installed", path: found, version, ...app ? { app: true } : {} } : null;
+  const install = `install Claude Code (\`${installCommand(look.platform)}\`, or see ${INSTALL_LINK}), then press Check again`;
+  let problem = null;
+  if (!required) {
+    problem = "Ledung could not read which Claude Code version its Agent SDK needs (the SDK's package.json). Install Ledung again (`npm install`).";
+  } else if (!found) {
+    problem = given ? `Ledung runs your Claude Code, and there is none at ${setting} (the config's "claudeExecutable"). Install it from ${INSTALL_LINK}, or correct the path.` : `Ledung runs your Claude Code, and it isn't installed on this computer. Install it from ${INSTALL_LINK}, then press Check again.`;
+  } else if (app && !version) {
+    problem = `Ledung runs your Claude Code, and the only one on this computer is the Claude desktop app's own copy at ${found}, whose version couldn't be read. The app keeps that copy for itself: ${install}.`;
+  } else if (app && !atLeast(version, required)) {
+    problem = `Ledung runs your Claude Code, and the only one on this computer is the Claude desktop app's own copy, ${version} at ${found}; Ledung needs ${required} or newer. The app keeps that copy for itself: ${install}.`;
+  } else if (!version) {
+    problem = `Ledung runs your Claude Code, and the version of the one at ${found} couldn't be read. Update it (\`claude update\`) or install it again from ${INSTALL_LINK}.`;
+  } else if (!atLeast(version, required)) {
+    problem = `Ledung runs your Claude Code, and yours is ${version}; Ledung needs ${required} or newer. Update it (\`claude update\`), then press Check again.`;
+  }
+  return { ...base, installed, program: problem ? null : installed, problem, looked };
+}
+
+// src/accounts/signin.ts
+function signInKind(method, subscriptionType) {
+  if (method === "oauth_token") return "token";
+  if (method === "api_key") return "key";
+  if (method !== "claude.ai") return null;
+  if (subscriptionType === null) return "token";
+  return typeof subscriptionType === "string" && subscriptionType ? "login" : null;
+}
+function readAuthStatus(result) {
+  const at = Date.now();
+  if (result.error) return { state: "unknown", method: null, detail: result.error, checkedAt: at };
+  const parsed = jsonOf(result.stdout);
+  if (!parsed || typeof parsed.loggedIn !== "boolean") {
+    return { state: "unknown", method: null, detail: `claude auth status gave no answer (exit code ${result.code ?? "none"})`, checkedAt: at };
+  }
+  const method = typeof parsed.authMethod === "string" && parsed.authMethod !== "none" ? parsed.authMethod : null;
+  return parsed.loggedIn ? { state: "in", method, detail: null, checkedAt: at } : { state: "out", method: null, detail: null, checkedAt: at };
+}
+function readSignIn(result) {
+  const found = readAuthStatus(result);
+  if (found.state !== "in") return found;
+  const said = jsonOf(result.stdout);
+  return { ...found, kind: signInKind(said.authMethod, said.subscriptionType) };
+}
+function jsonOf(text) {
+  try {
+    const v = JSON.parse(text);
+    return v && typeof v === "object" ? v : null;
+  } catch {
+    return null;
+  }
+}
+var runCommand = (command, args, env, timeoutMs, cwd) => new Promise((resolve) => {
+  execFile2(command, args, { env, cwd, windowsHide: true, timeout: timeoutMs, maxBuffer: 1024 * 1024 }, (err, stdout) => {
+    const e = err;
+    if (!e) return resolve({ code: 0, stdout: String(stdout) });
+    if (e.killed) return resolve({ code: null, stdout: "", error: `Claude Code did not answer within ${Math.round(timeoutMs / 1e3)} s` });
+    if (typeof e.code === "number") return resolve({ code: e.code, stdout: String(stdout ?? "") });
+    resolve({ code: null, stdout: "", error: `Claude Code could not be run (${e.code ?? e.message})` });
+  });
+});
+async function checkSignIn(env, opts = {}) {
+  const binary = opts.binary !== void 0 ? opts.binary : sdkClaudeBinary();
+  if (!binary) return { state: "unknown", method: null, detail: "no Claude Code to ask: it is not installed, or too old (see Settings \u2192 Claude Code)", checkedAt: Date.now() };
+  const settings = opts.where?.settings && Object.keys(opts.where.settings).length ? ["--settings", JSON.stringify(opts.where.settings)] : [];
+  const { command, args } = commandFor(binary);
+  return readSignIn(await (opts.run ?? runCommand)(command, [...args, ...settings, "auth", "status", "--json"], env, opts.timeoutMs ?? 15e3, opts.where?.cwd));
+}
+
+// src/runners/runner.ts
+import { execFile as execFile3 } from "node:child_process";
+function runWithInput(command, args, input, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = execFile3(command, args, { windowsHide: true, timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err) reject(Object.assign(err, { stdout: String(stdout ?? ""), stderr: String(stderr ?? "") }));
+      else resolve({ stdout: String(stdout) });
+    });
+    child.stdin?.on("error", () => {
+    });
+    child.stdin?.end(input ?? "");
+  });
+}
+
+// src/accounts/signin-store.ts
+var CREDENTIALS = ".credentials.json";
+function localUser(read = () => os3.userInfo().username) {
+  try {
+    return read();
+  } catch {
+    return process.env.USER ?? process.env.LOGNAME ?? "";
+  }
+}
+function keychainEntry(folder, user = localUser()) {
+  return { service: `Claude Code-credentials-${createHash("sha256").update(folder.normalize("NFC")).digest("hex").slice(0, 8)}`, account: user };
+}
+function signInRecord(token) {
+  return JSON.stringify({ claudeAiOauth: { accessToken: token, refreshToken: null, expiresAt: null, scopes: ["user:inference"], subscriptionType: null, rateLimitTier: null } });
+}
+function localStore(platform = process.platform, run = runWithInput) {
+  if (platform === "darwin") {
+    return {
+      // `security` exits 44 when there is no such entry; without -w it prints no secret.
+      hasSignIn: async (folder) => {
+        const { service, account } = keychainEntry(folder);
+        try {
+          await run("security", ["find-generic-password", "-a", account, "-s", service], null, 2e4);
+          return true;
+        } catch (e) {
+          if (e.code === 44) return false;
+          throw new Error("the Keychain could not be read; if it is locked, `security unlock-keychain` unlocks it");
+        }
+      },
+      // Through `security -i`, so the record is on its standard input, not a command line anyone can list; as hex
+      // (-X), so no quoting can break it. -U replaces the entry that is there, and `security -i` exits non-zero
+      // when a line fails (probe of 2026-11-02).
+      put: async (folder, record) => {
+        const { service, account } = keychainEntry(folder);
+        const hex = Buffer.from(record, "utf8").toString("hex");
+        try {
+          await run("security", ["-i"], `add-generic-password -U -a "${account}" -s "${service}" -X ${hex}
+`, 2e4);
+        } catch {
+          throw new Error("the Keychain could not be written; if it is locked, `security unlock-keychain` unlocks it");
+        }
+      }
+    };
+  }
+  return {
+    hasSignIn: async (folder) => fs4.existsSync(path5.join(folder, CREDENTIALS)),
+    // Whole to a file of its own, readable only by the user, then renamed over the one that is there.
+    put: async (folder, record) => {
+      fs4.mkdirSync(folder, { recursive: true });
+      const temp = path5.join(folder, `${CREDENTIALS}.ledung-${process.pid}`);
+      try {
+        fs4.writeFileSync(temp, record, { mode: 384, flag: "wx" });
+        fs4.renameSync(temp, path5.join(folder, CREDENTIALS));
+      } finally {
+        fs4.rmSync(temp, { force: true });
+      }
+    }
+  };
+}
+
 // src/accounts/store.ts
 var ACCOUNT_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/;
 var DEFAULT_ACCOUNT = "default";
+var SIGN_IN_ENV = "CLAUDE_SECURESTORAGE_CONFIG_DIR";
+var LOGIN_ENV = ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY", SIGN_IN_ENV];
 function canonicalFolder(folder) {
-  return path3.resolve(folder);
+  return path6.resolve(folder);
 }
 function canonicalContainerFolder(folder) {
   const f = folder.trim().replace(/\/+$/, "");
@@ -309,7 +793,7 @@ function sameFolder(a, b, platform = process.platform) {
   return platform === "win32" || platform === "darwin" ? x.toLowerCase() === y.toLowerCase() : x === y;
 }
 function sharedLoginFolders() {
-  return [path3.join(os2.homedir(), ".claude"), ...process.env.CLAUDE_CONFIG_DIR ? [process.env.CLAUDE_CONFIG_DIR] : []];
+  return [path6.join(os4.homedir(), ".claude"), ...process.env.CLAUDE_CONFIG_DIR ? [process.env.CLAUDE_CONFIG_DIR] : []];
 }
 
 // src/config.ts
@@ -413,7 +897,7 @@ function withoutNotes(raw) {
 }
 var ClaudeAccountSetting = z6.preprocess(withoutNotes, z6.object({
   whatItIsFor: z6.string().trim().max(200).optional(),
-  signInFolderOnThisComputer: z6.string().trim().min(1, "give a folder, or leave the field out for Ledung's own").refine((f) => path4.isAbsolute(f), "give the whole path, such as D:\\Claude sign-ins\\work or /Users/you/claude-signins/work").refine((f) => !sharedLoginFolders().some((s) => sameFolder(s, f)), "that is this computer's own Claude Code folder; an account needs a folder of its own").optional(),
+  signInFolderOnThisComputer: z6.string().trim().min(1, "give a folder, or leave the field out for Ledung's own").refine((f) => path7.isAbsolute(f), "give the whole path, such as D:\\Claude sign-ins\\work or /Users/you/claude-signins/work").refine((f) => !sharedLoginFolders().some((s) => sameFolder(s, f)), "that is this computer's own Claude Code folder; an account needs a folder of its own").optional(),
   signInFolderInContainers: z6.string().trim().min(1, "give a folder, or leave the field out for ~/.ledung-accounts/<name>").refine((f) => canonicalContainerFolder(f) !== null, "starts with ~/ or /, of letters, digits and . _ / + - only").refine((f) => canonicalContainerFolder(f) !== "~/.claude", "that is the container user's own Claude Code folder; an account needs a folder of its own").optional()
 }).strict());
 var ClaudeAccountsSetting = z6.preprocess(withoutNotes, z6.record(z6.string(), ClaudeAccountSetting)).default({}).superRefine((accounts, ctx) => {
@@ -462,7 +946,7 @@ var LocalProject = z6.object({
    * Folders outside the project folder where its sessions may also work, such as where its git worktrees
    * go (start_session's cwd, decision of 2026-10-14). None: only the project folder and folders inside it.
    */
-  extraFolders: z6.array(z6.string().min(1).refine((f) => path4.isAbsolute(f), "Give each extra folder as a full path.")).max(20).optional(),
+  extraFolders: z6.array(z6.string().min(1).refine((f) => path7.isAbsolute(f), "Give each extra folder as a full path.")).max(20).optional(),
   model: z6.string().optional(),
   /** Its manager's model; none: the same as its sessions (decision of 2026-10-13). */
   managerModel: z6.string().optional(),
@@ -579,7 +1063,7 @@ var Config = z6.object({
    * One that is missing or older than the SDK needs is never run: sessions are refused and the page says how to fix it
    * (Martin, 2026-10-27). "bundled" only when set here. Containers run their own.
    */
-  claudeExecutable: z6.string().min(1).refine((v) => v === "installed" || v === "bundled" || path4.isAbsolute(v), 'claudeExecutable is "installed", "bundled" or a full path to Claude Code.').default("installed"),
+  claudeExecutable: z6.string().min(1).refine((v) => v === "installed" || v === "bundled" || path7.isAbsolute(v), 'claudeExecutable is "installed", "bundled" or a full path to Claude Code.').default("installed"),
   /** The shell a "!" command from the message box runs in on Windows (issue #212): Git Bash, as Claude's Bash tool, or PowerShell. */
   windowsShell: z6.enum(["bash", "powershell"]).default("bash"),
   board: BoardSetting,
@@ -609,13 +1093,68 @@ function workflowsOf(config) {
 }
 function configPath(packaged = PACKAGED) {
   const set = envSetting("CONFIG");
-  if (set) return path4.resolve(set);
-  if (packaged) return path4.join(userDataDir(), "ledung.config.json");
-  return path4.join(appDir(), "ledung.config.local.json");
+  if (set) return path7.resolve(set);
+  if (packaged) return path7.join(userDataDir(), "ledung.config.json");
+  return path7.join(appDir(), "ledung.config.local.json");
+}
+function parseConfig(raw) {
+  const result = Config.safeParse(raw);
+  if (!result.success) {
+    const problems = result.error.issues.map((i) => `  - ${i.path.join(".") || "(top level)"}: ${i.message}`).join("\n");
+    throw new Error(`The config has problems:
+${problems}`);
+  }
+  try {
+    validateSensitive(result.data.sensitive);
+    validateSensitive(result.data.chats.sensitive);
+    for (const p of result.data.projects) validateSensitive(p.sensitive);
+    const fromWorkflow = workflowsOf(result.data).some((w) => w.profilesFile);
+    validateProfiles(result.data.profiles, fromWorkflow ? null : result.data.defaultProfiles);
+  } catch (e) {
+    throw new Error(`The config has problems:
+  - ${e.message}`);
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const p of result.data.projects) {
+    if (names.has(p.name)) throw new Error(`The config has two projects named "${p.name}".`);
+    names.add(p.name);
+  }
+  return result.data;
+}
+function loadConfig(file = configPath()) {
+  if (!fs5.existsSync(file)) {
+    throw new Error(`No config file at ${file}. Copy ledung.config.example.json to ledung.config.local.json and fill it in.`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(fs5.readFileSync(file, "utf8"));
+  } catch (e) {
+    throw new Error(`The config file ${file} is not valid JSON: ${e.message}`);
+  }
+  return parseConfig(raw);
 }
 
 // src/platform/node-warnings.ts
 import { pathToFileURL } from "node:url";
+var exercised = false;
+function isSqliteWarning(warning, typeOrOptions) {
+  const type = typeof typeOrOptions === "string" ? typeOrOptions : warning instanceof Error ? warning.name : typeOrOptions?.type;
+  const text = warning instanceof Error ? warning.message : warning;
+  return type === "ExperimentalWarning" && typeof text === "string" && text.startsWith("SQLite is an experimental feature");
+}
+function dropSqliteWarning() {
+  const emit = process.emitWarning;
+  process.emitWarning = function(warning, ...rest) {
+    if (isSqliteWarning(warning, rest[0])) {
+      if (!exercised) {
+        exercised = true;
+        exercisedLine("EXERCISED #428 Node's SQLite warning kept off the console");
+      }
+      return;
+    }
+    return emit.call(this, warning, ...rest);
+  };
+}
 function coreArgs(entry2, passthrough2, restarted2, packaged = PACKAGED) {
   const preload = new URL(packaged ? "./preload.js" : "./preload.ts", pathToFileURL(entry2)).href;
   const args = ["--import", preload, entry2, ...passthrough2];
@@ -625,9 +1164,9 @@ function coreArgs(entry2, passthrough2, restarted2, packaged = PACKAGED) {
 
 // src/platform/running.ts
 import crypto from "node:crypto";
-import fs3 from "node:fs";
+import fs6 from "node:fs";
 import http from "node:http";
-import path5 from "node:path";
+import path8 from "node:path";
 
 // src/platform/open-browser.ts
 import { spawn } from "node:child_process";
@@ -643,8 +1182,8 @@ function openBrowser(url) {
 var NOT_RUNNING_CODE = 3;
 function configuredPort(configFile) {
   try {
-    if (!fs3.existsSync(configFile)) return DEFAULT_PORT;
-    const port = JSON.parse(fs3.readFileSync(configFile, "utf8")).port;
+    if (!fs6.existsSync(configFile)) return DEFAULT_PORT;
+    const port = JSON.parse(fs6.readFileSync(configFile, "utf8")).port;
     return port === void 0 ? DEFAULT_PORT : typeof port === "number" && Number.isInteger(port) ? port : null;
   } catch {
     return null;
@@ -652,7 +1191,7 @@ function configuredPort(configFile) {
 }
 function savedToken(dataDir = userDataDir()) {
   try {
-    const token = fs3.readFileSync(path5.join(dataDir, "auth-token"), "utf8").trim();
+    const token = fs6.readFileSync(path8.join(dataDir, "auth-token"), "utf8").trim();
     return /^[0-9a-f]{64}$/.test(token) ? token : null;
   } catch {
     return null;
@@ -698,8 +1237,8 @@ async function openIfRunning(opts) {
 
 // src/platform/background.ts
 import { spawn as spawn2 } from "node:child_process";
-import fs4 from "node:fs";
-import path6 from "node:path";
+import fs7 from "node:fs";
+import path9 from "node:path";
 
 // src/server/devices.ts
 var PAIR_CODE_MS = 10 * 60 * 1e3;
@@ -718,18 +1257,18 @@ var MAX_LOG_BYTES = 10 * 1024 * 1024;
 var READY_MS = 6e4;
 var STOPPED_MS = 6e4;
 function logFile(dataDir = userDataDir()) {
-  return path6.join(dataDir, LOG_FILE);
+  return path9.join(dataDir, LOG_FILE);
 }
 function rotateLog(file, maxBytes = MAX_LOG_BYTES) {
-  const size = fs4.statSync(file, { throwIfNoEntry: false })?.size ?? 0;
+  const size = fs7.statSync(file, { throwIfNoEntry: false })?.size ?? 0;
   if (size <= maxBytes) return;
-  const old = path6.join(path6.dirname(file), "ledung.old.log");
-  fs4.rmSync(old, { force: true });
-  fs4.renameSync(file, old);
+  const old = path9.join(path9.dirname(file), "ledung.old.log");
+  fs7.rmSync(old, { force: true });
+  fs7.renameSync(file, old);
 }
 function logTail(file, lines = 20) {
   try {
-    return fs4.readFileSync(file, "utf8").trimEnd().split(/\r?\n/).slice(-lines).join("\n");
+    return fs7.readFileSync(file, "utf8").trimEnd().split(/\r?\n/).slice(-lines).join("\n");
   } catch {
     return "";
   }
@@ -740,9 +1279,9 @@ async function startInBackground(opts) {
   const dataDir = opts.dataDir ?? userDataDir();
   const file = logFile(dataDir);
   rotateLog(file);
-  const out = fs4.openSync(file, "a", 384);
-  if (process.platform !== "win32") fs4.fchmodSync(out, 384);
-  fs4.writeSync(out, `
+  const out = fs7.openSync(file, "a", 384);
+  if (process.platform !== "win32") fs7.fchmodSync(out, 384);
+  fs7.writeSync(out, `
 --- ${(/* @__PURE__ */ new Date()).toISOString()} Ledung starting in the background
 `);
   const child = spawn2(process.execPath, opts.args, {
@@ -753,7 +1292,7 @@ async function startInBackground(opts) {
     // Shown in Settings next to the log's path: this Ledung's output goes there.
     env: { ...process.env, LEDUNG_LOG_FILE: file }
   });
-  fs4.closeSync(out);
+  fs7.closeSync(out);
   let exited = null;
   child.on("exit", (code) => {
     exited = code ?? 1;
@@ -812,6 +1351,148 @@ async function stopRunning(opts) {
   return 1;
 }
 
+// src/accounts/token-command.ts
+import path10 from "node:path";
+var USAGE = "Use: ledung account token <account name>. The token is asked for afterwards, or read from a pipe; it never goes on the command line.";
+var TOKEN = /^sk-ant-oat\d{2}-[A-Za-z0-9_-]{40,900}$/;
+function cleanToken(given) {
+  const lines = given.trim().split(/\r\n|\r|\n/).map((line) => line.trim());
+  if (lines.some((line) => !line || /\s/.test(line))) return null;
+  const token = lines.join("");
+  return TOKEN.test(token) && !token.includes("sk-ant-", 1) ? token : null;
+}
+function applyKeys(held, piece) {
+  let text = held;
+  const keys = piece.replace(/\x1b\[[0-9;?]*[A-Za-z~]/g, "");
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key === "") return { held: "", done: "stop" };
+    if (key === "") return { held: text, done: "enter" };
+    if (key === "\x7F" || key === "\b") text = text.slice(0, -1);
+    else if (key === "\r" || key === "\n") {
+      if (i === keys.length - 1) return { held: text, done: "enter" };
+      text += key;
+    } else if (key >= " ") text += key;
+  }
+  return { held: text, done: null };
+}
+function readHidden(input) {
+  return new Promise((resolve) => {
+    let held = "";
+    const finish = (value) => {
+      input.off("data", onData);
+      input.off("end", onEnd);
+      input.setRawMode(false);
+      input.pause();
+      resolve(value);
+    };
+    const onData = (chunk) => {
+      const next = applyKeys(held, String(chunk));
+      held = next.held;
+      if (next.done) finish(next.done === "stop" ? null : held);
+    };
+    const onEnd = () => finish(held);
+    input.setRawMode(true);
+    input.on("data", onData);
+    input.on("end", onEnd);
+    input.resume();
+  });
+}
+async function readPipe(input) {
+  let text = "";
+  for await (const chunk of input) text += String(chunk);
+  return text;
+}
+async function findInDatabase(name, file) {
+  dropSqliteWarning();
+  const { DatabaseSync } = await import("node:sqlite");
+  const db = new DatabaseSync(file, { readOnly: true });
+  try {
+    const rows = db.prepare("SELECT name, config_dir FROM accounts ORDER BY name").all();
+    const row = rows.find((r) => r.name === name);
+    return row ? { folder: row.config_dir } : { names: rows.map((r) => r.name) };
+  } finally {
+    db.close();
+  }
+}
+function realDeps() {
+  const store = localStore();
+  return {
+    findAccount: async (name) => {
+      const file = path10.join(userDataDir(), "ledung.db");
+      try {
+        return await findInDatabase(name, file);
+      } catch {
+        return { names: [] };
+      }
+    },
+    readToken: async () => {
+      if (!process.stdin.isTTY) return readPipe(process.stdin);
+      process.stderr.write("Paste the token from `claude setup-token` and press Enter (nothing is shown): ");
+      const token = await readHidden(process.stdin);
+      process.stderr.write("\n");
+      return token;
+    },
+    store,
+    check: async (folder) => {
+      let setting = "installed";
+      try {
+        setting = loadConfig(configPath()).claudeExecutable;
+      } catch {
+      }
+      const binary = (await chooseClaude(setting)).program?.path ?? null;
+      return checkSignIn(folderOnlyEnv(process.env, folder), { binary });
+    },
+    print: (line) => console.log(line)
+  };
+}
+function folderOnlyEnv(base, folder) {
+  const env = {};
+  for (const [k, v] of Object.entries(base)) if (v !== void 0 && !LOGIN_ENV.includes(k) && !k.startsWith("LEDUNG_")) env[k] = v;
+  return { ...env, [SIGN_IN_ENV]: folder };
+}
+async function accountCommand(args, deps = realDeps()) {
+  const [what, name, ...rest] = args;
+  if (what !== "token" || !name || rest.length || !ACCOUNT_NAME.test(name)) {
+    deps.print(USAGE);
+    return 2;
+  }
+  const found = await deps.findAccount(name);
+  if (!("folder" in found)) {
+    deps.print(`There is no account named "${name}" in Ledung. ${found.names.length ? `Its accounts: ${found.names.join(", ")}.` : "Add it under Settings \u2192 Claude & usage \u2192 Accounts first."}`);
+    return 1;
+  }
+  const given = await deps.readToken();
+  if (given === null) {
+    deps.print("Stopped. Nothing was changed.");
+    return 1;
+  }
+  const token = cleanToken(given);
+  if (!token) {
+    deps.print("That is not a long-lived token: `claude setup-token` prints one starting with sk-ant-oat. Nothing was changed.");
+    return 1;
+  }
+  let replaced;
+  try {
+    replaced = await deps.store.hasSignIn(found.folder);
+    await deps.store.put(found.folder, signInRecord(token));
+  } catch (e) {
+    deps.print(`The token could not be stored: ${e.message}. Nothing was changed.`);
+    return 1;
+  }
+  deps.print(`The token is in Claude Code's sign-in for "${name}"${replaced ? ", in place of the sign-in that was there" : ""}.`);
+  const after = await deps.check(found.folder);
+  if (after.state === "in" && after.method === "claude.ai" && after.kind === "token") {
+    deps.print("Claude Code sees it: signed in with a long-lived token. It reads what is stored without trying it, so the first session is what proves the token.");
+    deps.print("Press Check again under Settings \u2192 Claude & usage \u2192 Accounts to see it in Ledung.");
+    return 0;
+  }
+  if (after.state === "unknown") deps.print(`Claude Code could not be asked whether it worked: ${after.detail ?? "no answer"}.`);
+  else if (after.state === "out") deps.print("It did NOT work: Claude Code says this account is not signed in.");
+  else deps.print(`It did NOT work: Claude Code answers with something else for this account (${after.method ?? "an unknown sign-in"}${after.kind === "login" ? ", a /login" : ""}).`);
+  return 1;
+}
+
 // src/cli.ts
 var RESTART_CODE = 75;
 var OWN = ["--open-only", "--foreground"];
@@ -821,12 +1502,13 @@ if (passthrough.includes("--version") || passthrough.includes("-v")) {
   process.exit(0);
 }
 if (passthrough[0] === "stop") process.exit(await stopRunning({ configFile: configPath() }));
+if (passthrough[0] === "account") process.exit(await accountCommand(passthrough.slice(1)));
 if (await openIfRunning({ configFile: configPath(), open: !passthrough.includes("--no-open") })) process.exit(0);
 if (process.argv.includes("--open-only")) process.exit(NOT_RUNNING_CODE);
 if (!process.argv.includes("--foreground")) {
-  process.exit(await startInBackground({ args: [fileURLToPath2(import.meta.url), "--foreground", ...passthrough], configFile: configPath() }));
+  process.exit(await startInBackground({ args: [fileURLToPath3(import.meta.url), "--foreground", ...passthrough], configFile: configPath() }));
 }
-var entry = fileURLToPath2(new URL(PACKAGED ? "./main.js" : "./main.ts", import.meta.url));
+var entry = fileURLToPath3(new URL(PACKAGED ? "./main.js" : "./main.ts", import.meta.url));
 for (const signal of ["SIGINT", "SIGTERM", "SIGBREAK"]) process.on(signal, () => {
 });
 var restarted = false;