@anna-ai/cli 0.1.19 → 0.1.22

package/dist/apps-cut-DtEkddIk.js

@@ -0,0 +1,83 @@
+import { canonicalHost } from "./credentials-BTv2IfUZ.js";
+import { cutWorkingDraft } from "./apps-B1Nd8l_t.js";
+import { CliError } from "./client-Dn9zThOd.js";
+import { readExecutasLock, writeExecutasLock } from "./bundled-executas-BNOKw4kv.js";
+import "./executas-Cep6KEo0.js";
+import "./executa-cache-BFoUtb4J.js";
+import "./executa-publish-Ca5V7MyA.js";
+import "./manifest-DGwRap2i.js";
+import { resolveClient, withErrorHandling } from "./_lifecycle-shared-sbea9HtH.js";
+import "./app-cache-BEM653Th.js";
+import { resolveAppBySlugOrCache } from "./working-orchestration-Dw9u1Vq0.js";
+import { resolve } from "node:path";
+import { bold, cyan, dim, green, yellow } from "kleur/colors";
+
+//#region src/commands/apps-cut.ts
+async function runAppsCut(opts) {
+	return withErrorHandling(async () => {
+		const { client, host } = resolveClient({ account: opts.account });
+		const app = await resolveAppBySlugOrCache(client, host, {
+			slug: opts.slug,
+			cwd: opts.cwd
+		});
+		if (opts.dryRun) {
+			if (!opts.json) console.log(yellow(`[dry-run] would cut version ${opts.version} for apps/${app.slug} (app_id=${app.id})`));
+			return 0;
+		}
+		let result;
+		try {
+			result = await cutWorkingDraft(client, app.id, {
+				version: opts.version,
+				changelog: opts.changelog
+			});
+		} catch (e) {
+			if (e instanceof CliError && e.status === 409) throw new CliError(`version ${opts.version} already cut for apps/${app.slug}; choose a higher SemVer (e.g. bump patch/minor) and retry`, 9);
+			if (e instanceof CliError && (e.status === 400 || e.status === 422)) throw new CliError(`cannot cut: ${e.message} — fix the working draft and \`apps push\` again`, 4);
+			throw e;
+		}
+		if (result.frozen_executas.length > 0) {
+			const cwd = resolve(opts.cwd ?? process.cwd());
+			const lock = readExecutasLock(cwd, host);
+			if (lock) {
+				const byToolId = new Map(Object.entries(lock.executas).map(([h, e]) => [e.tool_id, h]));
+				for (const fr of result.frozen_executas) {
+					const handle = byToolId.get(fr.tool_id);
+					if (handle && lock.executas[handle]) lock.executas[handle] = {
+						...lock.executas[handle],
+						tool_id: fr.tool_id,
+						source: "cut"
+					};
+				}
+				writeExecutasLock(cwd, {
+					$schema: "anna-executas-lock/v1",
+					host: canonicalHost(host),
+					executas: lock.executas
+				});
+			}
+		}
+		if (opts.json) {
+			console.log(JSON.stringify({
+				app_id: app.id,
+				slug: app.slug,
+				host,
+				version_id: result.version_id,
+				version: result.version,
+				frozen_executas: result.frozen_executas,
+				bundle: result.bundle
+			}, null, 2));
+			return 0;
+		}
+		console.log(green(`✓ apps/${app.slug}: cut immutable version ${result.version} `) + dim(`(version_id=${result.version_id})`));
+		for (const fr of result.frozen_executas) console.log(dim(`  froze ${fr.tool_id} → executa_version=${fr.executa_version_id}`) + (fr.version ? dim(` (v${fr.version})`) : ""));
+		if (result.bundle && typeof result.bundle === "object") {
+			const prefix = result.bundle.object_prefix;
+			if (prefix) console.log(dim(`  bundle frozen at ${prefix}`));
+		}
+		console.log(dim(`→ run `) + cyan(`anna-app apps release ${result.version}`) + dim(` to go live`));
+		console.log(bold(cyan(`status: ${app.status}`)));
+		return 0;
+	});
+}
+
+//#endregion
+export { runAppsCut };

