@anna-ai/cli 0.1.19 → 0.1.21

package/dist/{dev-b1j-dEM2.js → dev-E7mqXj5S.js}

@@ -43,8 +43,8 @@ async function runDev(opts) {
 		}
 		process.env.ANNA_APP_RUNTIME_STORAGE_MODE = "aps";
 	}
-	const { PythonBridge, PINNED_RUNTIME_VERSION } = await import("./bridge-B3Vwr4cg.js");
-	const { HarnessServer } = await import("./server-BgJGmEpv.js");
+	const { PythonBridge, PINNED_RUNTIME_VERSION } = await import("./bridge-Id8K8gr-.js");
+	const { HarnessServer } = await import("./server-_IG8Igje.js");
 	const bridge = new PythonBridge({
 		mode,
 		matrixNexusRoot: matrixNexusRoot ?? void 0,
@@ -77,6 +77,19 @@ async function runDev(opts) {
 	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 bundledResolved = resolveBundledHandles(dirname(manifestPath), executas);
+	if (Object.keys(bundledResolved).length > 0) {
+		const { substituteBundledRefs, writeBundleToolIdSidecar } = await import("./bundled-executas-CNaV2C_O.js");
+		try {
+			manifest = substituteBundledRefs(manifest, bundledResolved);
+			writeBundleToolIdSidecar(bundleDir, bundledResolved);
+			console.log(`  bundled handles   ${dim(Object.entries(bundledResolved).map(([h, id]) => `${h}→${id}`).join(", "))}`);
+		} catch (e) {
+			console.error(red(`✗ bundled handle resolution failed: ${e.message}`));
+			await bridge.stop();
+			return 2;
+		}
+	}
 	const llm = opts.noLlm ? { mode: "off" } : opts.mockLlm ? {
 		mode: "mock",
 		mockFile: opts.mockLlm
@@ -136,8 +149,8 @@ async function runDev(opts) {
 * registered `appSlug`.
 */
 async function resolveRealLlm(args) {
-	const { getAccount } = await import("./credentials-DDqx6XMQ.js");
-	const { ensureDevAppRegistered } = await import("./dev-app-cache-CZ1UjMz0.js");
+	const { getAccount } = await import("./credentials-DklPMD22.js");
+	const { ensureDevAppRegistered } = await import("./dev-app-cache-D-r6ZpEk.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.)"));
@@ -166,7 +179,7 @@ async function resolveRealLlm(args) {
 			account: args.account,
 			appSlug: entry.slug,
 			onAppSlugNotFound: async () => {
-				const { invalidateDevAppCache } = await import("./dev-app-cache-CZ1UjMz0.js");
+				const { invalidateDevAppCache } = await import("./dev-app-cache-D-r6ZpEk.js");
 				invalidateDevAppCache(args.cwd);
 				const fresh = getAccount(args.account);
 				if (!fresh) throw new Error("PAT not found while re-registering dev app — run `anna-app login` again");
@@ -188,6 +201,46 @@ function deriveSlug(manifest, path) {
 	if (typeof fromMan === "string" && fromMan) return fromMan;
 	return dirname(path).split(/[\\/]/).pop() || "anna-app-dev";
 }
+/**
+* Map each `app.json` `bundled_executas` handle to the concrete dev
+* `tool_id` of the executa discovered at its `path`. Mirrors PUBLISH's
+* handle→minted-id resolution so `anna-app dev` can rewrite
+* `bundled:<handle>` refs in the manifest. Returns `{}` when there is no
+* `app.json` or no `bundled_executas`. Unresolvable handles are warned and
+* skipped (the leftover `bundled:` ref will then fail the whitelist, which
+* surfaces the misconfiguration loudly).
+*/
+function resolveBundledHandles(manifestDir, executas) {
+	const appJsonPath = resolve(manifestDir, "app.json");
+	if (!existsSync(appJsonPath)) return {};
+	let appJson;
+	try {
+		appJson = JSON.parse(readFileSync(appJsonPath, "utf-8"));
+	} catch (e) {
+		console.warn(yellow(`⚠ app.json is not valid json: ${e.message}`));
+		return {};
+	}
+	const bundled = appJson.bundled_executas;
+	if (!bundled || typeof bundled !== "object") return {};
+	const byDir = new Map();
+	for (const ex of executas) byDir.set(resolve(ex.project_dir), ex.tool_id);
+	const resolved = {};
+	for (const [handle, spec] of Object.entries(bundled)) {
+		const p = spec?.path;
+		if (!p) {
+			console.warn(yellow(`⚠ bundled_executas["${handle}"] missing "path"`));
+			continue;
+		}
+		const dir = isAbsolute(p) ? p : resolve(manifestDir, p);
+		const toolId = byDir.get(resolve(dir));
+		if (!toolId) {
+			console.warn(yellow(`⚠ bundled handle "${handle}" → ${p}: no executa discovered at that path (check executas/<dir>/executa.json "tool_id")`));
+			continue;
+		}
+		resolved[handle] = toolId;
+	}
+	return resolved;
+}
 function autoDiscoverExecutas(manifestDir) {
 	const root = resolve(manifestDir, "executas");
 	if (!existsSync(root)) return [];
@@ -257,13 +310,17 @@ function discoverOne(dir, name, opts = { respectEnabled: true }) {
 }
 function defaultCommand(type, dir, toolId) {
 	switch (type) {
-		case "python": return [
-			"uv",
-			"run",
-			"--project",
-			dir,
-			toolId
-		];
+		case "python": {
+			const script = pythonScriptName(dir);
+			if (script instanceof Error) return script;
+			return [
+				"uv",
+				"run",
+				"--project",
+				dir,
+				script ?? toolId
+			];
+		}
 		case "node": {
 			const pkg = readPackageJson(dir);
 			if (!pkg) return new Error("type=node but no package.json found");
@@ -285,7 +342,30 @@ function defaultCommand(type, dir, toolId) {
 	}
 }
 function discoverPython(dir, name) {
+	const script = pythonScriptName(dir);
+	if (script instanceof Error) return script;
+	if (script === null) return new Error("no [project.scripts] entry in pyproject.toml");
+	return {
+		tool_id: script,
+		project_dir: dir,
+		command: [
+			"uv",
+			"run",
+			"--project",
+			dir,
+			script
+		]
+	};
+}
+/**
+* First `[project.scripts]` entry name from a dir's pyproject.toml — the
+* console-script `uv run` should launch. Returns `null` when there's no
+* pyproject / no scripts table (caller decides the fallback), or an Error
+* when pyproject exists but can't be parsed.
+*/
+function pythonScriptName(dir) {
 	const py = resolve(dir, "pyproject.toml");
+	if (!existsSync(py)) return null;
 	let body;
 	try {
 		body = readFileSync(py, "utf-8");
@@ -299,21 +379,10 @@ function discoverPython(dir, name) {
 		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");
+	if (!scripts || typeof scripts !== "object") return null;
 	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
-		]
-	};
+	if (keys.length === 0) return null;
+	return keys[0];
 }
 function discoverNode(dir, name) {
 	const pkg = readPackageJson(dir);

package/dist/{dev-app-cache-3Pfesngr.js → dev-app-cache-D-r6ZpEk.js}

@@ -82,7 +82,16 @@ async function listDevApps(args) {
 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;
+	if (cached && cached.host === canonical && cached.slug === args.input.slug) try {
+		const apps = await listDevApps({
+			host: args.host,
+			pat: args.pat
+		});
+		if (apps.some((a) => a.slug === args.input.slug)) return cached;
+		invalidateDevAppCache(args.cwd);
+	} catch {
+		return cached;
+	}
 	const r = await registerDevApp({
 		host: args.host,
 		pat: args.pat,
@@ -186,4 +195,4 @@ async function ensureDevExecutaRegistered(args) {
 }
 
 //#endregion
-export { ensureDevAppRegistered, ensureDevExecutaRegistered, invalidateDevAppCache, listDevApps, readDevAppCache, readDevExecutaCache, registerDevApp, registerDevExecuta, writeDevAppCache, writeDevExecutaCache };
+export { ensureDevAppRegistered, ensureDevExecutaRegistered, invalidateDevAppCache };

package/dist/{doctor-CgJYokiR.js → doctor-DKrt-Kda.js}

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

package/dist/executa-cache-BFoUtb4J.js

@@ -0,0 +1,86 @@
+import { canonicalHost } from "./credentials-BTv2IfUZ.js";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+
+//#region src/identity/executa-cache.ts
+const CACHE_DIR = ".anna";
+const CACHE_FILE = "executa.json";
+function executaCachePath(cwd) {
+	return resolve(cwd, CACHE_DIR, CACHE_FILE);
+}
+function readExecutaIdentity(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.tool_id === "string" && typeof raw.executa_id === "number" && typeof raw.slug === "string" && (raw.executa_type === "tool" || raw.executa_type === "skill")) return {
+			$schema: "anna-executa-identity/v1",
+			host: canonicalHost(raw.host),
+			executa_id: raw.executa_id,
+			tool_id: raw.tool_id,
+			slug: raw.slug,
+			executa_type: raw.executa_type,
+			first_published_at: raw.first_published_at
+		};
+	} catch {}
+	return null;
+}
+function writeExecutaIdentity(cwd, identity) {
+	const p = executaCachePath(cwd);
+	mkdirSync(dirname(p), { recursive: true });
+	const tmp = `${p}.tmp.${process.pid}`;
+	writeFileSync(tmp, JSON.stringify({
+		...identity,
+		host: canonicalHost(identity.host)
+	}, null, 2) + "\n", "utf-8");
+	try {
+		renameSync(tmp, p);
+	} catch (e) {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+		throw e;
+	}
+}
+function executaCacheMatches(identity, host, slug) {
+	if (!identity) return false;
+	return identity.host === canonicalHost(host) && identity.slug === slug;
+}
+/**
+* Remove the cache file (best-effort). Used when a cached identity
+* points at a server-side row that no longer exists (404 on
+* GET/PUT/POST against `executa_id`), so the next `executa publish`
+* re-runs the draft+commit mint path with the idempotency key instead
+* of dying with "Tool not found".
+*/
+function invalidateExecutaCache(cwd) {
+	const p = executaCachePath(cwd);
+	try {
+		if (existsSync(p)) unlinkSync(p);
+	} catch {}
+}
+/**
+* Stable mint idempotency key — `sha256(host|slug|type)`.
+*
+* Sent on every `POST /my/drafts` so that a fresh CI runner without the
+* `.anna/executa.json` cache short-circuits onto the existing draft /
+* Executa instead of minting a brand-new `tool_id`.
+*/
+function mintIdempotencyKey(host, slug, executaType) {
+	const canonical = canonicalHost(host);
+	const h = createHash("sha256");
+	h.update(canonical);
+	h.update("|");
+	h.update(slug);
+	h.update("|");
+	h.update(executaType);
+	return h.digest("hex");
+}
+const _internal = {
+	CACHE_DIR,
+	CACHE_FILE: join(CACHE_DIR, CACHE_FILE)
+};
+
+//#endregion
+export { executaCacheMatches, executaCachePath, invalidateExecutaCache, mintIdempotencyKey, readExecutaIdentity, writeExecutaIdentity };

package/dist/executa-cache-WBkCLic7.js

@@ -0,0 +1,4 @@
+import "./credentials-BTv2IfUZ.js";
+import { executaCacheMatches, executaCachePath, invalidateExecutaCache, mintIdempotencyKey, readExecutaIdentity, writeExecutaIdentity } from "./executa-cache-BFoUtb4J.js";
+
+export { executaCachePath, invalidateExecutaCache };

package/dist/executa-destructive-COQE4Xqi.js

@@ -0,0 +1,104 @@
+import "./credentials-BTv2IfUZ.js";
+import { CliError } from "./client-Dn9zThOd.js";
+import { deleteMyTool, listMyTools, listToolVersions, unpublishTool, yankToolVersion } from "./executas-Cep6KEo0.js";
+import { resolveClient, withErrorHandling } from "./_lifecycle-shared-sbea9HtH.js";
+import { ensureDestructiveAllowed } from "./confirm-DxHkk9Wn.js";
+import { dim, green, yellow } from "kleur/colors";
+
+//#region src/commands/executa-destructive.ts
+async function findBySlug(client, ref) {
+	const rows = await listMyTools(client);
+	const exact = rows.find((r) => r.tool_id === ref);
+	if (exact) return exact;
+	const matches = rows.filter((r) => r.tool_id.includes(ref));
+	if (matches.length === 0) return null;
+	if (matches.length === 1) return matches[0] ?? null;
+	const list = matches.map((r) => `  - ${r.tool_id}`).join("\n");
+	throw new CliError(`ref "${ref}" is ambiguous (${matches.length} matches):\n${list}\nPlease pass the full tool_id.`, 5);
+}
+/**
+* Confirm-token UX: accept the slug the user typed OR the real server
+* tool_id. Validating against tool_id is the safer match because the
+* user has just been told what it is by the resolver.
+*/
+async function checkConfirm(verb, refTyped, toolId, opts) {
+	await ensureDestructiveAllowed({
+		verb,
+		slug: toolId,
+		yes: opts.yes,
+		confirm: opts.confirm === refTyped ? toolId : opts.confirm
+	});
+}
+async function runExecutaUnpublish(opts) {
+	return withErrorHandling(async () => {
+		const { client, host } = resolveClient({ account: opts.account });
+		const ex = await findBySlug(client, opts.slug);
+		if (!ex) throw new CliError(`no executa matching "${opts.slug}" on ${host}`, 5);
+		await checkConfirm("executa unpublish", opts.slug, ex.tool_id, opts);
+		const updated = await unpublishTool(client, ex.id);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				executa_id: ex.id,
+				tool_id: ex.tool_id,
+				visibility: updated.visibility ?? null
+			}, null, 2));
+			return 0;
+		}
+		console.log(green(`✓ executas/${ex.tool_id}: unpublished (visibility=${updated.visibility})`));
+		return 0;
+	});
+}
+async function runExecutaYank(opts) {
+	return withErrorHandling(async () => {
+		const at = opts.ref.lastIndexOf("@");
+		if (at < 1) throw new CliError(`\`executa yank\` expects <slug>@<version> (got "${opts.ref}")`, 4);
+		const slug = opts.ref.slice(0, at);
+		const version = opts.ref.slice(at + 1);
+		const { client, host } = resolveClient({ account: opts.account });
+		const ex = await findBySlug(client, slug);
+		if (!ex) throw new CliError(`no executa matching "${slug}" on ${host}`, 5);
+		await checkConfirm("executa yank", slug, ex.tool_id, opts);
+		const versions = await listToolVersions(client, ex.id);
+		const ver = versions.find((v) => v.version === version);
+		if (!ver) throw new CliError(`no version "${version}" for executa "${slug}" (have: ${versions.map((v) => v.version).join(", ") || "(none)"})`, 5);
+		await yankToolVersion(client, ex.id, ver.id);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				executa_id: ex.id,
+				tool_id: ex.tool_id,
+				version,
+				version_id: ver.id,
+				yanked: true
+			}, null, 2));
+			return 0;
+		}
+		console.log(yellow(`✓ executas/${ex.tool_id}@${version}: yanked (version_id=${ver.id})`));
+		return 0;
+	});
+}
+async function runExecutaDelete(opts) {
+	return withErrorHandling(async () => {
+		const { client, host } = resolveClient({ account: opts.account });
+		const ex = await findBySlug(client, opts.slug);
+		if (!ex) throw new CliError(`no executa matching "${opts.slug}" on ${host}`, 5);
+		await checkConfirm("executa delete", opts.slug, ex.tool_id, opts);
+		await deleteMyTool(client, ex.id);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				executa_id: ex.id,
+				tool_id: ex.tool_id,
+				deleted: true
+			}, null, 2));
+			return 0;
+		}
+		console.log(yellow(`✓ executas/${ex.tool_id}: deleted`));
+		console.log(dim(`  (local .anna/executa.json is now stale; remove it manually if you no longer need it)`));
+		return 0;
+	});
+}
+
+//#endregion
+export { runExecutaDelete, runExecutaUnpublish, runExecutaYank };

