@anna-ai/cli 0.1.12 → 0.1.16

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

@@ -0,0 +1,175 @@
+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)
+};
+const EXECUTA_CACHE_FILE = "dev-executa.json";
+/**
+* Bump this whenever the server-side dev-executa grant shape changes in
+* a way that requires a re-register to pick up. Cached entries written
+* with a lower `cache_version` are treated as stale and re-POSTed.
+*
+*   1 — initial (llm_grant only)
+*   2 — adds image_grant + upload_grant; fixes `allowedPurposes` to
+*       protocol whitelist {image_input,image_reference,user_artifact}
+*/
+const EXECUTA_CACHE_VERSION = 2;
+function executaCachePath(cwd) {
+	return resolve(cwd, CACHE_DIR, EXECUTA_CACHE_FILE);
+}
+function readDevExecutaCache(cwd) {
+	const p = executaCachePath(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" && typeof raw.tool_id === "string") return {
+			host: raw.host,
+			slug: raw.slug,
+			app_id: raw.app_id,
+			tool_id: raw.tool_id,
+			name: raw.name ?? raw.tool_id,
+			registered_at: raw.registered_at ?? "",
+			cache_version: typeof raw.cache_version === "number" ? raw.cache_version : 0
+		};
+	} catch {}
+	return null;
+}
+function writeDevExecutaCache(cwd, entry) {
+	const p = executaCachePath(cwd);
+	mkdirSync(dirname(p), { recursive: true });
+	writeFileSync(p, JSON.stringify(entry, null, 2) + "\n", "utf-8");
+}
+/** Call `POST /api/v1/anna-apps/dev/executas/register`. Idempotent. */
+async function registerDevExecuta(args) {
+	const url = `${canonicalHost(args.host)}/api/v1/anna-apps/dev/executas/register`;
+	const res = await fetch(url, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			pat: args.pat,
+			tool_id: args.toolId,
+			slug: args.slug,
+			name: args.name
+		})
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new Error(`/dev/executas/register failed: HTTP ${res.status} ${text}`);
+	}
+	return await res.json();
+}
+/**
+* Convenience: return a cached executa registration if still valid for
+* this host+tool_id, otherwise hit the server. Throws if no PAT.
+*/
+async function ensureDevExecutaRegistered(args) {
+	const canonical = canonicalHost(args.host);
+	const cached = readDevExecutaCache(args.cwd);
+	if (cached && cached.host === canonical && cached.tool_id === args.toolId && cached.cache_version >= EXECUTA_CACHE_VERSION && (!args.slug || cached.slug === args.slug)) return cached;
+	const r = await registerDevExecuta({
+		host: args.host,
+		pat: args.pat,
+		toolId: args.toolId,
+		slug: args.slug,
+		name: args.name
+	});
+	const entry = {
+		host: canonical,
+		slug: r.slug,
+		app_id: r.app_id,
+		tool_id: r.tool_id,
+		name: r.name,
+		registered_at: new Date().toISOString(),
+		cache_version: EXECUTA_CACHE_VERSION
+	};
+	writeDevExecutaCache(args.cwd, entry);
+	return entry;
+}
+
+//#endregion
+export { ensureDevAppRegistered, ensureDevExecutaRegistered, listDevApps, readDevAppCache, readDevExecutaCache, registerDevApp, registerDevExecuta, writeDevAppCache, writeDevExecutaCache };

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

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

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

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

package/dist/executa-dev-4FZ7AJHR.js