package/dist/apps-destructive-DSTrcFUP.js

@@ -0,0 +1,104 @@
+import "./credentials-BTv2IfUZ.js";
+import { archiveApp, deleteApp, findAppBySlug, unarchiveApp, unpublishApp } from "./apps-B1Nd8l_t.js";
+import { CliError } from "./client-Dn9zThOd.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/apps-destructive.ts
+async function resolveAppId(account, slug) {
+	const { client, host } = resolveClient({ account });
+	const app = await findAppBySlug(client, slug);
+	if (!app) throw new CliError(`no app with slug "${slug}" on ${host}`, 5);
+	return {
+		client,
+		host,
+		appId: app.id,
+		serverSlug: app.slug
+	};
+}
+async function runAppsUnpublish(opts) {
+	return withErrorHandling(async () => {
+		await ensureDestructiveAllowed({
+			verb: "apps unpublish",
+			...opts
+		});
+		const { client, host, appId, serverSlug } = await resolveAppId(opts.account, opts.slug);
+		const updated = await unpublishApp(client, appId);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				app_id: appId,
+				slug: serverSlug,
+				status: updated.status
+			}, null, 2));
+			return 0;
+		}
+		console.log(green(`✓ apps/${serverSlug}: unpublished (status=${updated.status})`));
+		return 0;
+	});
+}
+async function runAppsArchive(opts) {
+	return withErrorHandling(async () => {
+		await ensureDestructiveAllowed({
+			verb: "apps archive",
+			...opts
+		});
+		const { client, host, appId, serverSlug } = await resolveAppId(opts.account, opts.slug);
+		const updated = await archiveApp(client, appId);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				app_id: appId,
+				slug: serverSlug,
+				status: updated.status
+			}, null, 2));
+			return 0;
+		}
+		console.log(yellow(`✓ apps/${serverSlug}: archived (status=${updated.status})`));
+		return 0;
+	});
+}
+async function runAppsUnarchive(opts) {
+	return withErrorHandling(async () => {
+		if (!opts.yes) throw new CliError(`\`apps unarchive\` refused: pass --yes to acknowledge`, 7);
+		const { client, host, appId, serverSlug } = await resolveAppId(opts.account, opts.slug);
+		const updated = await unarchiveApp(client, appId);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				app_id: appId,
+				slug: serverSlug,
+				status: updated.status
+			}, null, 2));
+			return 0;
+		}
+		console.log(green(`✓ apps/${serverSlug}: unarchived (status=${updated.status})`));
+		return 0;
+	});
+}
+async function runAppsDelete(opts) {
+	return withErrorHandling(async () => {
+		await ensureDestructiveAllowed({
+			verb: "apps delete",
+			...opts
+		});
+		const { client, host, appId, serverSlug } = await resolveAppId(opts.account, opts.slug);
+		await deleteApp(client, appId);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				app_id: appId,
+				slug: serverSlug,
+				deleted: true
+			}, null, 2));
+			return 0;
+		}
+		console.log(yellow(`✓ apps/${serverSlug}: deleted`));
+		console.log(dim(`  (local .anna/app.json may now be stale; remove it manually if you no longer need it)`));
+		return 0;
+	});
+}
+
+//#endregion
+export { runAppsArchive, runAppsDelete, runAppsUnarchive, runAppsUnpublish };

package/dist/apps-discard-y3_IwcbQ.js

