@anna-ai/cli 0.1.11 → 0.1.14

package/dist/{dev-BPIUX2Nh.js → dev-BfLGxpiT.js}

@@ -31,8 +31,8 @@ async function runDev(opts) {
 	}
 	const matrixNexusRoot = await resolveMatrixNexusRoot(opts.matrixNexusRoot, cwd);
 	const mode = matrixNexusRoot ? "nexus-source" : "uvx";
-	const { PythonBridge, PINNED_RUNTIME_VERSION } = await import("./bridge-BIO7ilgO.js");
-	const { HarnessServer } = await import("./server-Cd5Lo-2v.js");
+	const { PythonBridge, PINNED_RUNTIME_VERSION } = await import("./bridge-C0DWb5eQ.js");
+	const { HarnessServer } = await import("./server-q6nKCeEV.js");
 	const bridge = new PythonBridge({
 		mode,
 		matrixNexusRoot: matrixNexusRoot ?? void 0,
@@ -68,12 +68,14 @@ async function runDev(opts) {
 	const llm = opts.noLlm ? { mode: "off" } : opts.mockLlm ? {
 		mode: "mock",
 		mockFile: opts.mockLlm
-	} : {
-		mode: "real",
+	} : await resolveRealLlm({
+		cwd,
 		account: opts.llmAccount,
-		appId: opts.llmAppId
-	};
-	console.log(`  llm bridge        ${dim(llm.mode === "off" ? "disabled (--no-llm)" : llm.mode === "mock" ? `mock (${opts.mockLlm})` : `real${opts.llmAccount ? ` [${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,
@@ -111,6 +113,49 @@ async function runDev(opts) {
 	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-DDqx6XMQ.js");
+	const { ensureDevAppRegistered } = await import("./dev-app-cache-CZ8lIKiw.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;

package/dist/dev-C81H9c9_.js

@@ -0,0 +1,3 @@
+import { parseExecutaSpec, runDev } from "./dev-BfLGxpiT.js";
+
+export { parseExecutaSpec, runDev };

package/dist/dev-account-DCyjamBa.js

@@ -0,0 +1,44 @@
+import { canonicalHost, getAccount } from "./credentials-BTv2IfUZ.js";
+
+//#region src/executa/dev-account.ts
+/** Embed a JSON-RPC error code on a thrown Error so the runner can forward it. */
+function withCode(err, code) {
+	err.rpcCode = code;
+	return err;
+}
+/**
+* Resolve a saved developer PAT for the given account host (or the
+* "current" one when omitted).
+*
+* @throws JSON-RPC `-32001` when no PAT is on disk or it has expired.
+*/
+function requireAccount(account) {
+	const acc = getAccount(account);
+	if (!acc) throw withCode(new Error("no PAT on disk — run `anna-app login --host <nexus-url>` first (or use a `mock`/`off`/`memory` mode for the affected bridge)"), -32001);
+	if (acc.expires_at && acc.expires_at < Math.floor(Date.now() / 1e3)) throw withCode(new Error("PAT expired — run `anna-app login` again"), -32001);
+	return acc;
+}
+/** Return the canonical `https://host[:port]` form of a saved account. */
+function hostOf(acc) {
+	return canonicalHost(acc.host);
+}
+/**
+* Call `POST /api/v1/anna-apps/dev/session/mint` and parse the response.
+* Thin wrapper used by both sampling and agent bridges.
+*/
+async function mintAppSession(host, body) {
+	const url = `${canonicalHost(host)}/api/v1/anna-apps/dev/session/mint`;
+	const res = await fetch(url, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(body)
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw withCode(new Error(`session.mint failed: HTTP ${res.status} ${text}`), -32e3);
+	}
+	return await res.json();
+}
+
+//#endregion
+export { hostOf, mintAppSession, requireAccount, withCode };

package/dist/dev-app-cache-C3D1Sp_V.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-CZ8lIKiw.js

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

package/dist/{doctor-R1pjmBDG.js → doctor-B3u0edUg.js}

@@ -1,4 +1,4 @@
-import { PINNED_RUNTIME_VERSION } from "./bridge-Cpm3D2Wk.js";
+import { PINNED_RUNTIME_VERSION } from "./bridge-D6YyP9DM.js";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { existsSync, statSync } from "node:fs";
 import { spawnSync } from "node:child_process";

package/dist/executa-dev-BhouP8jh.js

@@ -0,0 +1,212 @@
+import { parseExecutaSpec } from "./dev-BfLGxpiT.js";
+import { isAbsolute, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { bold, cyan, dim, green, red, yellow } from "kleur/colors";
+import * as readline from "node:readline";
+import { createInterface as createInterface$1 } from "node:readline/promises";
+
+//#region src/commands/executa-dev.ts
+/**
+* Mutable hook the REPL installs while it's waiting at a prompt, so
+* out-of-band stderr lines from the executa subprocess don't garble
+* the prompt. When set, the stderr sink clears the current readline
+* line on stdout, prints the message, then asks readline to redraw
+* the prompt + any pending user input.
+*/
+let activeRepl = null;
+async function runExecutaDev(opts) {
+	const cwd = process.cwd();
+	const dir = opts.dir ? isAbsolute(opts.dir) ? opts.dir : resolve(cwd, opts.dir) : cwd;
+	if (!existsSync(dir)) {
+		console.error(red(`✗ dir not found: ${dir}`));
+		return 2;
+	}
+	const specStr = opts.spec ? prependDirIfMissing(opts.spec, dir) : `dir=${dir}`;
+	const parsed = parseExecutaSpec(specStr, cwd);
+	if (parsed instanceof Error) {
+		console.error(red(`✗ ${parsed.message}`));
+		return 2;
+	}
+	if (!parsed.command || parsed.command.length === 0) {
+		console.error(red(`✗ could not derive a launch command for ${dir}`));
+		return 2;
+	}
+	const oneShot = !!(opts.describe || opts.health || opts.invoke);
+	const quiet = oneShot && (opts.json ?? false);
+	const { SamplingBridge } = await import("./sampling-3EfSlDHM.js");
+	const sampling = opts.noSampling ? new SamplingBridge({ mode: "off" }) : opts.mockSampling ? new SamplingBridge({
+		mode: "mock",
+		mockFile: opts.mockSampling
+	}) : opts.appSlug ? new SamplingBridge({
+		mode: "real",
+		account: opts.samplingAccount,
+		appSlug: opts.appSlug
+	}) : new SamplingBridge({ mode: "off" });
+	const { AgentBridge } = await import("./agent-DUmINbo4.js");
+	const agent = opts.noAgent ? new AgentBridge({ mode: "off" }) : opts.mockAgent ? new AgentBridge({
+		mode: "mock",
+		mockFile: opts.mockAgent
+	}) : opts.appSlug ? new AgentBridge({
+		mode: "real",
+		account: opts.agentAccount ?? opts.samplingAccount,
+		appSlug: opts.appSlug
+	}) : new AgentBridge({ mode: "off" });
+	const { StorageBridge } = await import("./storage-CnWTZqq_.js");
+	const storageMode = opts.storage ?? (opts.mockStorage ? "mock" : "memory");
+	const storage = new StorageBridge({
+		mode: storageMode,
+		mockFile: opts.mockStorage,
+		account: opts.storageAccount ?? opts.samplingAccount,
+		appSlug: opts.appSlug,
+		scopes: opts.storageScopes ? opts.storageScopes.split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+		pluginName: parsed.tool_id
+	});
+	const { ExecutaRunner } = await import("./runner-Bral1LFW.js");
+	const runner = new ExecutaRunner({
+		command: parsed.command,
+		cwd: parsed.project_dir,
+		sampling,
+		agent,
+		storage,
+		onStderr: (line) => {
+			const text = quiet ? `${line}\n` : dim(`[executa] ${line}\n`);
+			writeStderrCooperative(text);
+		}
+	});
+	if (!quiet) {
+		console.log(bold(cyan("anna-app executa dev")));
+		console.log(`  tool_id   ${dim(parsed.tool_id)}`);
+		console.log(`  dir       ${dim(parsed.project_dir)}`);
+		console.log(`  command   ${dim(parsed.command.join(" "))}`);
+		console.log(`  sampling  ${dim(opts.noSampling ? "disabled (--no-sampling)" : opts.mockSampling ? `mock (${opts.mockSampling})` : opts.appSlug ? `real → app_slug=${opts.appSlug}` : "disabled (no fixture, no --app-slug)")}`);
+		console.log(`  agent     ${dim(opts.noAgent ? "disabled (--no-agent)" : opts.mockAgent ? `mock (${opts.mockAgent})` : opts.appSlug ? `real → app_slug=${opts.appSlug}` : "disabled (no fixture, no --app-slug)")}`);
+		console.log(`  storage   ${dim(storageMode === "mock" ? `mock (${opts.mockStorage ?? "<no-fixture>"})` : storageMode === "real" ? `real → app_slug=${opts.appSlug ?? "<unset>"}` : storageMode)}`);
+	}
+	let init;
+	try {
+		init = await runner.start();
+	} catch (e) {
+		console.error(red(`✗ executa failed to start: ${e.message}`));
+		return 2;
+	}
+	if (!quiet) console.log(`  ${green("✓")} negotiated protocol ${bold(init.protocolVersion)}`);
+	let exitCode = 0;
+	try {
+		if (oneShot) exitCode = await runOneShot(runner, opts, quiet);
+		else exitCode = await runRepl(runner);
+	} finally {
+		await runner.stop();
+	}
+	return exitCode;
+}
+function prependDirIfMissing(spec, dir) {
+	if (/\bdir\s*=/.test(spec)) return spec;
+	return `dir=${dir},${spec}`;
+}
+async function runOneShot(runner, opts, quiet) {
+	const print = (v) => {
+		process.stdout.write(`${JSON.stringify(v, null, quiet ? 0 : 2)}\n`);
+	};
+	try {
+		if (opts.describe) {
+			print(await runner.describe());
+			return 0;
+		}
+		if (opts.health) {
+			print(await runner.health());
+			return 0;
+		}
+		if (opts.invoke) {
+			let args = {};
+			if (opts.args) try {
+				const parsed = JSON.parse(opts.args);
+				if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("--args must be a JSON object");
+				args = parsed;
+			} catch (e) {
+				console.error(red(`✗ --args: ${e.message}`));
+				return 2;
+			}
+			print(await runner.invoke(opts.invoke, args));
+			return 0;
+		}
+		return 0;
+	} catch (e) {
+		console.error(red(`✗ ${e.message}`));
+		return 1;
+	}
+}
+async function runRepl(runner) {
+	const rl = createInterface$1({
+		input: process.stdin,
+		output: process.stdout
+	});
+	console.log(yellow("  REPL ready. Commands: describe | health | invoke <tool> <json?> | quit"));
+	activeRepl = { rl };
+	for (;;) {
+		let line;
+		try {
+			line = (await rl.question(cyan("executa> "))).trim();
+		} catch {
+			break;
+		}
+		if (!line) continue;
+		if (line === "quit" || line === "exit" || line === ".q") break;
+		try {
+			if (line === "describe") {
+				const out = await runner.describe();
+				process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
+			} else if (line === "health") {
+				const out = await runner.health();
+				process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
+			} else if (line.startsWith("invoke")) {
+				const rest = line.slice(6).trim();
+				const sp = rest.indexOf(" ");
+				const tool = sp === -1 ? rest : rest.slice(0, sp);
+				const argsStr = sp === -1 ? "{}" : rest.slice(sp + 1).trim() || "{}";
+				if (!tool) {
+					console.error(red("usage: invoke <tool> <json-args?>"));
+					continue;
+				}
+				let args;
+				try {
+					const parsed = JSON.parse(argsStr);
+					if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("args must be a JSON object");
+					args = parsed;
+				} catch (e) {
+					console.error(red(`bad args: ${e.message}`));
+					continue;
+				}
+				const out = await runner.invoke(tool, args);
+				process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
+			} else console.error(yellow(`unknown command: ${line}`));
+		} catch (e) {
+			console.error(red(`✗ ${e.message}`));
+		}
+	}
+	activeRepl = null;
+	rl.close();
+	return 0;
+}
+/**
+* Write to stderr without trampling the REPL prompt. When the REPL is
+* idle (no `activeRepl`) or stdout is not a TTY, this is a plain
+* `process.stderr.write`. When the REPL is at a prompt, we clear the
+* prompt line on stdout, emit the stderr text, then redraw the prompt
+* with any user input the reader had already buffered.
+*/
+function writeStderrCooperative(text) {
+	const repl = activeRepl;
+	if (!repl || !process.stdout.isTTY) {
+		process.stderr.write(text);
+		return;
+	}
+	readline.cursorTo(process.stdout, 0);
+	readline.clearLine(process.stdout, 0);
+	process.stderr.write(text);
+	const rl = repl.rl;
+	if (typeof rl._refreshLine === "function") rl._refreshLine();
+	else process.stdout.write(cyan("executa> "));
+}
+
+//#endregion
+export { runExecutaDev };

package/dist/executa-init-COEmKDOE.js

@@ -0,0 +1,68 @@
+import { printMascot } from "./mascot-wlYTJqMs.js";
+import { dirname, join, resolve } from "node:path";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import kleur from "kleur";
+
+//#region src/commands/executa-init.ts
+const here = dirname(fileURLToPath(import.meta.url));
+function templateRoot(template) {
+	for (const cand of [resolve(here, "..", "..", "templates", "executa", template), resolve(here, "..", "templates", "executa", template)]) if (existsSync(cand)) return cand;
+	throw new Error(`executa template not found: ${template}`);
+}
+function substitute(content, slug, toolId) {
+	const slugPy = slug.replace(/-/g, "_");
+	return content.replace(/__SLUG_PY__/g, slugPy).replace(/__SLUG__/g, slug).replace(/__TOOL_ID__/g, toolId);
+}
+function copyDirWithSubst(src, dst, slug, toolId) {
+	mkdirSync(dst, { recursive: true });
+	for (const entry of readdirSync(src, { withFileTypes: true })) {
+		const s = join(src, entry.name);
+		const d = join(dst, substitute(entry.name, slug, toolId));
+		if (entry.isDirectory()) copyDirWithSubst(s, d, slug, toolId);
+		else if (entry.isFile()) {
+			const stat = statSync(s);
+			if (stat.size < 256 * 1024) {
+				const buf = readFileSync(s);
+				if (!buf.includes(0)) {
+					writeFileSync(d, substitute(buf.toString("utf-8"), slug, toolId), "utf-8");
+					continue;
+				}
+			}
+			cpSync(s, d);
+		}
+	}
+}
+function runExecutaInit(opts) {
+	const target = resolve(process.cwd(), opts.targetDir);
+	if (existsSync(target) && !opts.force) {
+		if (readdirSync(target).filter((n) => !n.startsWith(".")).length > 0) {
+			console.error(kleur.red(`✗ target dir not empty: ${target} (use --force to override)`));
+			return 1;
+		}
+	}
+	if (!/^[a-z][a-z0-9-]{1,40}$/.test(opts.slug)) {
+		console.error(kleur.red(`✗ invalid slug "${opts.slug}": must match /^[a-z][a-z0-9-]{1,40}$/`));
+		return 1;
+	}
+	const toolId = opts.toolId ?? `tool-dev-${opts.slug}`;
+	if (!/^[a-z][a-z0-9-]{1,80}$/.test(toolId)) {
+		console.error(kleur.red(`✗ invalid tool_id "${toolId}": must match /^[a-z][a-z0-9-]{1,80}$/`));
+		return 1;
+	}
+	let tplRoot;
+	try {
+		tplRoot = templateRoot(opts.template);
+	} catch (e) {
+		console.error(kleur.red(`✗ ${e.message}`));
+		return 1;
+	}
+	copyDirWithSubst(tplRoot, target, opts.slug, toolId);
+	printMascot(`scaffolded an executa — happy hacking!`);
+	console.log(kleur.green(`✓ scaffolded "${opts.slug}" (${opts.template}) at ${target}`));
+	console.log(kleur.gray(`  next: cd ${opts.targetDir} && anna-app executa dev --describe`));
+	return 0;
+}
+
+//#endregion
+export { runExecutaInit };

package/dist/executa-register-66WKIwQQ.js

@@ -0,0 +1,47 @@
+import { getAccount } from "./credentials-BTv2IfUZ.js";
+import { bold, cyan, dim, green, red } from "kleur/colors";
+
+//#region src/commands/executa-register.ts
+async function runExecutaRegister(opts) {
+	const acc = getAccount(opts.account);
+	if (!acc) {
+		console.error(red("✗ no PAT on disk — run `anna-app login --host <nexus-url>` first."));
+		return 2;
+	}
+	const body = {
+		pat: acc.pat,
+		tool_id: opts.toolId,
+		slug: opts.slug,
+		name: opts.name
+	};
+	const url = `${acc.host.replace(/\/$/, "")}/api/v1/anna-apps/dev/executas/register`;
+	let res;
+	try {
+		res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	} catch (e) {
+		console.error(red(`✗ network error: ${e.message}`));
+		return 2;
+	}
+	if (res.status === 404) {
+		console.error(red("✗ your nexus does not expose POST /api/v1/anna-apps/dev/executas/register — upgrade matrix-nexus to a version that ships this endpoint."));
+		return 2;
+	}
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		console.error(red(`✗ HTTP ${res.status}: ${text}`));
+		return 1;
+	}
+	const out = await res.json();
+	console.log(`${green(out.created ? "✓ registered" : "✓ exists")} ${bold(out.slug)} ${dim(`(app_id=${out.app_id}, kind=${out.kind})`)}`);
+	console.log(`  tool_id   ${dim(out.tool_id)}`);
+	console.log(`  name      ${dim(out.name)}`);
+	console.log(`  host      ${cyan(acc.host)}`);
+	return 0;
+}
+
+//#endregion
+export { runExecutaRegister };

package/dist/{login-D8cmvBb6.js → login-CsIVbrmf.js}

@@ -1,4 +1,4 @@
-import { canonicalHost, saveAccount } from "./credentials-ggdaz_-7.js";
+import { canonicalHost, saveAccount } from "./credentials-BTv2IfUZ.js";
 
 //#region src/commands/login.ts
 const POLL_TIMEOUT_MS = 12 * 60 * 1e3;

package/dist/{logout-P6L9VU4W.js → logout-gfmKQxMj.js}

@@ -1,4 +1,4 @@
-import { canonicalHost, getAccount, readCredentials, removeAccount } from "./credentials-ggdaz_-7.js";
+import { canonicalHost, getAccount, readCredentials, removeAccount } from "./credentials-BTv2IfUZ.js";
 
 //#region src/commands/logout.ts
 async function runLogout(opts) {