package/dist/{executa-dev-BeC6a8S8.js → executa-dev-BvS9zTpO.js}

@@ -1,9 +1,9 @@
-import { parseExecutaSpec } from "./dev-b1j-dEM2.js";
+import { parseExecutaSpec } from "./dev-E7mqXj5S.js";
 import { isAbsolute, resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { bold, cyan, dim, green, red, yellow } from "kleur/colors";
+import { createInterface } from "node:readline/promises";
 import * as readline from "node:readline";
-import { createInterface as createInterface$1 } from "node:readline/promises";
 
 //#region src/commands/executa-dev.ts
 /**
@@ -33,8 +33,8 @@ async function runExecutaDev(opts) {
 	}
 	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-CZ1UjMz0.js");
+	const { getAccount } = await import("./credentials-DklPMD22.js");
+	const { ensureDevExecutaRegistered } = await import("./dev-app-cache-D-r6ZpEk.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;
@@ -56,7 +56,7 @@ async function runExecutaDev(opts) {
 			}
 		}
 	}
-	const { SamplingBridge } = await import("./sampling-CJUDG-mf.js");
+	const { SamplingBridge } = await import("./sampling-CXke7hq1.js");
 	const sampling = opts.noSampling ? new SamplingBridge({ mode: "off" }) : opts.mockSampling ? new SamplingBridge({
 		mode: "mock",
 		mockFile: opts.mockSampling
@@ -65,7 +65,7 @@ async function runExecutaDev(opts) {
 		account: opts.samplingAccount,
 		appSlug: effectiveAppSlug
 	}) : new SamplingBridge({ mode: "off" });
-	const { AgentBridge } = await import("./agent-DUmINbo4.js");
+	const { AgentBridge } = await import("./agent-Br6zY2qw.js");
 	const agent = opts.noAgent ? new AgentBridge({ mode: "off" }) : opts.mockAgent ? new AgentBridge({
 		mode: "mock",
 		mockFile: opts.mockAgent
@@ -74,7 +74,7 @@ async function runExecutaDev(opts) {
 		account: opts.agentAccount ?? opts.samplingAccount,
 		appSlug: effectiveAppSlug
 	}) : new AgentBridge({ mode: "off" });
-	const { StorageBridge } = await import("./storage-EQJA_0UW.js");
+	const { StorageBridge } = await import("./storage-CTkApNQ9.js");
 	const storageMode = opts.storage ?? (opts.mockStorage ? "mock" : "memory");
 	const storage = new StorageBridge({
 		mode: storageMode,
@@ -84,8 +84,8 @@ async function runExecutaDev(opts) {
 		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 { ExecutaRunner } = await import("./runner-B-hIqx5L.js");
+	const { ImageBridge } = await import("./image-DduR91n5.js");
 	const image = opts.noImage ? new ImageBridge({ mode: "off" }) : opts.mockImage ? new ImageBridge({
 		mode: "mock",
 		mockFile: opts.mockImage
@@ -94,7 +94,7 @@ async function runExecutaDev(opts) {
 		account: opts.imageAccount ?? opts.samplingAccount,
 		appSlug: effectiveAppSlug
 	}) : new ImageBridge({ mode: "off" });
-	const { HostUploadBridge } = await import("./host_upload-C_pGOS6p.js");
+	const { HostUploadBridge } = await import("./host_upload-GXVkDM5M.js");
 	const hostUpload = opts.noUpload ? new HostUploadBridge({ mode: "off" }) : opts.mockUpload ? new HostUploadBridge({
 		mode: "mock",
 		mockFile: opts.mockUpload
@@ -183,7 +183,7 @@ async function runOneShot(runner, opts, quiet) {
 	}
 }
 async function runRepl(runner) {
-	const rl = createInterface$1({
+	const rl = createInterface({
 		input: process.stdin,
 		output: process.stdout
 	});

package/dist/executa-publish-B88_9gbp.js

@@ -0,0 +1,9 @@
+import "./credentials-BTv2IfUZ.js";
+import "./client-Dn9zThOd.js";
+import "./executas-Cep6KEo0.js";
+import "./executa-cache-BFoUtb4J.js";
+import { runExecutaPublish } from "./executa-publish-Ca5V7MyA.js";
+import "./manifest-DGwRap2i.js";
+import "./_lifecycle-shared-sbea9HtH.js";
+
+export { runExecutaPublish };