@@ -0,0 +1,44 @@
+import "./credentials-BTv2IfUZ.js";
+import { deleteWorkingDraft, getWorkingDraft } from "./apps-B1Nd8l_t.js";
+import "./client-Dn9zThOd.js";
+import "./bundled-executas-BNOKw4kv.js";
+import "./executas-Cep6KEo0.js";
+import "./executa-cache-BFoUtb4J.js";
+import "./executa-publish-Ca5V7MyA.js";
+import "./manifest-DGwRap2i.js";
+import { resolveClient, withErrorHandling } from "./_lifecycle-shared-sbea9HtH.js";
+import "./app-cache-BEM653Th.js";
+import { resolveAppBySlugOrCache } from "./working-orchestration-Dw9u1Vq0.js";
+import { dim, green, yellow } from "kleur/colors";
+
+//#region src/commands/apps-discard.ts
+async function runAppsDiscard(opts) {
+	return withErrorHandling(async () => {
+		const { client, host } = resolveClient({ account: opts.account });
+		const app = await resolveAppBySlugOrCache(client, host, {
+			slug: opts.slug,
+			cwd: opts.cwd
+		});
+		const existing = await getWorkingDraft(client, app.id);
+		if (opts.dryRun) {
+			if (!opts.json) console.log(yellow(existing ? `[dry-run] would discard working draft (rev ${existing.revision}) for apps/${app.slug}` : `[dry-run] no working draft for apps/${app.slug} (nothing to discard)`));
+			return 0;
+		}
+		await deleteWorkingDraft(client, app.id);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				app_id: app.id,
+				slug: app.slug,
+				host,
+				discarded: existing !== null
+			}, null, 2));
+			return 0;
+		}
+		if (existing) console.log(green(`✓ apps/${app.slug}: discarded working draft `) + dim(`(was rev ${existing.revision})`));
+		else console.log(dim(`apps/${app.slug}: no working draft — nothing to discard`));
+		return 0;
+	});
+}
+
+//#endregion
+export { runAppsDiscard };

package/dist/apps-grants-BGWlpee0.js

@@ -0,0 +1,34 @@
+import "./credentials-BTv2IfUZ.js";
+import { findAppBySlug, getAppGrants } from "./apps-B1Nd8l_t.js";
+import { CliError } from "./client-Dn9zThOd.js";
+import { resolveClient, withErrorHandling } from "./_lifecycle-shared-sbea9HtH.js";
+import { bold, cyan, dim } from "kleur/colors";
+
+//#region src/commands/apps-grants.ts
+async function runAppsGrants(opts) {
+	return withErrorHandling(async () => {
+		const { client, host } = resolveClient({ account: opts.account });
+		const app = await findAppBySlug(client, opts.slug);
+		if (!app) throw new CliError(`no app with slug "${opts.slug}" on ${host}`, 5);
+		const grants = await getAppGrants(client, app.id);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				app_id: app.id,
+				slug: app.slug,
+				grants
+			}, null, 2));
+			return 0;
+		}
+		console.log(bold(cyan(`apps/${app.slug}`)) + " " + dim(`grants`));
+		if (!grants) {
+			console.log(dim("  (no grants endpoint data available)"));
+			return 0;
+		}
+		console.log(JSON.stringify(grants, null, 2));
+		return 0;
+	});
+}
+
+//#endregion
+export { runAppsGrants };

package/dist/apps-publish-CaTCanDu.js

