@anna-ai/cli 0.1.9 → 0.1.12

package/dist/dev-DoY58pBM.js

@@ -0,0 +1,411 @@
+import { dirname, isAbsolute, resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { bold, cyan, dim, green, red, yellow } from "kleur/colors";
+import { parse } from "smol-toml";
+
+//#region src/commands/dev.ts
+async function runDev(opts) {
+	const cwd = resolve(opts.cwd);
+	const manifestPath = isAbsolute(opts.manifestPath) ? opts.manifestPath : resolve(cwd, opts.manifestPath);
+	if (!existsSync(manifestPath)) {
+		console.error(red(`✗ manifest not found: ${manifestPath}`));
+		return 2;
+	}
+	let manifest;
+	try {
+		manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+	} catch (e) {
+		console.error(red(`✗ manifest is not valid json: ${e.message}`));
+		return 2;
+	}
+	const slug = opts.slug ?? deriveSlug(manifest, manifestPath);
+	const bundleDir = opts.bundleDir ? resolve(cwd, opts.bundleDir) : resolve(dirname(manifestPath), "bundle");
+	const bundleEntry = manifest.ui?.bundle?.entry ?? "index.html";
+	if (!existsSync(bundleDir)) {
+		console.error(red(`✗ bundle dir not found: ${bundleDir}`));
+		return 2;
+	}
+	if (!existsSync(resolve(bundleDir, bundleEntry))) {
+		console.error(red(`✗ bundle entry "${bundleEntry}" not found under ${bundleDir}`));
+		return 2;
+	}
+	const matrixNexusRoot = await resolveMatrixNexusRoot(opts.matrixNexusRoot, cwd);
+	const mode = matrixNexusRoot ? "nexus-source" : "uvx";
+	const { PythonBridge, PINNED_RUNTIME_VERSION } = await import("./bridge-BEHyfpPI.js");
+	const { HarnessServer } = await import("./server-NXmiWJjX.js");
+	const bridge = new PythonBridge({
+		mode,
+		matrixNexusRoot: matrixNexusRoot ?? void 0,
+		onStderr: (line) => process.stderr.write(dim(`[bridge] ${line}\n`))
+	});
+	console.log(bold(cyan("anna-app dev")));
+	console.log(`  manifest          ${dim(manifestPath)}`);
+	console.log(`  bundle            ${dim(`${bundleDir}/${bundleEntry}`)}`);
+	if (mode === "nexus-source") {
+		console.log(`  matrix-nexus root ${dim(matrixNexusRoot)}`);
+		console.log(`  runtime           ${dim("nexus-source (uv run)")}`);
+	} else console.log(`  runtime           ${dim(`uvx anna-app-runtime-local@${PINNED_RUNTIME_VERSION}`)}`);
+	console.log(`  spawning python bridge…`);
+	try {
+		await bridge.start();
+	} catch (e) {
+		console.error(red(`✗ bridge failed to start: ${e.message}`));
+		if (mode === "uvx") console.error(dim("  (try: install uv from https://docs.astral.sh/uv/, or pass --matrix-nexus-root to use a checkout)"));
+		else console.error(dim("  (try: cd matrix-nexus && uv sync; ensure `uv` is on PATH; or unset --matrix-nexus-root to use uvx)"));
+		return 2;
+	}
+	try {
+		const pong = await bridge.call("ping");
+		if (!pong.pong) throw new Error("bridge ping returned non-pong");
+	} catch (e) {
+		console.error(red(`✗ bridge ping failed: ${e.message}`));
+		await bridge.stop();
+		return 2;
+	}
+	console.log(green("  ✓ bridge ready"));
+	const executas = opts.executas ?? autoDiscoverExecutas(dirname(manifestPath));
+	if (executas.length > 0) console.log(`  executas          ${dim(executas.map((e) => e.tool_id).join(", "))}`);
+	const llm = opts.noLlm ? { mode: "off" } : opts.mockLlm ? {
+		mode: "mock",
+		mockFile: opts.mockLlm
+	} : await resolveRealLlm({
+		cwd,
+		account: opts.llmAccount,
+		appSlug: opts.llmAppSlug ?? slug,
+		manifest
+	});
+	if (llm === null) return 2;
+	console.log(`  llm bridge        ${dim(llm.mode === "off" ? "disabled (--no-llm)" : llm.mode === "mock" ? `mock (${opts.mockLlm})` : `real${opts.llmAccount ? ` [${opts.llmAccount}]` : ""} → app_slug=${llm.appSlug}`)}`);
+	const server = new HarnessServer({
+		slug,
+		manifest,
+		bundleDir,
+		bundleEntry,
+		view: opts.view,
+		matrixNexusRoot,
+		userId: opts.userId,
+		port: opts.port,
+		executas,
+		watch: !opts.noWatch,
+		llm
+	}, bridge);
+	try {
+		await server.listen();
+	} catch (e) {
+		const msg = e.code === "EADDRINUSE" ? `port ${opts.port} already in use` : e.message;
+		console.error(red(`✗ harness failed to listen: ${msg}`));
+		await bridge.stop();
+		return 2;
+	}
+	console.log(`  ${green("✓")} dashboard ${cyan(`http://localhost:${opts.port}/`)}`);
+	console.log(yellow("  press Ctrl+C to stop"));
+	const shutdown = async () => {
+		console.log(dim("\n  shutting down…"));
+		try {
+			await server.close();
+			await bridge.stop();
+		} finally {
+			process.exit(0);
+		}
+	};
+	process.once("SIGINT", shutdown);
+	process.once("SIGTERM", shutdown);
+	await new Promise(() => {});
+	return 0;
+}
+/**
+* Resolve the `real` LlmBridgeOptions: load the dev PAT, register
+* (or re-use) an `AnnaApp(is_dev=True)` on nexus, cache the result.
+*
+* Returns `null` (after printing) when registration fails so the caller
+* can exit cleanly. Otherwise returns a bridge config carrying the
+* registered `appSlug`.
+*/
+async function resolveRealLlm(args) {
+	const { getAccount } = await import("./credentials-CIOYq2Lm.js");
+	const { ensureDevAppRegistered } = await import("./dev-app-cache-cXvO2XwQ.js");
+	const acc = getAccount(args.account);
+	if (!acc) {
+		console.error(red("✗ no developer PAT on disk — run `anna-app login --host <nexus-url>` first.\n  (or use `--no-llm` / `--mock-llm <fixture>` to develop offline.)"));
+		return null;
+	}
+	if (acc.expires_at && acc.expires_at < Math.floor(Date.now() / 1e3)) {
+		console.error(red("✗ PAT expired — run `anna-app login` again."));
+		return null;
+	}
+	const manifest = args.manifest;
+	try {
+		const entry = await ensureDevAppRegistered({
+			cwd: args.cwd,
+			host: acc.host,
+			pat: acc.pat,
+			input: {
+				slug: args.appSlug,
+				name: manifest.name,
+				category: manifest.category,
+				tagline: manifest.tagline
+			}
+		});
+		return {
+			mode: "real",
+			account: args.account,
+			appSlug: entry.slug
+		};
+	} catch (e) {
+		console.error(red(`✗ failed to register dev app on nexus: ${e.message}`));
+		return null;
+	}
+}
+function deriveSlug(manifest, path) {
+	const fromMan = manifest.slug ?? manifest.name;
+	if (typeof fromMan === "string" && fromMan) return fromMan;
+	return dirname(path).split(/[\\/]/).pop() || "anna-app-dev";
+}
+function autoDiscoverExecutas(manifestDir) {
+	const root = resolve(manifestDir, "executas");
+	if (!existsSync(root)) return [];
+	const found = [];
+	const seen = new Map();
+	for (const name of readdirSync(root)) {
+		if (name.startsWith(".")) continue;
+		const dir = resolve(root, name);
+		let st;
+		try {
+			st = statSync(dir);
+		} catch {
+			continue;
+		}
+		if (!st.isDirectory()) continue;
+		const result = discoverOne(dir, name);
+		if (result === "skip" || result === "disabled") continue;
+		if (result instanceof Error) {
+			console.warn(yellow(`⚠ skipping executa ${name}: ${result.message}`));
+			continue;
+		}
+		const prior = seen.get(result.tool_id);
+		if (prior) {
+			console.warn(yellow(`⚠ skipping executa ${name}: tool_id "${result.tool_id}" already provided by ${prior} (toggle "enabled": false in executa.json to silence)`));
+			continue;
+		}
+		seen.set(result.tool_id, name);
+		found.push(result);
+	}
+	return found;
+}
+function discoverOne(dir, name, opts = { respectEnabled: true }) {
+	const cfgPath = resolve(dir, "executa.json");
+	if (existsSync(cfgPath)) {
+		let cfg;
+		try {
+			cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
+		} catch (err) {
+			return new Error(`failed to parse executa.json (${err.message})`);
+		}
+		if (cfg.enabled === false && opts.respectEnabled !== false) return "disabled";
+		if (!cfg.tool_id) return new Error("executa.json missing required `tool_id`");
+		if (!cfg.type) return new Error("executa.json missing required `type`");
+		if (cfg.command && cfg.command.length > 0) return {
+			tool_id: cfg.tool_id,
+			project_dir: dir,
+			command: cfg.command
+		};
+		const cmd = defaultCommand(cfg.type, dir, cfg.tool_id);
+		if (cmd instanceof Error) return cmd;
+		return {
+			tool_id: cfg.tool_id,
+			project_dir: dir,
+			command: cmd
+		};
+	}
+	if (existsSync(resolve(dir, "pyproject.toml"))) return discoverPython(dir, name);
+	if (existsSync(resolve(dir, "package.json"))) return discoverNode(dir, name);
+	if (existsSync(resolve(dir, "go.mod"))) return new Error("Go executa requires an explicit executa.json with `tool_id` and `type: \"go\"` (go.mod has no script-name field)");
+	const binCandidate = resolve(dir, "bin", name);
+	if (existsSync(binCandidate)) return {
+		tool_id: name,
+		project_dir: dir,
+		command: [binCandidate]
+	};
+	return "skip";
+}
+function defaultCommand(type, dir, toolId) {
+	switch (type) {
+		case "python": return [
+			"uv",
+			"run",
+			"--project",
+			dir,
+			toolId
+		];
+		case "node": {
+			const pkg = readPackageJson(dir);
+			if (!pkg) return new Error("type=node but no package.json found");
+			const entry = nodeEntry(pkg, toolId, dir);
+			if (entry instanceof Error) return entry;
+			return ["node", entry];
+		}
+		case "go": return [
+			"go",
+			"run",
+			"."
+		];
+		case "binary": {
+			const guess = resolve(dir, "bin", toolId);
+			if (!existsSync(guess)) return new Error(`type=binary but no executable at ${guess}; specify "command" in executa.json explicitly`);
+			return [guess];
+		}
+		default: return new Error(`unknown type "${type}" — expected python | node | go | binary`);
+	}
+}
+function discoverPython(dir, name) {
+	const py = resolve(dir, "pyproject.toml");
+	let body;
+	try {
+		body = readFileSync(py, "utf-8");
+	} catch {
+		return new Error("could not read pyproject.toml");
+	}
+	let parsed;
+	try {
+		parsed = parse(body);
+	} catch (err) {
+		return new Error(`failed to parse pyproject.toml (${err.message})`);
+	}
+	const scripts = parsed?.project?.scripts;
+	if (!scripts || typeof scripts !== "object") return new Error("no [project.scripts] entry in pyproject.toml");
+	const keys = Object.keys(scripts);
+	if (keys.length === 0) return new Error("[project.scripts] is empty");
+	const toolId = keys[0];
+	return {
+		tool_id: toolId,
+		project_dir: dir,
+		command: [
+			"uv",
+			"run",
+			"--project",
+			dir,
+			toolId
+		]
+	};
+}
+function discoverNode(dir, name) {
+	const pkg = readPackageJson(dir);
+	if (!pkg) return new Error("could not read package.json");
+	const toolId = (typeof pkg.executa === "object" && pkg.executa ? pkg.executa.tool_id : void 0) ?? firstBinKey(pkg) ?? (typeof pkg.name === "string" ? pkg.name : void 0);
+	if (!toolId) return new Error("package.json missing tool_id — set `executa.tool_id`, `bin`, or `name`");
+	const entry = nodeEntry(pkg, toolId, dir);
+	if (entry instanceof Error) return entry;
+	return {
+		tool_id: toolId,
+		project_dir: dir,
+		command: ["node", entry]
+	};
+}
+function readPackageJson(dir) {
+	const p = resolve(dir, "package.json");
+	if (!existsSync(p)) return null;
+	try {
+		return JSON.parse(readFileSync(p, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function firstBinKey(pkg) {
+	if (typeof pkg.bin === "string") return typeof pkg.name === "string" ? pkg.name : void 0;
+	if (pkg.bin && typeof pkg.bin === "object") {
+		const keys = Object.keys(pkg.bin);
+		return keys[0];
+	}
+	return void 0;
+}
+function nodeEntry(pkg, toolId, dir) {
+	let rel;
+	if (typeof pkg.bin === "string") rel = pkg.bin;
+	else if (pkg.bin && typeof pkg.bin === "object") {
+		const obj = pkg.bin;
+		const v = obj[toolId];
+		if (typeof v === "string") rel = v;
+		else {
+			const first = Object.values(obj).find((x) => typeof x === "string");
+			if (typeof first === "string") rel = first;
+		}
+	}
+	if (!rel && typeof pkg.main === "string") rel = pkg.main;
+	if (!rel && typeof pkg.module === "string") rel = pkg.module;
+	if (!rel) return new Error("package.json has no usable entry — set `bin`, `main`, or override `command` in executa.json");
+	const abs = isAbsolute(rel) ? rel : resolve(dir, rel);
+	if (!existsSync(abs)) return new Error(`node entry not found: ${abs}`);
+	return abs;
+}
+/**
+* Parse `--executa <spec>` flag values from CLI. Spec syntax (comma-separated
+* key=value pairs, all keys lowercase):
+*
+*   --executa dir=./executas/foo,type=node
+*   --executa dir=/abs/path,tool_id=tool-x,command="node plugin.js"
+*
+* Required: `dir`. Optional: `tool_id`, `type`, `command` (space-split unless
+* already an array via JSON), `cwd`. When `tool_id`/`type`/`command` are
+* omitted, falls back to the same rules as `executa.json` discovery.
+*/
+function parseExecutaSpec(spec, cwd) {
+	const parts = spec.split(",").map((s) => s.trim()).filter(Boolean);
+	const kv = {};
+	for (const p of parts) {
+		const eq = p.indexOf("=");
+		if (eq === -1) return new Error(`bad --executa spec part: "${p}"`);
+		kv[p.slice(0, eq).trim().toLowerCase()] = p.slice(eq + 1).trim();
+	}
+	const dirRaw = kv.dir;
+	if (!dirRaw) return new Error("--executa spec missing `dir=`");
+	const dir = isAbsolute(dirRaw) ? dirRaw : resolve(cwd, dirRaw);
+	if (!existsSync(dir)) return new Error(`--executa dir not found: ${dir}`);
+	if (!kv.tool_id && !kv.type && !kv.command) {
+		const result = discoverOne(dir, dir.split(/[\\/]/).pop() ?? dir, { respectEnabled: false });
+		if (result === "skip") return new Error(`nothing discoverable at ${dir} (no executa.json / pyproject.toml / package.json / bin/)`);
+		if (result === "disabled") return new Error(`executa.json at ${dir} has "enabled": false`);
+		if (result instanceof Error) return result;
+		return result;
+	}
+	const tool_id = kv.tool_id;
+	if (!tool_id) return new Error("--executa spec missing `tool_id=`");
+	let command;
+	if (kv.command) if (kv.command.startsWith("[")) try {
+		const arr = JSON.parse(kv.command);
+		if (!Array.isArray(arr) || !arr.every((x) => typeof x === "string")) return new Error("--executa command JSON must be a string array");
+		command = arr;
+	} catch (err) {
+		return new Error(`--executa command JSON invalid: ${err.message}`);
+	}
+	else command = kv.command.split(/\s+/);
+	else if (kv.type) {
+		const c = defaultCommand(kv.type, dir, tool_id);
+		if (c instanceof Error) return c;
+		command = c;
+	}
+	return {
+		tool_id,
+		project_dir: dir,
+		command
+	};
+}
+async function resolveMatrixNexusRoot(explicit, cwd) {
+	const candidates = [explicit, process.env.ANNA_NEXUS_ROOT];
+	let dir = cwd;
+	while (true) {
+		candidates.push(dir);
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	candidates.push(resolve(cwd, "..", "matrix-nexus"));
+	for (const c of candidates) {
+		if (!c) continue;
+		const abs = isAbsolute(c) ? c : resolve(cwd, c);
+		if (existsSync(resolve(abs, "packages/anna-app-runtime-local/pyproject.toml"))) return abs;
+	}
+	return null;
+}
+
+//#endregion
+export { parseExecutaSpec, runDev };

package/dist/dev-app-cache-BMfOlTHd.js

@@ -0,0 +1,93 @@
+import { canonicalHost } from "./credentials-BTv2IfUZ.js";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+
+//#region src/dev-app-cache.ts
+const CACHE_DIR = ".anna";
+const CACHE_FILE = "dev-app.json";
+function cachePath(cwd) {
+	return resolve(cwd, CACHE_DIR, CACHE_FILE);
+}
+function readDevAppCache(cwd) {
+	const p = cachePath(cwd);
+	if (!existsSync(p)) return null;
+	try {
+		const raw = JSON.parse(readFileSync(p, "utf-8"));
+		if (typeof raw.host === "string" && typeof raw.slug === "string" && typeof raw.app_id === "number") return {
+			host: raw.host,
+			slug: raw.slug,
+			app_id: raw.app_id,
+			name: raw.name ?? raw.slug,
+			registered_at: raw.registered_at ?? ""
+		};
+	} catch {}
+	return null;
+}
+function writeDevAppCache(cwd, entry) {
+	const p = cachePath(cwd);
+	mkdirSync(dirname(p), { recursive: true });
+	writeFileSync(p, JSON.stringify(entry, null, 2) + "\n", "utf-8");
+}
+/** Call POST /api/v1/anna-apps/dev/apps/register. Idempotent server-side. */
+async function registerDevApp(args) {
+	const url = `${canonicalHost(args.host)}/api/v1/anna-apps/dev/apps/register`;
+	const res = await fetch(url, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			pat: args.pat,
+			slug: args.input.slug,
+			name: args.input.name,
+			category: args.input.category,
+			tagline: args.input.tagline
+		})
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new Error(`/dev/apps/register failed: HTTP ${res.status} ${text}`);
+	}
+	return await res.json();
+}
+/** Call GET /api/v1/anna-apps/dev/apps. */
+async function listDevApps(args) {
+	const url = new URL(`${canonicalHost(args.host)}/api/v1/anna-apps/dev/apps`);
+	url.searchParams.set("pat", args.pat);
+	const res = await fetch(url, { method: "GET" });
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new Error(`/dev/apps failed: HTTP ${res.status} ${text}`);
+	}
+	const body = await res.json();
+	return body.apps;
+}
+/**
+* Convenience helper for `anna-app dev`: returns a valid cached entry if
+* it still matches the manifest slug, otherwise hits the server to
+* (re-)register. Throws if no PAT is available on disk.
+*/
+async function ensureDevAppRegistered(args) {
+	const canonical = canonicalHost(args.host);
+	const cached = readDevAppCache(args.cwd);
+	if (cached && cached.host === canonical && cached.slug === args.input.slug) return cached;
+	const r = await registerDevApp({
+		host: args.host,
+		pat: args.pat,
+		input: args.input
+	});
+	const entry = {
+		host: canonical,
+		slug: r.slug,
+		app_id: r.app_id,
+		name: r.name,
+		registered_at: new Date().toISOString()
+	};
+	writeDevAppCache(args.cwd, entry);
+	return entry;
+}
+const _internal = {
+	cachePath,
+	CACHE_DIR: join(CACHE_DIR, CACHE_FILE)
+};
+
+//#endregion
+export { ensureDevAppRegistered, listDevApps, readDevAppCache, registerDevApp, writeDevAppCache };

package/dist/dev-app-cache-cXvO2XwQ.js

@@ -0,0 +1,4 @@
+import "./credentials-BTv2IfUZ.js";
+import { ensureDevAppRegistered, listDevApps, readDevAppCache, registerDevApp, writeDevAppCache } from "./dev-app-cache-BMfOlTHd.js";
+
+export { ensureDevAppRegistered };

package/dist/{doctor-BmR0POfL.js → doctor-DP2UB10l.js}

@@ -1,8 +1,8 @@
-import { PINNED_RUNTIME_VERSION } from "./bridge-CBcQUQGU.js";
+import { PINNED_RUNTIME_VERSION } from "./bridge-BQUo6ehX.js";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { existsSync, statSync } from "node:fs";
-import { bold, dim, green, red, yellow } from "kleur/colors";
 import { spawnSync } from "node:child_process";
+import { bold, dim, green, red, yellow } from "kleur/colors";
 import { homedir } from "node:os";
 
 //#region src/commands/doctor.ts

package/dist/login-dl1Zfny8.js

@@ -0,0 +1,102 @@
+import { canonicalHost, saveAccount } from "./credentials-BTv2IfUZ.js";
+
+//#region src/commands/login.ts
+const POLL_TIMEOUT_MS = 12 * 60 * 1e3;
+function envBool(v) {
+	return !!v && /^(1|true|yes|on)$/i.test(v);
+}
+async function tryOpenBrowser(url) {
+	if (envBool(process.env.ANNA_LOGIN_NO_OPEN)) return;
+	const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+	try {
+		const { spawn } = await import("node:child_process");
+		spawn(opener, [url], {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+	} catch {}
+}
+async function runLogin(opts) {
+	const host = canonicalHost(opts.host);
+	process.stdout.write(`▸ logging in to ${host}\n`);
+	let startResp;
+	try {
+		const res = await fetch(`${host}/api/v1/anna-apps/dev/login/start`, {
+			method: "POST",
+			headers: { "content-type": "application/json" }
+		});
+		if (!res.ok) {
+			console.error(`✗ /dev/login/start failed: HTTP ${res.status}`);
+			return 1;
+		}
+		startResp = await res.json();
+	} catch (e) {
+		console.error(`✗ cannot reach nexus: ${e.message}`);
+		return 1;
+	}
+	const verifyUrl = `${host}${startResp.verification_uri_complete}`;
+	process.stdout.write(`\n  user_code: \x1b[1m${startResp.user_code}\x1b[0m\n`);
+	process.stdout.write(`  open:      ${verifyUrl}\n`);
+	process.stdout.write(`  (waiting up to ${Math.round(startResp.expires_in / 60)} min)\n\n`);
+	if (!opts.noBrowser) await tryOpenBrowser(verifyUrl);
+	const interval = Math.max(2, Math.min(15, startResp.interval || 5));
+	const deadline = Date.now() + Math.min(POLL_TIMEOUT_MS, startResp.expires_in * 1e3);
+	const spinner = [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	];
+	let frame = 0;
+	while (Date.now() < deadline) {
+		process.stdout.write(`\r  ${spinner[frame++ % spinner.length]} polling...`);
+		await new Promise((r) => setTimeout(r, interval * 1e3));
+		let resp;
+		try {
+			resp = await fetch(`${host}/api/v1/anna-apps/dev/login/poll`, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({ device_code: startResp.device_code })
+			});
+		} catch (e) {
+			process.stdout.write("\n");
+			console.error(`✗ poll failed: ${e.message}`);
+			return 1;
+		}
+		if (resp.status === 202) continue;
+		if (resp.status === 410) {
+			process.stdout.write("\n✗ device code expired\n");
+			return 1;
+		}
+		if (resp.status === 200) {
+			process.stdout.write("\n");
+			const ok = await resp.json();
+			const now = Math.floor(Date.now() / 1e3);
+			saveAccount({
+				host,
+				user_id: null,
+				pat: ok.pat,
+				issued_at: now,
+				expires_at: now + (ok.expires_in || 0),
+				scopes: ok.scopes
+			});
+			console.log(`✓ logged in. PAT saved to ~/.config/anna/credentials.json`);
+			console.log(`  expires in ~${Math.round((ok.expires_in || 0) / 86400)}d`);
+			return 0;
+		}
+		process.stdout.write("\n");
+		console.error(`✗ unexpected status: HTTP ${resp.status}`);
+		return 1;
+	}
+	process.stdout.write("\n✗ timed out waiting for approval\n");
+	return 1;
+}
+
+//#endregion
+export { runLogin };

package/dist/logout-DablvlFs.js

@@ -0,0 +1,23 @@
+import { canonicalHost, getAccount, readCredentials, removeAccount } from "./credentials-BTv2IfUZ.js";
+
+//#region src/commands/logout.ts
+async function runLogout(opts) {
+	if (opts.all) {
+		const data = readCredentials();
+		const n = Object.keys(data.accounts).length;
+		for (const k of Object.keys(data.accounts)) removeAccount(k);
+		console.log(`✓ removed ${n} account(s)`);
+		return 0;
+	}
+	const acc = getAccount(opts.host);
+	if (!acc) {
+		console.error(opts.host ? `✗ no account for ${canonicalHost(opts.host)}` : "✗ no current account");
+		return 1;
+	}
+	removeAccount(acc.host);
+	console.log(`✓ removed account ${acc.host}`);
+	return 0;
+}
+
+//#endregion
+export { runLogout };