@anna-ai/cli 0.1.19 → 0.1.22

package/dist/executa-publish-Ca5V7MyA.js

@@ -0,0 +1,258 @@
+import { canonicalHost } from "./credentials-BTv2IfUZ.js";
+import { CliError } from "./client-Dn9zThOd.js";
+import { commitDraft, createDraft, getMySkill, getMyTool, listToolVersions, publishToolVersion, setSkillVisibility, setToolVisibility, updateMySkill, updateMyTool } from "./executas-Cep6KEo0.js";
+import { executaCacheMatches, invalidateExecutaCache, mintIdempotencyKey, readExecutaIdentity, writeExecutaIdentity } from "./executa-cache-BFoUtb4J.js";
+import { loadExecutaManifest } from "./manifest-DGwRap2i.js";
+import { resolveClient, withErrorHandling } from "./_lifecycle-shared-sbea9HtH.js";
+import { join, relative, resolve, sep } from "node:path";
+import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { bold, cyan, dim, green, yellow } from "kleur/colors";
+import { createHash } from "node:crypto";
+
+//#region src/publish/bundle.ts
+function manifestHash(manifest) {
+	const canon = canonicalize(manifest);
+	return createHash("sha256").update(canon).digest("hex");
+}
+function bundleHash(manifest, bundleDir) {
+	const h = createHash("sha256");
+	h.update(canonicalize(manifest));
+	if (bundleDir) {
+		const files = walk(bundleDir);
+		files.sort();
+		for (const rel of files) {
+			const abs = join(bundleDir, rel);
+			const data = readFileSync(abs);
+			h.update("\n");
+			h.update(rel.split(sep).join("/"));
+			h.update("\0");
+			h.update(createHash("sha256").update(data).digest("hex"));
+		}
+	}
+	return h.digest("hex");
+}
+/** RFC-8785-ish JSON canonicalization, sufficient for our hash use. */
+function canonicalize(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return "[" + value.map(canonicalize).join(",") + "]";
+	const obj = value;
+	const keys = Object.keys(obj).sort();
+	return "{" + keys.map((k) => JSON.stringify(k) + ":" + canonicalize(obj[k])).join(",") + "}";
+}
+function walk(root, base = root) {
+	const out = [];
+	for (const ent of readdirSync(base, { withFileTypes: true })) {
+		const abs = join(base, ent.name);
+		if (ent.isDirectory()) out.push(...walk(root, abs));
+		else if (ent.isFile()) out.push(relative(root, abs));
+	}
+	return out;
+}
+
+//#endregion
+//#region src/publish/bump.ts
+function bumpVersion(current, kind) {
+	const m = current.match(/^(\d+)\.(\d+)\.(\d+)(?:[-+][0-9A-Za-z.-]+)?$/);
+	if (!m || !m[1] || !m[2] || !m[3]) throw new CliError(`cannot bump non-semver version "${current}"`, 4);
+	let [, maj, min, pat] = m;
+	if (kind === "major") {
+		maj = String(Number(maj) + 1);
+		min = "0";
+		pat = "0";
+	} else if (kind === "minor") {
+		min = String(Number(min) + 1);
+		pat = "0";
+	} else pat = String(Number(pat) + 1);
+	return `${maj}.${min}.${pat}`;
+}
+/**
+* Rewrite a manifest's `version` field in place.
+*
+* Preserves on-disk formatting as much as possible (re-serialising
+* with 2-space JSON.stringify) — `manifest.json` and `executa.json`
+* are both expected to be machine-managed, so cosmetic formatting
+* differences are acceptable.
+*/
+function rewriteVersion(manifestPath, manifest, newVersion) {
+	const next = {
+		...manifest,
+		version: newVersion
+	};
+	writeFileSync(manifestPath, JSON.stringify(next, null, 2) + "\n", "utf-8");
+}
+
+//#endregion
+//#region src/commands/executa-publish.ts
+/**
+* Flatten the parsed `executa.json` `distribution` block into the snake_case
+* field set the server expects on both the draft-commit payload and the
+* `PUT /my/tools/{id}` metadata sync. Returns an empty object when the
+* Executa declares no distribution (dev-only) so the spread is a no-op.
+*
+* Note: per-asset `sha256` is folded into each `binary_urls` asset dict
+* (`{ url, sha256, … }`) rather than sent as a separate top-level
+* `binary_sha256` map — the `PUT /my/tools/{id}` schema
+* (`UserToolUpdateRequest`) has no `binary_sha256` field, whereas
+* `binary_urls` accepts the asset-dict form on both the create and update
+* paths.
+*/
+function distributionPayload(d) {
+	if (!d) return {};
+	const out = { distribution_type: d.type };
+	if (d.packageName !== void 0) out.package_name = d.packageName;
+	if (d.executableName !== void 0) out.executable_name = d.executableName;
+	if (d.supportsProtocol !== void 0) out.supports_protocol = d.supportsProtocol;
+	if (d.binaryUrls !== void 0) out.binary_urls = d.binaryUrls;
+	if (d.capabilities !== void 0) out.capabilities = d.capabilities;
+	return out;
+}
+async function runExecutaPublish(opts) {
+	return withErrorHandling(async () => {
+		const cwd = resolve(opts.cwd ?? process.cwd());
+		const manifest = loadExecutaManifest(cwd, opts.manifest);
+		const isSkill = manifest.executa_type === "skill";
+		const { client, host, source } = resolveClient({ account: opts.account });
+		if (!opts.json && !opts.quiet) console.log(dim(`using PAT from ${source} (host=${host})`));
+		if (opts.bump) {
+			const next = bumpVersion(manifest.version, opts.bump);
+			if (!opts.json && !opts.quiet) console.log(yellow(`↑ bumping executa.json version: ${manifest.version} → ${next}`));
+			if (!opts.noWrite && !opts.dryRun) rewriteVersion(manifest.path, manifest.raw, next);
+			manifest.version = next;
+			manifest.raw.version = next;
+		}
+		let cached = readExecutaIdentity(cwd);
+		if (cached && cached.host !== canonicalHost(host)) cached = null;
+		let executaId;
+		let toolId;
+		let serverSlug;
+		let firstPublish = false;
+		let cacheValid = false;
+		if (cached && executaCacheMatches(cached, host, manifest.slug)) try {
+			if (isSkill) await getMySkill(client, cached.executa_id);
+			else await getMyTool(client, cached.executa_id);
+			cacheValid = true;
+		} catch (e) {
+			if (e instanceof CliError && e.status === 404) {
+				if (!opts.json && !opts.quiet) console.log(yellow(`! cached executa_id=${cached.executa_id} no longer exists on ${host}; clearing .anna/executa.json and re-minting via draft+commit`));
+				invalidateExecutaCache(cwd);
+				cached = null;
+			} else throw e;
+		}
+		if (cacheValid && cached) {
+			executaId = cached.executa_id;
+			toolId = cached.tool_id;
+			serverSlug = cached.slug;
+		} else {
+			if (opts.dryRun) {
+				if (!opts.json) console.log(yellow(`[dry-run] would POST /my/drafts (slug=${manifest.slug}, type=${manifest.executa_type}) and commit`));
+				return 0;
+			}
+			const idemKey = mintIdempotencyKey(host, manifest.slug, manifest.executa_type);
+			const draftRes = await createDraft(client, {
+				name: manifest.name,
+				executa_type: manifest.executa_type,
+				slug_override: manifest.slug,
+				idempotency_key: idemKey
+			});
+			if (draftRes.committedExecutaId !== null) {
+				executaId = draftRes.committedExecutaId;
+				toolId = draftRes.draft.tool_id;
+				serverSlug = manifest.slug;
+				if (!opts.json && !opts.quiet) console.log(dim(`(server idempotent hit on already-committed Executa id=${executaId})`));
+			} else {
+				const draft = draftRes.draft;
+				const finalPayload = {
+					...typeof draft.payload === "object" && draft.payload !== null ? draft.payload : {},
+					name: manifest.name,
+					description: manifest.description,
+					executa_type: manifest.executa_type,
+					slug: manifest.slug,
+					version: manifest.version,
+					...distributionPayload(manifest.distribution)
+				};
+				if (manifest.executa_type === "skill") {
+					finalPayload.skill_content = manifest.skillContent;
+					if (manifest.executionMode) finalPayload.execution_mode = manifest.executionMode;
+				}
+				const committed = draftRes.idempotentHit ? await commitDraft(client, draft.id, finalPayload) : await commitDraft(client, draft.id, finalPayload);
+				executaId = committed.executa_id;
+				toolId = committed.tool_id;
+				serverSlug = manifest.slug;
+				firstPublish = true;
+			}
+			writeExecutaIdentity(cwd, {
+				$schema: "anna-executa-identity/v1",
+				host: canonicalHost(host),
+				executa_id: executaId,
+				tool_id: toolId,
+				slug: serverSlug,
+				executa_type: manifest.executa_type,
+				first_published_at: cached?.first_published_at ?? new Date().toISOString()
+			});
+		}
+		if (opts.dryRun) {
+			if (!opts.json) console.log(yellow(`[dry-run] resolved executa_id=${executaId} tool_id=${toolId}; would PUT metadata + POST version ${manifest.version}`));
+			return 0;
+		}
+		if (isSkill) await updateMySkill(client, executaId, {
+			name: manifest.name,
+			description: manifest.description,
+			skill_content: manifest.skillContent,
+			version: manifest.version,
+			...manifest.executionMode ? { skill_execution_mode: manifest.executionMode } : {}
+		});
+		else await updateMyTool(client, executaId, {
+			name: manifest.name,
+			description: manifest.description,
+			...distributionPayload(manifest.distribution)
+		});
+		const preFreeze = isSkill ? await getMySkill(client, executaId) : await getMyTool(client, executaId);
+		const currentVis = preFreeze.visibility ?? "private";
+		const targetVis = opts.publish ? "public" : currentVis === "public" ? "public" : "app_bundled";
+		const visibilityChanged = currentVis !== targetVis;
+		if (visibilityChanged) if (isSkill) await setSkillVisibility(client, executaId, targetVis);
+		else await setToolVisibility(client, executaId, targetVis);
+		const hash = manifestHash(manifest.raw);
+		const freeze = opts.freeze !== false;
+		let frozenIdempotentHit;
+		if (!freeze) frozenIdempotentHit = true;
+		else if (isSkill) frozenIdempotentHit = !visibilityChanged;
+		else {
+			const verRes = await publishToolVersion(client, executaId, { version: manifest.version }, hash);
+			frozenIdempotentHit = verRes.idempotentHit;
+		}
+		let publishedToPublic = false;
+		if (opts.publish && targetVis === "public") publishedToPublic = true;
+		const finalExecuta = isSkill ? await getMySkill(client, executaId) : await getMyTool(client, executaId);
+		const versions = await listToolVersions(client, executaId);
+		const latest = versions[0] ?? null;
+		const result = {
+			host,
+			executa_id: executaId,
+			tool_id: toolId,
+			slug: serverSlug,
+			version: manifest.version,
+			content_hash: hash,
+			idempotent_hit: frozenIdempotentHit,
+			first_publish: firstPublish,
+			published_public: publishedToPublic,
+			visibility: finalExecuta.visibility ?? null,
+			latest_version_id: latest?.id ?? null
+		};
+		opts.capture?.(result);
+		if (opts.quiet) return 0;
+		if (opts.json) {
+			console.log(JSON.stringify(result, null, 2));
+			return 0;
+		}
+		if (frozenIdempotentHit) console.log(green(`✓ executas/${serverSlug}: version ${manifest.version} already frozen (content hash unchanged)`));
+		else console.log(green(`✓ executas/${serverSlug}: version ${manifest.version} frozen`));
+		if (firstPublish) console.log(dim(`  first publish — wrote .anna/executa.json (tool_id=${toolId})`));
+		if (publishedToPublic) console.log(green(`  visibility set to PUBLIC`));
+		console.log(bold(cyan(`tool_id: ${toolId}`)));
+		return 0;
+	});
+}
+
+//#endregion
+export { bumpVersion, bundleHash, canonicalize, manifestHash, rewriteVersion, runExecutaPublish };