@@ -0,0 +1,265 @@
+import { canonicalHost } from "./credentials-BTv2IfUZ.js";
+import { createApp, createVersion, 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 { bumpVersion, bundleHash, manifestHash, rewriteVersion, runExecutaPublish } from "./executa-publish-Ca5V7MyA.js";
+import { loadAppManifest } from "./manifest-DGwRap2i.js";
+import { resolveClient, withErrorHandling } from "./_lifecycle-shared-sbea9HtH.js";
+import { appCacheMatches, readAppIdentity, writeAppIdentity } from "./app-cache-BEM653Th.js";
+import { isExistingDir, uploadAppBundle } from "./app-bundle-upload-DuLalcSt.js";
+import { resolve } from "node:path";
+import { bold, cyan, dim, green, yellow } from "kleur/colors";
+
+//#region src/commands/apps-publish.ts
+async function runAppsPublish(opts) {
+	return withErrorHandling(async () => {
+		const cwd = resolve(opts.cwd ?? process.cwd());
+		const manifest = loadAppManifest(cwd, opts.manifest);
+		const { client, host, source } = resolveClient({ account: opts.account });
+		if (!opts.json) {
+			console.log(dim(`using PAT from ${source} (host=${host})`));
+			console.log(yellow("⚠ `apps publish` mints an immutable version directly. The Option-C working-draft flow is now preferred:"));
+			console.log(dim("    anna-app apps push            ") + dim("# upsert the mutable working draft (safe every commit)"));
+			console.log(dim("    anna-app apps cut <version>   ") + dim("# snapshot + freeze executa deps"));
+		}
+		if (opts.bump) {
+			const next = bumpVersion(manifest.version, opts.bump);
+			if (!opts.json) console.log(yellow(`↑ bumping manifest.version: ${manifest.version} → ${next}`));
+			if (!opts.noWrite && !opts.dryRun) rewriteVersion(manifest.metadataPath, manifest.metadataRaw, next);
+			manifest.version = next;
+			manifest.metadataRaw.version = next;
+			if (manifest.metadataRaw !== manifest.raw && "version" in manifest.raw) manifest.raw.version = next;
+		}
+		const overrides = parseExecutaIdOverrides(opts.executaId);
+		const bundledActive = !opts.noBundledExecutas && (manifest.bundledExecutas.length > 0 || overrides.length > 0);
+		let publishManifestRaw = manifest.raw;
+		if (bundledActive) {
+			const { referenced } = validateBundledHandles(manifest.raw, manifest.bundledExecutas, overrides);
+			const overrideMap = new Map(overrides.map((o) => [o.handle, o.toolId]));
+			const lock = readExecutasLock(cwd, host);
+			const resolved = {};
+			const lockEntries = {};
+			for (const decl of manifest.bundledExecutas) {
+				if (overrideMap.has(decl.handle)) {
+					const id = overrideMap.get(decl.handle);
+					resolved[decl.handle] = id;
+					lockEntries[decl.handle] = {
+						tool_id: id,
+						path: decl.path,
+						source: "override"
+					};
+					if (!opts.json) console.log(dim(`  bundled:${decl.handle} → ${id} (override)`));
+					continue;
+				}
+				if (opts.skipExecutaPublish) {
+					const cachedId = lock?.executas[decl.handle]?.tool_id;
+					if (!cachedId) throw new CliError(`--skip-executa-publish set but no cached tool_id for "${decl.handle}" in .anna/executas.lock.json (run without --skip-executa-publish first, or pass --executa-id ${decl.handle}=<tool-id>)`, 4);
+					resolved[decl.handle] = cachedId;
+					lockEntries[decl.handle] = {
+						tool_id: cachedId,
+						path: decl.path,
+						source: "cache"
+					};
+					if (!opts.json) console.log(dim(`  bundled:${decl.handle} → ${cachedId} (cache)`));
+					continue;
+				}
+				const execCwd = resolve(cwd, decl.path);
+				if (opts.dryRun) {
+					if (!opts.json) console.log(yellow(`  [dry-run] would publish bundled executa "${decl.handle}" from ${decl.path}`));
+					continue;
+				}
+				if (!opts.json) console.log(dim(`  publishing bundled executa "${decl.handle}" (${decl.path})…`));
+				let captured;
+				const code = await runExecutaPublish({
+					cwd: execCwd,
+					account: opts.account,
+					quiet: true,
+					capture: (r) => {
+						captured = r;
+					}
+				});
+				if (code !== 0 || !captured) throw new CliError(`failed to publish bundled executa "${decl.handle}" (${decl.path})`, code === 0 ? 4 : code);
+				resolved[decl.handle] = captured.tool_id;
+				lockEntries[decl.handle] = {
+					tool_id: captured.tool_id,
+					path: decl.path,
+					source: "published"
+				};
+				if (!opts.json) console.log(green(`  ✓ bundled:${decl.handle} → ${captured.tool_id}`) + dim(` (v${captured.version}${captured.idempotent_hit ? ", unchanged" : ""})`));
+			}
+			for (const o of overrides) if (!(o.handle in resolved)) {
+				resolved[o.handle] = o.toolId;
+				lockEntries[o.handle] = {
+					tool_id: o.toolId,
+					source: "override"
+				};
+				if (!opts.json) console.log(dim(`  bundled:${o.handle} → ${o.toolId} (override)`));
+			}
+			const missing = [...referenced].filter((h) => !(h in resolved));
+			if (missing.length > 0 && !opts.dryRun) throw new CliError(`could not resolve bundled handle(s): ${missing.sort().join(", ")}`, 4);
+			if (!opts.dryRun) {
+				const merged = {
+					$schema: "anna-executas-lock/v1",
+					host: canonicalHost(host),
+					executas: {
+						...lock?.executas ?? {},
+						...lockEntries
+					}
+				};
+				writeExecutasLock(cwd, merged);
+				publishManifestRaw = substituteBundledRefs(manifest.raw, resolved);
+				const bundleEntry = manifest.raw.ui?.bundle?.entry;
+				if (bundleEntry) {
+					const bundleDir$1 = resolve(cwd, "bundle");
+					if (Object.keys(resolved).length > 0) {
+						const sidecar = writeBundleToolIdSidecar(bundleDir$1, resolved);
+						if (!opts.json) console.log(dim(`  wrote ${sidecar.replace(cwd + "/", "")}`));
+					}
+				}
+			}
+		}
+		let cached = readAppIdentity(cwd);
+		if (cached && cached.host !== canonicalHost(host)) cached = null;
+		let appId;
+		let serverSlug;
+		let firstPublish = false;
+		let appIdFromCache = false;
+		if (cached && appCacheMatches(cached, host, manifest.slug)) {
+			appId = cached.app_id;
+			serverSlug = cached.slug;
+			appIdFromCache = true;
+		} else {
+			const found = await findAppBySlug(client, manifest.slug);
+			if (found) {
+				appId = found.id;
+				serverSlug = found.slug;
+			} else {
+				if (opts.dryRun) {
+					if (!opts.json) console.log(yellow(`[dry-run] would create AnnaApp slug=${manifest.slug}, then upload version ${manifest.version}`));
+					return 0;
+				}
+				const created = await createApp(client, {
+					slug: manifest.slug,
+					name: manifest.name,
+					category: manifest.category,
+					tagline: manifest.tagline,
+					description: manifest.description
+				});
+				appId = created.id;
+				serverSlug = created.slug;
+				firstPublish = true;
+			}
+			writeAppIdentity(cwd, {
+				$schema: "anna-app-identity/v1",
+				host: canonicalHost(host),
+				app_id: appId,
+				slug: serverSlug,
+				first_published_at: cached?.first_published_at ?? new Date().toISOString()
+			});
+		}
+		if (opts.dryRun) {
+			if (!opts.json) {
+				console.log(yellow(`[dry-run] resolved app_id=${appId} slug=${serverSlug}; would POST version ${manifest.version}`));
+				const uiEntry = publishManifestRaw.ui?.bundle?.entry;
+				const dryBundleDir = resolve(cwd, opts.bundleDir ?? "bundle");
+				if (uiEntry && !opts.noBundle && isExistingDir(dryBundleDir)) console.log(yellow(`[dry-run] would upload UI bundle from ${dryBundleDir} (entry=${uiEntry})`));
+			}
+			return 0;
+		}
+		const hashInput = {
+			version: manifest.version,
+			manifest: publishManifestRaw
+		};
+		const hashBundleEntry = publishManifestRaw.ui?.bundle?.entry;
+		const hashBundleDir = resolve(cwd, opts.bundleDir ?? "bundle");
+		const hash = hashBundleEntry && !opts.noBundle && isExistingDir(hashBundleDir) ? bundleHash(hashInput, hashBundleDir) : manifestHash(hashInput);
+		let verResp;
+		try {
+			verResp = await createVersion(client, appId, {
+				version: manifest.version,
+				changelog: manifest.changelog,
+				manifest: publishManifestRaw
+			}, hash);
+		} catch (e) {
+			if (appIdFromCache && e instanceof CliError && e.status === 404) {
+				if (!opts.json) console.log(yellow(`\u26a0 cached app_id=${appId} not found on server (deleted?); re-resolving identity and retrying\u2026`));
+				const found = await findAppBySlug(client, manifest.slug);
+				if (found) {
+					appId = found.id;
+					serverSlug = found.slug;
+				} else {
+					const created = await createApp(client, {
+						slug: manifest.slug,
+						name: manifest.name,
+						category: manifest.category,
+						tagline: manifest.tagline,
+						description: manifest.description
+					});
+					appId = created.id;
+					serverSlug = created.slug;
+					firstPublish = true;
+				}
+				writeAppIdentity(cwd, {
+					$schema: "anna-app-identity/v1",
+					host: canonicalHost(host),
+					app_id: appId,
+					slug: serverSlug,
+					first_published_at: cached?.first_published_at ?? new Date().toISOString()
+				});
+				verResp = await createVersion(client, appId, {
+					version: manifest.version,
+					changelog: manifest.changelog,
+					manifest: publishManifestRaw
+				}, hash);
+			} else throw e;
+		}
+		let bundleResult = null;
+		const uiBundle = publishManifestRaw.ui?.bundle;
+		const bundleDir = resolve(cwd, opts.bundleDir ?? "bundle");
+		if (uiBundle?.entry && !opts.noBundle) if (!isExistingDir(bundleDir)) {
+			if (!opts.json) console.log(yellow(`⚠ manifest declares ui.bundle.entry="${uiBundle.entry}" but bundle dir not found (${bundleDir}); skipping UI bundle upload`));
+		} else bundleResult = await uploadAppBundle({
+			client,
+			appId,
+			versionId: verResp.version.id,
+			bundleDir,
+			entryPath: uiBundle.entry,
+			bundleFormat: uiBundle.format,
+			externalOrigins: Array.isArray(uiBundle.external_origins) ? uiBundle.external_origins : [],
+			log: opts.json ? void 0 : (m) => console.log(dim(m))
+		});
+		const finalApp = await getApp(client, appId);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				app_id: appId,
+				slug: serverSlug,
+				host,
+				version: verResp.version.version,
+				version_id: verResp.version.id,
+				content_hash: hash,
+				idempotent_hit: verResp.idempotentHit,
+				first_publish: firstPublish,
+				status: finalApp.status,
+				bundle: bundleResult ? {
+					status: bundleResult.status,
+					bundle_status: bundleResult.detail.status,
+					file_count: bundleResult.detail.file_count,
+					total_size_bytes: bundleResult.detail.total_size_bytes,
+					sha256_manifest: bundleResult.detail.sha256_manifest
+				} : null
+			}, null, 2));
+			return 0;
+		}
+		if (verResp.idempotentHit) console.log(green(`✓ apps/${serverSlug}: version ${manifest.version} already live (content hash unchanged)`));
+		else console.log(green(`✓ apps/${serverSlug}: version ${manifest.version} published (id=${verResp.version.id})`));
+		if (firstPublish) console.log(dim(`  first publish — wrote .anna/app.json`));
+		if (bundleResult) if (bundleResult.status === "skipped") console.log(dim(`  UI bundle unchanged — skipped`));
+		else console.log(green(`  ✓ UI bundle: ${bundleResult.fileCount} files, ${(bundleResult.totalBytes / 1024).toFixed(1)} KB → ${bundleResult.detail.status}`));
+		console.log(bold(cyan(`status: ${finalApp.status}`)));
+		if (!verResp.idempotentHit) console.log(dim(`→ run `) + cyan(`anna-app apps release ${manifest.version}`) + dim(` to freeze & publish this version`));
+		return 0;
+	});
+}
+
+//#endregion
+export { runAppsPublish };

