@anna-ai/cli 0.1.21 → 0.1.23

package/dist/{executa-publish-Ca5V7MyA.js → executa-publish-BKFq6Hz9.js}

@@ -2,7 +2,7 @@ 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 { loadExecutaManifest } from "./manifest-hXWnNFHE.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";

package/dist/{executa-publish-B88_9gbp.js → executa-publish-DaYvxbbW.js}

@@ -2,8 +2,8 @@ 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 { runExecutaPublish } from "./executa-publish-BKFq6Hz9.js";
+import "./manifest-hXWnNFHE.js";
 import "./_lifecycle-shared-sbea9HtH.js";
 
 export { runExecutaPublish };

package/dist/{manifest-DGwRap2i.js → manifest-hXWnNFHE.js}

@@ -124,23 +124,82 @@ function loadExecutaManifest(cwd, manifestPath) {
 * 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.
+*
+* Two shapes are accepted:
+*
+*   1. Flat (single mode) — the historical form:
+*
+*        "distribution": { "type": "binary", "binary_urls": { … } }
+*
+*   2. Multi-profile (switchable) — keep several modes side by side and flip
+*      `active` to choose which one is published:
+*
+*        "distribution": {
+*          "active": "binary",
+*          "profiles": {
+*            "local":  { "type": "local",  "executable_name": "…" },
+*            "binary": { "type": "binary", "binary_urls": { … } }
+*          }
+*        }
+*
+*      Every profile is validated (so a typo in an *inactive* profile is
+*      still caught), but the returned `ExecutaDistribution` carries the
+*      fields of the *active* profile plus `active`/`profiles` for
+*      introspection. Downstream publish code stays profile-agnostic.
 */
 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 (typeof value !== "object" || Array.isArray(value)) throw new CliError("executa.json `distribution` must be an object with a `type` field (or `profiles` for the switchable multi-mode form)", 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;
+	if (d["profiles"] !== void 0) return parseProfiledDistribution(d);
+	return parseDistributionProfile(d, "distribution");
+}
+/**
+* Resolve the multi-profile `distribution` form into the selected profile.
+* Validates *all* profiles and records them under `profiles`.
+*/
+function parseProfiledDistribution(d) {
+	if (d["type"] !== void 0) throw new CliError("executa.json `distribution` cannot set both `type` (flat form) and `profiles` (switchable form) — pick one", 4);
+	const profilesRaw = d["profiles"];
+	if (profilesRaw === null || typeof profilesRaw !== "object" || Array.isArray(profilesRaw)) throw new CliError("executa.json `distribution.profiles` must be an object mapping a profile name → distribution config", 4);
+	const profileEntries = Object.entries(profilesRaw);
+	if (profileEntries.length === 0) throw new CliError("executa.json `distribution.profiles` must declare at least one profile", 4);
+	const profiles = {};
+	for (const [pname, pval] of profileEntries) {
+		if (pval === null || typeof pval !== "object" || Array.isArray(pval)) throw new CliError(`executa.json \`distribution.profiles["${pname}"]\` must be an object`, 4);
+		profiles[pname] = parseDistributionProfile(pval, `distribution.profiles["${pname}"]`);
+	}
+	const active = pickString(d, "active");
+	let selected;
+	if (active !== void 0) {
+		if (!(active in profiles)) throw new CliError(`executa.json \`distribution.active\` "${active}" is not a declared profile — expected one of ${Object.keys(profiles).join(" | ")}`, 4);
+		selected = active;
+	} else if (profileEntries.length === 1) selected = profileEntries[0][0];
+	else throw new CliError(`executa.json \`distribution.active\` is required when more than one profile is declared — expected one of ${Object.keys(profiles).join(" | ")}`, 4);
+	const resolved = profiles[selected];
+	return {
+		...resolved,
+		active: selected,
+		profiles
+	};
+}
+/**
+* Parse + validate a single distribution config (one flat block or one entry
+* of a `profiles` map). `ctx` is the JSON path label used in error messages.
+*/
+function parseDistributionProfile(d, ctx) {
 	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);
+	if (!type) throw new CliError(`executa.json \`${ctx}.type\` is required`, 4);
+	if (!DISTRIBUTION_TYPES.has(type)) throw new CliError(`executa.json \`${ctx}.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);
+	const binaryUrls = parseBinaryUrls(d["binary_urls"], ctx);
+	const capabilities = parseCapabilities(d["capabilities"], ctx);
+	if (PACKAGE_BACKED.has(distType) && !packageName) throw new CliError(`executa.json \`${ctx}.package_name\` is required for \`${ctx}.type: "${distType}"\``, 4);
+	if (distType === "binary" && (!binaryUrls || Object.keys(binaryUrls).length === 0)) throw new CliError(`executa.json \`${ctx}.binary_urls\` is required (and non-empty) for \`${ctx}.type: "binary"\``, 4);
 	return {
 		type: distType,
 		packageName,
@@ -150,29 +209,29 @@ function parseExecutaDistribution(value, executaType) {
 		capabilities
 	};
 }
-function parseBinaryUrls(value) {
+function parseBinaryUrls(value, ctx = "distribution") {
 	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);
+	if (typeof value !== "object" || Array.isArray(value)) throw new CliError(`executa.json \`${ctx}.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);
+			if (!asset.trim()) throw new CliError(`executa.json \`${ctx}.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);
+			if (!url) throw new CliError(`executa.json \`${ctx}.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);
+		throw new CliError(`executa.json \`${ctx}.binary_urls["${platform}"]\` must be a URL string or an asset dict \`{ url, sha256?, size?, entrypoint?, format? }\``, 4);
 	}
 	return out;
 }