package/dist/executa-reads-CQ6S8gHY.js

@@ -0,0 +1,107 @@
+import "./credentials-BTv2IfUZ.js";
+import { CliError } from "./client-Dn9zThOd.js";
+import { getMyTool, listMyTools, listToolVersions } from "./executas-Cep6KEo0.js";
+import { resolveClient, withErrorHandling } from "./_lifecycle-shared-sbea9HtH.js";
+import { bold, cyan, dim, green } from "kleur/colors";
+
+//#region src/commands/executa-reads.ts
+async function runExecutaList(opts) {
+	return withErrorHandling(async () => {
+		const { client, host } = resolveClient({ account: opts.account });
+		const published = await listMyTools(client);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				executas: published
+			}, null, 2));
+			return 0;
+		}
+		console.log(bold(cyan(`my executas`)) + " " + dim(`(${host})`));
+		if (published.length === 0) {
+			console.log(dim("  (none — run `anna-app executa publish` from a project to mint one; dev harness placeholders show up under `anna-app apps list`)"));
+			return 0;
+		}
+		for (const r of published) {
+			const vis = r.visibility ? `[${r.visibility}]` : "";
+			console.log(`  ${green("[published]")} ${r.tool_id} ` + dim(`(id=${r.id}, type=${r.executa_type}) ${vis}`));
+		}
+		return 0;
+	});
+}
+async function findExecutaByRef(client, ref) {
+	const rows = await listMyTools(client);
+	const exact = rows.find((r) => r.tool_id === ref);
+	if (exact) return exact;
+	const slug = rows.find((r) => {
+		const parts = r.tool_id.split("-");
+		return parts.includes(ref);
+	});
+	return slug ?? null;
+}
+async function runExecutaStatus(opts) {
+	return withErrorHandling(async () => {
+		const { client, host } = resolveClient({ account: opts.account });
+		const ex = await findExecutaByRef(client, opts.ref);
+		if (!ex) throw new CliError(`no executa matching "${opts.ref}" for current user on ${host}`, 5);
+		const full = await getMyTool(client, ex.id);
+		const versions = await listToolVersions(client, ex.id);
+		const latest = versions[0] ?? null;
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				executa_id: full.id,
+				tool_id: full.tool_id,
+				name: full.name,
+				executa_type: full.executa_type,
+				visibility: full.visibility ?? null,
+				is_published: full.is_published ?? false,
+				version_count: versions.length,
+				latest_version: latest ? {
+					id: latest.id,
+					version: latest.version,
+					content_hash: latest.content_hash,
+					in_published_app: latest.in_published_app ?? false
+				} : null
+			}, null, 2));
+			return 0;
+		}
+		console.log(bold(cyan(full.tool_id)) + " " + dim(`(${host})`));
+		console.log(`  ${dim("name      :")} ${full.name}`);
+		console.log(`  ${dim("type      :")} ${full.executa_type}`);
+		console.log(`  ${dim("visibility:")} ${full.visibility ?? "(unknown)"}`);
+		console.log(`  ${dim("published :")} ${full.is_published ? green("yes") : "no"}`);
+		if (latest) console.log(`  ${dim("latest    :")} v${latest.version} (id=${latest.id})`);
+		else console.log(`  ${dim("latest    :")} ${dim("(no versions)")}`);
+		return 0;
+	});
+}
+async function runExecutaVersions(opts) {
+	return withErrorHandling(async () => {
+		const { client, host } = resolveClient({ account: opts.account });
+		const ex = await findExecutaByRef(client, opts.ref);
+		if (!ex) throw new CliError(`no executa matching "${opts.ref}" for current user on ${host}`, 5);
+		const versions = await listToolVersions(client, ex.id);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				executa_id: ex.id,
+				tool_id: ex.tool_id,
+				versions
+			}, null, 2));
+			return 0;
+		}
+		console.log(bold(cyan(ex.tool_id)) + " " + dim(`versions (${versions.length})`));
+		if (versions.length === 0) {
+			console.log(dim("  (none)"));
+			return 0;
+		}
+		for (const v of versions) {
+			const inApp = v.in_published_app ? green("[anchored]") : "          ";
+			console.log(`  ${inApp} v${v.version} ${dim(`(id=${v.id}, hash=${v.content_hash.slice(0, 12)}…)`)}`);
+		}
+		return 0;
+	});
+}
+
+//#endregion
+export { runExecutaList, runExecutaStatus, runExecutaVersions };