package/dist/apps-publish-DfZTOxBJ.js

@@ -0,0 +1,14 @@
+import "./credentials-BTv2IfUZ.js";
+import "./apps-B1Nd8l_t.js";
+import "./client-Dn9zThOd.js";
+import "./bundled-executas-BNOKw4kv.js";
+import "./executas-Cep6KEo0.js";
+import "./executa-cache-BFoUtb4J.js";
+import "./executa-publish-Ca5V7MyA.js";
+import "./manifest-DGwRap2i.js";
+import "./_lifecycle-shared-sbea9HtH.js";
+import "./app-cache-BEM653Th.js";
+import "./app-bundle-upload-DuLalcSt.js";
+import { runAppsPublish } from "./apps-publish-CaTCanDu.js";
+
+export { runAppsPublish };

package/dist/apps-push-B9XT2uwF.js

@@ -0,0 +1,127 @@
+import "./credentials-BTv2IfUZ.js";
+import { getApp, getWorkingDraft, upsertWorkingDraft } from "./apps-B1Nd8l_t.js";
+import { CliError } from "./client-Dn9zThOd.js";
+import "./bundled-executas-BNOKw4kv.js";
+import "./executas-Cep6KEo0.js";
+import "./executa-cache-BFoUtb4J.js";
+import { bumpVersion, bundleHash, manifestHash, rewriteVersion } from "./executa-publish-Ca5V7MyA.js";
+import { loadAppManifest } from "./manifest-DGwRap2i.js";
+import { resolveClient, withErrorHandling } from "./_lifecycle-shared-sbea9HtH.js";
+import "./app-cache-BEM653Th.js";
+import { resolveAppIdentity, resolveBundledExecutas } from "./working-orchestration-Dw9u1Vq0.js";
+import { isExistingDir, uploadWorkingBundle } from "./app-bundle-upload-DuLalcSt.js";
+import { resolve } from "node:path";
+import { bold, cyan, dim, green, yellow } from "kleur/colors";
+
+//#region src/commands/apps-push.ts
+async function runAppsPush(opts) {
+	return withErrorHandling(async () => {
+		const cwd = resolve(opts.cwd ?? process.cwd());
+		const manifest = loadAppManifest(cwd, opts.manifest);
+		const { client, host, source } = resolveClient({ account: opts.account });
+		if (!opts.json) console.log(dim(`using PAT from ${source} (host=${host})`));
+		if (opts.bump) {
+			const next = bumpVersion(manifest.version, opts.bump);
+			if (!opts.json) console.log(yellow(`↑ bumping manifest.version: ${manifest.version} → ${next}`));
+			if (!opts.noWrite && !opts.dryRun) rewriteVersion(manifest.metadataPath, manifest.metadataRaw, next);
+			manifest.version = next;
+			manifest.metadataRaw.version = next;
+		}
+		const { publishManifestRaw } = await resolveBundledExecutas({
+			manifest,
+			cwd,
+			host,
+			executaId: opts.executaId,
+			skipExecutaPublish: opts.skipExecutaPublish,
+			noBundledExecutas: opts.noBundledExecutas,
+			dryRun: opts.dryRun,
+			freeze: false,
+			lockSource: "working",
+			account: opts.account,
+			json: opts.json
+		});
+		const identity = await resolveAppIdentity({
+			client,
+			cwd,
+			host,
+			manifest,
+			dryRun: opts.dryRun,
+			json: opts.json
+		});
+		if (!identity) return 0;
+		const { appId, serverSlug, firstPublish } = identity;
+		const hashInput = {
+			version: manifest.version,
+			manifest: publishManifestRaw
+		};
+		const bundleEntry = publishManifestRaw.ui?.bundle?.entry;
+		const bundleDir = resolve(cwd, opts.bundleDir ?? "bundle");
+		const hasBundle = !!bundleEntry && !opts.noBundle && isExistingDir(bundleDir);
+		const hash = hasBundle ? bundleHash(hashInput, bundleDir) : manifestHash(hashInput);
+		if (opts.dryRun) {
+			if (!opts.json) console.log(yellow(`[dry-run] app_id=${appId} slug=${serverSlug}; would PUT /working (content_hash=${hash.slice(0, 12)}…)` + (hasBundle ? ` + stage working bundle from ${bundleDir}` : "")));
+			return 0;
+		}
+		let resp;
+		try {
+			resp = await upsertWorkingDraft(client, appId, {
+				manifest: publishManifestRaw,
+				changelog: manifest.changelog,
+				content_hash: hash
+			}, opts.ifMatch);
+		} catch (e) {
+			if (e instanceof CliError && e.status === 409) throw new CliError(`working draft was modified concurrently (If-Match=${opts.ifMatch} is stale); re-run \`apps push\` without --if-match for last-writer-wins, or fetch the current revision with \`apps status\``, 4);
+			throw e;
+		}
+		let bundleResult = null;
+		if (hasBundle) {
+			const uiBundle = publishManifestRaw.ui.bundle;
+			const skipStage = resp.unchanged && resp.bundle_status === "ready";
+			if (!skipStage) bundleResult = await uploadWorkingBundle({
+				client,
+				appId,
+				bundleDir,
+				entryPath: uiBundle.entry,
+				bundleFormat: uiBundle.format,
+				externalOrigins: Array.isArray(uiBundle.external_origins) ? uiBundle.external_origins : [],
+				log: opts.json ? void 0 : (m) => console.log(dim(m))
+			});
+		}
+		const finalApp = await getApp(client, appId);
+		const draft = await getWorkingDraft(client, appId);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				app_id: appId,
+				slug: serverSlug,
+				host,
+				revision: resp.revision,
+				content_hash: resp.content_hash,
+				unchanged: resp.unchanged,
+				bundle_status: resp.bundle_status,
+				first_publish: firstPublish,
+				status: finalApp.status,
+				dirty_vs_latest_cut: draft?.dirty_vs_latest_cut ?? null,
+				bundle: bundleResult ? {
+					status: bundleResult.status,
+					file_count: bundleResult.fileCount,
+					total_size_bytes: bundleResult.totalBytes,
+					bundle_status: bundleResult.bundleStatus
+				} : null
+			}, null, 2));
+			return 0;
+		}
+		if (resp.unchanged) console.log(green(`✓ apps/${serverSlug}: working draft unchanged (rev ${resp.revision})`));
+		else console.log(green(`✓ apps/${serverSlug}: working draft updated (rev ${resp.revision})`));
+		if (firstPublish) console.log(dim(`  first push — wrote .anna/app.json`));
+		if (bundleResult) if (bundleResult.status === "skipped") console.log(dim(`  working bundle unchanged — skipped`));
+		else console.log(green(`  ✓ working bundle: ${bundleResult.fileCount} files, ${(bundleResult.totalBytes / 1024).toFixed(1)} KB → ${bundleResult.bundleStatus}`));
+		console.log(bold(cyan(`status: ${finalApp.status}`)));
+		if (draft?.dirty_vs_latest_cut) console.log(dim(`  (uncommitted changes vs latest cut version)`));
+		console.log(dim(`→ install & test the draft (reserved `) + cyan(`0.0.0-draft`) + dim(`) from the Developer Console`));
+		console.log(dim(`→ run `) + cyan(`anna-app apps cut ${manifest.version}`) + dim(` to snapshot an immutable version`));
+		return 0;
+	});
+}
+
+//#endregion
+export { runAppsPush };