-function parseCapabilities(value) {
+function parseCapabilities(value, ctx = "distribution") {
 	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);
+	if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) throw new CliError(`executa.json \`${ctx}.capabilities\` must be an array of strings`, 4);
 	return value;
 }
 function pickBool(o, k) {

package/dist/{publish-C1wcf-qI.js → publish-R3JAl9Hm.js}

@@ -4,12 +4,12 @@ import { CliError } from "./client-Dn9zThOd.js";
 import "./bundled-executas-BNOKw4kv.js";
 import "./executas-Cep6KEo0.js";
 import "./executa-cache-BFoUtb4J.js";
-import { runExecutaPublish } from "./executa-publish-Ca5V7MyA.js";
-import "./manifest-DGwRap2i.js";
+import { runExecutaPublish } from "./executa-publish-BKFq6Hz9.js";
+import "./manifest-hXWnNFHE.js";
 import { withErrorHandling } from "./_lifecycle-shared-sbea9HtH.js";
-import "./app-cache-BEM653Th.js";
-import "./app-bundle-upload-DuLalcSt.js";
-import { runAppsPublish } from "./apps-publish-CaTCanDu.js";
+import "./app-cache-TcmbIIuL.js";
+import "./app-bundle-upload-Cd4ci4rB.js";
+import { runAppsPublish } from "./apps-publish-U_Y7svJw.js";
 import { resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { red, yellow } from "kleur/colors";

package/dist/{server-_IG8Igje.js → server-BzfmXVJD.js}

@@ -1,5 +1,5 @@
 import { canonicalHost, getAccount } from "./credentials-BTv2IfUZ.js";
-import { BridgeRequestError } from "./bridge-BuklhzeE.js";
+import { BridgeRequestError } from "./bridge-CBew_Ytl.js";
 import { dirname, join, normalize, resolve } from "node:path";
 import { createRequire } from "node:module";
 import { createReadStream, existsSync, readFileSync, statSync, watch } from "node:fs";

package/dist/{storage-CTkApNQ9.js → storage-BCj754in.js}

@@ -1,5 +1,5 @@
 import { canonicalHost } from "./credentials-BTv2IfUZ.js";
-import { hostOf, requireAccount, withCode } from "./dev-account-qRaET1Cp.js";
+import { hostOf, requireAccount, withCode } from "./dev-account-CD6hTr7M.js";
 import { resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 

package/dist/test/index.js

@@ -22,6 +22,9 @@ function deriveAcl(manifest) {
 		const bare = ref.includes(":") ? ref.split(":", 2)[1] : ref;
 		allowedTools.add(bare);
 	}
+	if (allowedTools.size === 0 && !toolsWildcard) {
+		for (const r of [...manifest.required_executas ?? [], ...manifest.optional_executas ?? []]) if (r.tool_id) allowedTools.add(r.tool_id);
+	}
 	if (allowedTools.size > 0 || toolsWildcard) allowed.add("tools.invoke");
 	for (const ns of Object.keys(NAMESPACED)) {
 		if (ns === "tools") continue;

package/dist/{working-orchestration-Dw9u1Vq0.js → working-orchestration-CIpQ_JMY.js}

@@ -2,10 +2,13 @@ import { canonicalHost } from "./credentials-BTv2IfUZ.js";
 import { createApp, findAppBySlug, getApp } from "./apps-B1Nd8l_t.js";
 import { CliError } from "./client-Dn9zThOd.js";
 import { parseExecutaIdOverrides, readExecutasLock, substituteBundledRefs, validateBundledHandles, writeBundleToolIdSidecar, writeExecutasLock } from "./bundled-executas-BNOKw4kv.js";
-import { runExecutaPublish } from "./executa-publish-Ca5V7MyA.js";
-import { appCacheMatches, readAppIdentity, writeAppIdentity } from "./app-cache-BEM653Th.js";
-import { resolve } from "node:path";
+import { runExecutaPublish } from "./executa-publish-BKFq6Hz9.js";
+import { loadExecutaManifest } from "./manifest-hXWnNFHE.js";
+import { runExecutaInstall } from "./executa-install-DnBG8UJA.js";
+import { appCacheMatches, readAppIdentity, writeAppIdentity } from "./app-cache-TcmbIIuL.js";
+import { join, resolve } from "node:path";
 import { dim, green, yellow } from "kleur/colors";
+import { homedir } from "node:os";
 
 //#region src/publish/working-orchestration.ts
 async function resolveBundledExecutas(params) {
@@ -104,6 +107,50 @@ async function resolveBundledExecutas(params) {
 	};
 }
 /**
+* Install a local-dev launcher shim for every bundled executa whose *active*
+* distribution profile is `local`, under its minted `tool_id`. This closes
+* the manual gap after `apps push`: a `local` executa never triggers a server
+* `install_plugin` RPC, so the only way it turns "Running" on an Agent is the
+* **Rediscover Local** flow — which needs an on-disk shim named exactly the
+* minted `tool_id`. Binary/uv/npm/etc. profiles are skipped (the Agent
+* installs those itself), as are skills (no runtime process) and dev-only
+* executas with no distribution block.
+*
+* Failures are non-fatal: a shim that can't be written warns but does not
+* fail the surrounding `apps push`.
+*/
+async function installLocalBundledShims(params) {
+	const { manifest, cwd, resolved, json = false } = params;
+	const binDir = params.binDir ?? join(homedir(), ".anna", "executa", "bin");
+	const installed = [];
+	for (const decl of manifest.bundledExecutas) {
+		const toolId = resolved[decl.handle];
+		if (!toolId) continue;
+		const dir = resolve(cwd, decl.path);
+		let exManifest;
+		try {
+			exManifest = loadExecutaManifest(dir);
+		} catch {
+			continue;
+		}
+		if (exManifest.distribution?.type !== "local") continue;
+		const code = await runExecutaInstall({
+			dir,
+			toolId,
+			binDir: params.binDir,
+			force: true,
+			quiet: true
+		});
+		if (code === 0) installed.push({
+			handle: decl.handle,
+			tool_id: toolId,
+			shim_path: join(binDir, toolId)
+		});
+		else if (!json) console.log(yellow(`  ! could not install local dev shim for "${decl.handle}" (exit ${code})`));
+	}
+	return installed;
+}
+/**
 * Resolve (creating if absent) the `AnnaApp` row, persisting the identity
 * cache before any subsequent network call. Returns `null` only in dry-run
 * mode when the app does not exist yet (nothing to create).
@@ -187,4 +234,4 @@ async function resolveAppBySlugOrCache(client, host, opts) {
 }
 
 //#endregion
-export { resolveAppBySlugOrCache, resolveAppIdentity, resolveBundledExecutas };
+export { installLocalBundledShims, resolveAppBySlugOrCache, resolveAppIdentity, resolveBundledExecutas };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anna-ai/cli",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Anna App developer CLI: scaffold, validate, harness (Phase 2 MVP: init + validate).",
   "license": "MIT",
   "type": "module",

package/templates/executa/go/main.go

@@ -33,8 +33,10 @@ type rpcError struct {
 }
 
 var (
+	// The manifest no longer declares a top-level `name`; the plugin's
+	// identity is the server-assigned tool_id (resolved from the on-disk
+	// shim name), not a self-declared manifest name.
 	manifest = map[string]any{
-		"name":              "__TOOL_ID__",
 		"display_name":      "__TOOL_ID__",
 		"version":           "0.1.0",
 		"description":       "A minimal Go Executa plugin scaffold.",
@@ -85,7 +87,7 @@ func dispatch(e envelope) {
 	case "initialize":
 		result = map[string]any{
 			"protocolVersion": "2.0",
-			"server_info":     map[string]any{"name": manifest["name"], "version": manifest["version"]},
+			"server_info":     map[string]any{"name": manifest["display_name"], "version": manifest["version"]},
 			"capabilities":    map[string]any{"sampling": map[string]any{}},
 		}
 	case "describe":

package/templates/executa/node/plugin.mjs

@@ -12,7 +12,9 @@ import { randomUUID } from "node:crypto";
 import process from "node:process";
 
 const MANIFEST = {
-  name: "__TOOL_ID__",
+  // The manifest no longer declares a top-level `name`; the plugin's
+  // identity is the server-assigned tool_id (resolved from the on-disk
+  // shim name), not a self-declared manifest name.
   display_name: "__TOOL_ID__",
   version: "0.1.0",
   description: "A minimal Node.js Executa plugin scaffold.",
@@ -77,7 +79,7 @@ async function dispatch(env) {
     if (method === "initialize") {
       result = {
         protocolVersion: "2.0",
-        server_info: { name: MANIFEST.name, version: MANIFEST.version },
+        server_info: { name: MANIFEST.display_name, version: MANIFEST.version },
         capabilities: { sampling: {} },
       };
     } else if (method === "describe") {

package/templates/executa/python/__SLUG_PY___plugin.py

@@ -18,7 +18,9 @@ import uuid
 from typing import Any
 
 MANIFEST: dict[str, Any] = {
-    "name": "__TOOL_ID__",
+    # The manifest no longer declares a top-level `name`; the plugin's
+    # identity is the server-assigned tool_id (resolved from the on-disk
+    # shim name), not a self-declared manifest name.
     "display_name": "__TOOL_ID__",
     "version": "0.1.0",
     "description": "A minimal Executa plugin scaffold.",
@@ -111,7 +113,7 @@ def _dispatch(env: dict[str, Any]) -> None:
         if method == "initialize":
             result = {
                 "protocolVersion": "2.0",
-                "server_info": {"name": MANIFEST["name"], "version": MANIFEST["version"]},
+                "server_info": {"name": MANIFEST["display_name"], "version": MANIFEST["version"]},
                 "capabilities": {"sampling": {}},
             }
         elif method == "describe":

package/dist/bridge-Id8K8gr-.js

@@ -1,3 +0,0 @@
-import { BridgeRequestError, PINNED_RUNTIME_VERSION, PythonBridge } from "./bridge-BuklhzeE.js";
-
-export { PINNED_RUNTIME_VERSION, PythonBridge };

package/dist/dev-BS_8yoSm.js

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