package/dist/executas-Cep6KEo0.js

@@ -0,0 +1,109 @@
+//#region src/api/executas.ts
+async function createDraft(client, body) {
+	const r = await client.request({
+		method: "POST",
+		path: "/api/v1/executas/my/drafts",
+		body
+	});
+	const committed = r.idempotentHit && r.data.id < 0 && r.data.payload && typeof r.data.payload === "object" && typeof r.data.payload.committed_executa_id === "number" ? r.data.payload.committed_executa_id : null;
+	return {
+		draft: r.data,
+		idempotentHit: r.idempotentHit,
+		committedExecutaId: committed
+	};
+}
+async function commitDraft(client, draftId, finalPayload) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/executas/my/drafts/${draftId}/commit`,
+		body: finalPayload ? { payload: finalPayload } : void 0
+	});
+	return r.data;
+}
+async function listMyTools(client) {
+	const r = await client.request({ path: "/api/v1/executas/my/tools" });
+	return Array.isArray(r.data) ? r.data : [];
+}
+async function getMyTool(client, executaId) {
+	const r = await client.request({ path: `/api/v1/executas/my/tools/${executaId}/detail` });
+	return r.data;
+}
+async function updateMyTool(client, executaId, body) {
+	const r = await client.request({
+		method: "PUT",
+		path: `/api/v1/executas/my/tools/${executaId}`,
+		body
+	});
+	return r.data;
+}
+async function listToolVersions(client, executaId) {
+	const r = await client.request({
+		path: `/api/v1/executas/my/tools/${executaId}/versions`,
+		allowStatuses: [404]
+	});
+	if (r.status === 404) return [];
+	return Array.isArray(r.data) ? r.data : [];
+}
+async function publishToolVersion(client, executaId, body, contentHash) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/executas/my/tools/${executaId}/versions`,
+		query: contentHash ? { content_hash: contentHash } : void 0,
+		body: body ?? void 0
+	});
+	return {
+		executa: r.data,
+		idempotentHit: r.idempotentHit
+	};
+}
+async function setToolVisibility(client, executaId, visibility) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/executas/my/tools/${executaId}/visibility`,
+		body: { visibility }
+	});
+	return r.data;
+}
+async function unpublishTool(client, executaId) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/executas/my/tools/${executaId}/unpublish`
+	});
+	return r.data;
+}
+async function getMySkill(client, executaId) {
+	const r = await client.request({ path: `/api/v1/executas/my/skills/${executaId}/detail` });
+	return r.data;
+}
+async function updateMySkill(client, executaId, body) {
+	const r = await client.request({
+		method: "PUT",
+		path: `/api/v1/executas/my/skills/${executaId}`,
+		body
+	});
+	return r.data;
+}
+async function setSkillVisibility(client, executaId, visibility) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/executas/my/skills/${executaId}/visibility`,
+		body: { visibility }
+	});
+	return r.data;
+}
+async function deleteMyTool(client, executaId) {
+	await client.request({
+		method: "DELETE",
+		path: `/api/v1/executas/my/tools/${executaId}`,
+		allowStatuses: [200, 204]
+	});
+}
+async function yankToolVersion(client, executaId, versionId) {
+	await client.request({
+		method: "DELETE",
+		path: `/api/v1/executas/my/tools/${executaId}/versions/${versionId}`
+	});
+}
+
+//#endregion
+export { commitDraft, createDraft, deleteMyTool, getMySkill, getMyTool, listMyTools, listToolVersions, publishToolVersion, setSkillVisibility, setToolVisibility, unpublishTool, updateMySkill, updateMyTool, yankToolVersion };

package/dist/manifest-DGwRap2i.js

@@ -0,0 +1,188 @@
+import { CliError } from "./client-Dn9zThOd.js";
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+
+//#region src/publish/manifest.ts
+const DISTRIBUTION_TYPES = new Set([
+	"uv",
+	"npm",
+	"homebrew",
+	"binary",
+	"pipx",
+	"local"
+]);
+/** Distribution types that install a named package from an index. */
+const PACKAGE_BACKED = new Set([
+	"uv",
+	"npm",
+	"homebrew",
+	"pipx"
+]);
+const SLUG_RE = /^[a-z0-9][a-z0-9-]{1,78}[a-z0-9]$/;
+const SEMVER_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+function readJson(path) {
+	const raw = readFileSync(path, "utf-8");
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new CliError(`manifest at ${path} must be a JSON object`, 4);
+		return parsed;
+	} catch (e) {
+		if (e instanceof CliError) throw e;
+		throw new CliError(`failed to parse ${path}: ${e.message}`, 4);
+	}
+}
+function loadAppManifest(cwd, manifestPath) {
+	const path = resolve(cwd, manifestPath ?? "manifest.json");
+	if (!existsSync(path)) throw new CliError(`no manifest.json at ${path}`, 4);
+	const raw = readJson(path);
+	const appJsonPath = resolve(cwd, "app.json");
+	const hasAppJson = existsSync(appJsonPath);
+	const appJsonRaw = hasAppJson ? readJson(appJsonPath) : null;
+	const metadataPath = hasAppJson ? appJsonPath : path;
+	const metadataRaw = appJsonRaw ?? raw;
+	const metadataLabel = hasAppJson ? "app.json" : "manifest.json";
+	const pickMeta = (k) => (appJsonRaw && pickString(appJsonRaw, k)) ?? pickString(raw, k);
+	const slug = pickMeta("slug");
+	const name = pickMeta("name") ?? slug ?? "";
+	const version = pickMeta("version") ?? "0.1.0";
+	if (!slug) throw new CliError(`${metadataLabel} missing required \`slug\` (3-80 chars, kebab-case)`, 4);
+	if (!SLUG_RE.test(slug)) throw new CliError(`slug "${slug}" is not valid — must match ${SLUG_RE.source}`, 4);
+	if (!SEMVER_RE.test(version)) throw new CliError(`${metadataLabel} \`version\` "${version}" is not semver`, 4);
+	const bundledExecutas = parseBundledExecutas((appJsonRaw && appJsonRaw["bundled_executas"]) ?? raw["bundled_executas"], metadataLabel);
+	return {
+		kind: "app",
+		path,
+		raw,
+		metadataPath,
+		metadataRaw,
+		cwd: resolve(cwd),
+		bundledExecutas,
+		slug,
+		name,
+		version,
+		category: pickMeta("category"),
+		tagline: pickMeta("tagline"),
+		description: pickMeta("description"),
+		changelog: pickMeta("changelog")
+	};
+}
+const HANDLE_RE = /^[a-z0-9][a-z0-9-]{0,62}$/;
+function parseBundledExecutas(value, label) {
+	if (value === void 0 || value === null) return [];
+	if (typeof value !== "object" || Array.isArray(value)) throw new CliError(`${label} \`bundled_executas\` must be an object mapping handle → { path }`, 4);
+	const out = [];
+	for (const [handle, decl] of Object.entries(value)) {
+		if (!HANDLE_RE.test(handle)) throw new CliError(`bundled_executas handle "${handle}" is invalid — must be kebab-case, ≤63 chars`, 4);
+		if (decl === null || typeof decl !== "object" || Array.isArray(decl)) throw new CliError(`bundled_executas["${handle}"] must be an object with a \`path\` field`, 4);
+		const p = pickString(decl, "path");
+		if (!p) throw new CliError(`bundled_executas["${handle}"] missing required \`path\``, 4);
+		out.push({
+			handle,
+			path: p
+		});
+	}
+	return out;
+}
+function loadExecutaManifest(cwd, manifestPath) {
+	const path = resolve(cwd, manifestPath ?? "executa.json");
+	if (!existsSync(path)) throw new CliError(`no executa.json at ${path}`, 4);
+	const raw = readJson(path);
+	const slug = pickString(raw, "slug");
+	const name = pickString(raw, "name") ?? slug ?? "";
+	const version = pickString(raw, "version") ?? "0.1.0";
+	const t = pickString(raw, "executa_type") ?? "tool";
+	if (t !== "tool" && t !== "skill") throw new CliError(`executa.json \`executa_type\` must be "tool" or "skill" (got "${t}")`, 4);
+	if (!slug) throw new CliError(`executa.json missing required \`slug\` (3-80 chars, kebab-case)`, 4);
+	if (!SLUG_RE.test(slug)) throw new CliError(`slug "${slug}" is not valid — must match ${SLUG_RE.source}`, 4);
+	if (!SEMVER_RE.test(version)) throw new CliError(`executa.json \`version\` "${version}" is not semver`, 4);
+	let skillContent;
+	if (t === "skill") {
+		const contentFile = pickString(raw, "content_file") ?? "SKILL.md";
+		const contentPath = resolve(cwd, contentFile);
+		if (!existsSync(contentPath)) throw new CliError(`skill executa.json references content file "${contentFile}" but ${contentPath} does not exist`, 4);
+		skillContent = readFileSync(contentPath, "utf-8");
+		if (!skillContent.trim()) throw new CliError(`skill content file "${contentFile}" is empty`, 4);
+	}
+	return {
+		kind: "executa",
+		path,
+		raw,
+		slug,
+		name,
+		version,
+		executa_type: t,
+		description: pickString(raw, "description") ?? void 0,
+		changelog: pickString(raw, "changelog") ?? void 0,
+		skillContent,
+		executionMode: pickString(raw, "execution_mode") ?? void 0,
+		distribution: parseExecutaDistribution(raw["distribution"], t)
+	};
+}
+/**
+* Parse + validate the optional `executa.json` `distribution` object.
+*
+* Returns `undefined` when absent (a dev-only Executa). Skills never carry
+* distribution config — they are declarative Markdown, not installable
+* processes — so a `distribution` block on a skill is rejected.
+*/
+function parseExecutaDistribution(value, executaType) {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "object" || Array.isArray(value)) throw new CliError("executa.json `distribution` must be an object with a `type` field", 4);
+	if (executaType === "skill") throw new CliError("executa.json `distribution` is only valid for `executa_type: \"tool\"` — skills are declarative Markdown and are not installed as a process", 4);
+	const d = value;
+	const type = pickString(d, "type");
+	if (!type) throw new CliError("executa.json `distribution.type` is required", 4);
+	if (!DISTRIBUTION_TYPES.has(type)) throw new CliError(`executa.json \`distribution.type\` "${type}" is invalid — expected one of ` + [...DISTRIBUTION_TYPES].join(" | "), 4);
+	const distType = type;
+	const packageName = pickString(d, "package_name");
+	const executableName = pickString(d, "executable_name");
+	const supportsProtocol = pickBool(d, "supports_protocol");
+	const binaryUrls = parseBinaryUrls(d["binary_urls"]);
+	const capabilities = parseCapabilities(d["capabilities"]);
+	if (PACKAGE_BACKED.has(distType) && !packageName) throw new CliError(`executa.json \`distribution.package_name\` is required for \`distribution.type: "${distType}"\``, 4);
+	if (distType === "binary" && (!binaryUrls || Object.keys(binaryUrls).length === 0)) throw new CliError("executa.json `distribution.binary_urls` is required (and non-empty) for `distribution.type: \"binary\"`", 4);
+	return {
+		type: distType,
+		packageName,
+		executableName,
+		supportsProtocol,
+		binaryUrls,
+		capabilities
+	};
+}
+function parseBinaryUrls(value) {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "object" || Array.isArray(value)) throw new CliError("executa.json `distribution.binary_urls` must be an object mapping platform → URL string or asset dict", 4);
+	const out = {};
+	for (const [platform, asset] of Object.entries(value)) {
+		if (typeof asset === "string") {
+			if (!asset.trim()) throw new CliError(`executa.json \`distribution.binary_urls["${platform}"]\` is empty`, 4);
+			out[platform] = asset;
+			continue;
+		}
+		if (asset && typeof asset === "object" && !Array.isArray(asset)) {
+			const url = pickString(asset, "url");
+			if (!url) throw new CliError(`executa.json \`distribution.binary_urls["${platform}"]\` asset dict missing required \`url\``, 4);
+			out[platform] = asset;
+			continue;
+		}
+		throw new CliError(`executa.json \`distribution.binary_urls["${platform}"]\` must be a URL string or an asset dict \`{ url, sha256?, size?, entrypoint?, format? }\``, 4);
+	}
+	return out;
+}
+function parseCapabilities(value) {
+	if (value === void 0 || value === null) return void 0;
+	if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) throw new CliError("executa.json `distribution.capabilities` must be an array of strings", 4);
+	return value;
+}
+function pickBool(o, k) {
+	const v = o[k];
+	return typeof v === "boolean" ? v : void 0;
+}
+function pickString(o, k) {
+	const v = o[k];
+	return typeof v === "string" ? v : void 0;
+}
+
+//#endregion
+export { loadAppManifest, loadExecutaManifest };