@@ -0,0 +1,259 @@
+import { parseExecutaSpec } from "./dev-C6v5yRV2.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 { getAccount } = await import("./credentials-DDqx6XMQ.js");
+	const { ensureDevExecutaRegistered } = await import("./dev-app-cache-DGF2Kuzd.js");
+	const needsRealMint = !opts.noSampling && !opts.mockSampling || !opts.noAgent && !opts.mockAgent || !opts.noImage && !opts.mockImage || !opts.noUpload && !opts.mockUpload || opts.storage === "real";
+	let effectiveAppSlug = opts.appSlug;
+	let autoRegistered = false;
+	if (!effectiveAppSlug && needsRealMint) {
+		const acc = getAccount(opts.samplingAccount);
+		if (acc) try {
+			const reg = await ensureDevExecutaRegistered({
+				cwd: parsed.project_dir,
+				host: acc.host,
+				pat: acc.pat,
+				toolId: parsed.tool_id
+			});
+			effectiveAppSlug = reg.slug;
+			autoRegistered = true;
+		} catch (e) {
+			if (!quiet) {
+				console.warn(yellow(`! executa auto-register failed: ${e.message}`));
+				console.warn(yellow("  reverse-RPC bridges (sampling/agent/image/upload) will run in disabled mode. Pass `--app-slug <slug>` to override, or `--no-sampling --no-agent --no-image --no-upload` to silence."));
+			}
+		}
+	}
+	const { SamplingBridge } = await import("./sampling-CJUDG-mf.js");
+	const sampling = opts.noSampling ? new SamplingBridge({ mode: "off" }) : opts.mockSampling ? new SamplingBridge({
+		mode: "mock",
+		mockFile: opts.mockSampling
+	}) : effectiveAppSlug ? new SamplingBridge({
+		mode: "real",
+		account: opts.samplingAccount,
+		appSlug: effectiveAppSlug
+	}) : 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
+	}) : effectiveAppSlug ? new AgentBridge({
+		mode: "real",
+		account: opts.agentAccount ?? opts.samplingAccount,
+		appSlug: effectiveAppSlug
+	}) : new AgentBridge({ mode: "off" });
+	const { StorageBridge } = await import("./storage-EQJA_0UW.js");
+	const storageMode = opts.storage ?? (opts.mockStorage ? "mock" : "memory");
+	const storage = new StorageBridge({
+		mode: storageMode,
+		mockFile: opts.mockStorage,
+		account: opts.storageAccount ?? opts.samplingAccount,
+		appSlug: effectiveAppSlug,
+		scopes: opts.storageScopes ? opts.storageScopes.split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+		pluginName: parsed.tool_id
+	});
+	const { ExecutaRunner } = await import("./runner-DmGLdat0.js");
+	const { ImageBridge } = await import("./image-bwolX7pa.js");
+	const image = opts.noImage ? new ImageBridge({ mode: "off" }) : opts.mockImage ? new ImageBridge({
+		mode: "mock",
+		mockFile: opts.mockImage
+	}) : effectiveAppSlug ? new ImageBridge({
+		mode: "real",
+		account: opts.imageAccount ?? opts.samplingAccount,
+		appSlug: effectiveAppSlug
+	}) : new ImageBridge({ mode: "off" });
+	const { HostUploadBridge } = await import("./host_upload-C_pGOS6p.js");
+	const hostUpload = opts.noUpload ? new HostUploadBridge({ mode: "off" }) : opts.mockUpload ? new HostUploadBridge({
+		mode: "mock",
+		mockFile: opts.mockUpload
+	}) : effectiveAppSlug ? new HostUploadBridge({
+		mode: "real",
+		account: opts.uploadAccount ?? opts.samplingAccount,
+		appSlug: effectiveAppSlug
+	}) : new HostUploadBridge({ mode: "off" });
+	const runner = new ExecutaRunner({
+		command: parsed.command,
+		cwd: parsed.project_dir,
+		sampling,
+		agent,
+		storage,
+		image,
+		hostUpload,
+		onStderr: (line) => {
+			const text = quiet ? `${line}\n` : dim(`[executa] ${line}\n`);
+			writeStderrCooperative(text);
+		}
+	});
+	if (!quiet) {
+		const slugTag = (mode) => effectiveAppSlug ? `${mode} → app_slug=${effectiveAppSlug}${autoRegistered ? " (auto)" : ""}` : "disabled (no fixture, no --app-slug, no PAT)";
+		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(" "))}`);
+		if (autoRegistered && effectiveAppSlug) console.log(`  executa   ${dim(`auto-registered as ${effectiveAppSlug}`)}`);
+		console.log(`  sampling  ${dim(opts.noSampling ? "disabled (--no-sampling)" : opts.mockSampling ? `mock (${opts.mockSampling})` : slugTag("real"))}`);
+		console.log(`  agent     ${dim(opts.noAgent ? "disabled (--no-agent)" : opts.mockAgent ? `mock (${opts.mockAgent})` : slugTag("real"))}`);
+		console.log(`  storage   ${dim(storageMode === "mock" ? `mock (${opts.mockStorage ?? "<no-fixture>"})` : storageMode === "real" ? `real → app_slug=${effectiveAppSlug ?? "<unset>"}` : storageMode)}`);
+		console.log(`  image     ${dim(opts.noImage ? "disabled (--no-image)" : opts.mockImage ? `mock (${opts.mockImage})` : slugTag("real"))}`);
+		console.log(`  upload    ${dim(opts.noUpload ? "disabled (--no-upload)" : opts.mockUpload ? `mock (${opts.mockUpload})` : slugTag("real"))}`);
+	}
+	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 };