@anna-ai/cli 0.1.19 → 0.1.22

package/dist/_lifecycle-shared-sbea9HtH.js

@@ -0,0 +1,65 @@
+import { canonicalHost, getAccount } from "./credentials-BTv2IfUZ.js";
+import { CliError, NexusClient, ScopeError } from "./client-Dn9zThOd.js";
+import { dim, red, yellow } from "kleur/colors";
+
+//#region src/commands/_lifecycle-shared.ts
+function resolveClient(opts = {}) {
+	const envHost = process.env.ANNA_APP_HOST;
+	const envPat = process.env.ANNA_APP_PAT;
+	if (envHost && envPat) {
+		const host = canonicalHost(opts.host ?? envHost);
+		return {
+			client: new NexusClient({
+				host,
+				pat: envPat
+			}),
+			host,
+			source: "env"
+		};
+	}
+	const acc = getAccount(opts.account ?? opts.host);
+	if (!acc) throw new CliError("no PAT on disk and ANNA_APP_PAT not set — run `anna-app login --host <url>` first.", 2);
+	return {
+		client: new NexusClient({
+			host: acc.host,
+			pat: acc.pat
+		}),
+		host: acc.host,
+		source: "credentials"
+	};
+}
+/**
+* Print an error from a CLI command and return its exit code.
+*
+* `ScopeError` gets the friendly multi-line hint from design §6.2.
+* `CliError` prints its message + carries a numeric exit code.
+* Everything else maps to exit 1 with the bare message.
+*/
+function reportError(e) {
+	if (e instanceof ScopeError) {
+		const need = e.needed.length > 0 ? e.needed.join(", ") : "(unknown)";
+		const have = e.have.length > 0 ? e.have.join(", ") : "(none)";
+		const missing = e.missing.length > 0 ? e.missing.join(", ") : need;
+		console.error(red(`✗ this command needs PAT scope: ${missing}`) + "\n" + dim(`  current PAT scopes: [${have}]`) + "\n" + yellow(`  Mint a new token with:
+    anna-app login --host <nexus-url> --scopes ${need}`) + "\n" + dim("  Existing tokens cannot be upgraded — old token continues to work for its current scopes."));
+		return e.exitCode;
+	}
+	if (e instanceof CliError) {
+		console.error(red(`✗ ${e.message}`));
+		return e.exitCode;
+	}
+	const msg = e?.message ?? String(e);
+	console.error(red(`✗ ${msg}`));
+	return 1;
+}
+/** Wrap an async command body so unexpected throws become exit codes. */
+async function withErrorHandling(fn) {
+	try {
+		return await fn();
+	} catch (e) {
+		return reportError(e);
+	}
+}
+
+//#endregion
+export { resolveClient, withErrorHandling };

package/dist/{agent-DUmINbo4.js → agent-Br6zY2qw.js}

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

package/dist/app-bundle-upload-DuLalcSt.js

@@ -0,0 +1,213 @@
+import { finalizeBundle, finalizeWorkingBundle, getBundle, initBundle, initWorkingBundle, uploadBundleFile, uploadWorkingBundleFile } from "./apps-B1Nd8l_t.js";
+import { CliError } from "./client-Dn9zThOd.js";
+import { canonicalize } from "./executa-publish-Ca5V7MyA.js";
+import { join, relative, sep } from "node:path";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+
+//#region src/publish/app-bundle-upload.ts
+const CONTENT_TYPES = {
+	html: "text/html",
+	htm: "text/html",
+	css: "text/css",
+	js: "text/javascript",
+	mjs: "text/javascript",
+	json: "application/json",
+	map: "application/json",
+	webmanifest: "application/manifest+json",
+	wasm: "application/wasm",
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	svg: "image/svg+xml",
+	webp: "image/webp",
+	avif: "image/avif",
+	ico: "image/x-icon",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	txt: "text/plain",
+	md: "text/markdown"
+};
+const MAX_TOTAL_BYTES = 50 * 1024 * 1024;
+const MAX_FILE_BYTES = 10 * 1024 * 1024;
+const MAX_FILES = 2e3;
+const UPLOAD_PARALLEL = 4;
+function guessContentType(name) {
+	const m = /\.([a-z0-9]+)$/i.exec(name);
+	if (!m) return "application/octet-stream";
+	return CONTENT_TYPES[m[1].toLowerCase()] ?? "application/octet-stream";
+}
+/** Recursively collect files under `bundleDir` with stable POSIX paths. */
+function collectFiles(bundleDir) {
+	const out = [];
+	const walk = (base) => {
+		for (const ent of readdirSync(base, { withFileTypes: true })) {
+			const abs = join(base, ent.name);
+			if (ent.isDirectory()) walk(abs);
+			else if (ent.isFile()) {
+				const rel = relative(bundleDir, abs).split(sep).join("/");
+				const bytes = readFileSync(abs);
+				out.push({
+					relativePath: rel,
+					bytes,
+					entry: {
+						sha256: createHash("sha256").update(bytes).digest("hex"),
+						byte_size: bytes.byteLength,
+						content_type: guessContentType(rel)
+					}
+				});
+			}
+		}
+	};
+	walk(bundleDir);
+	out.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+	return out;
+}
+/**
+* Compute the same manifest fingerprint the server stores as
+* `sha256_manifest` (sha256 of canonical JSON of the sorted file_map with
+* each entry reduced to {sha256, byte_size, content_type}).
+*/
+function manifestFingerprint(files) {
+	const obj = {};
+	for (const f of [...files].sort((a, b) => a.relativePath.localeCompare(b.relativePath))) obj[f.relativePath] = {
+		sha256: f.entry.sha256,
+		byte_size: f.entry.byte_size,
+		content_type: f.entry.content_type
+	};
+	return createHash("sha256").update(canonicalize(obj)).digest("hex");
+}
+/**
+* Upload + finalize the UI bundle for one app version. Returns
+* `{ status: "skipped" }` when the version's bundle is already finalized
+* with identical content.
+*/
+async function uploadAppBundle(params) {
+	const { client, appId, versionId, bundleDir, entryPath, bundleFormat = "static-spa", externalOrigins = [], log } = params;
+	const files = collectFiles(bundleDir);
+	if (files.length === 0) throw new CliError(`bundle directory is empty: ${bundleDir}`, 4);
+	if (files.length > MAX_FILES) throw new CliError(`too many bundle files (${files.length} > ${MAX_FILES})`, 4);
+	const totalBytes = files.reduce((s, f) => s + f.entry.byte_size, 0);
+	if (totalBytes > MAX_TOTAL_BYTES) throw new CliError(`bundle is ${(totalBytes / 1024 / 1024).toFixed(2)} MB — exceeds 50 MB limit`, 4);
+	const tooBig = files.find((f) => f.entry.byte_size > MAX_FILE_BYTES);
+	if (tooBig) throw new CliError(`bundle file exceeds 10 MB: ${tooBig.relativePath} (${(tooBig.entry.byte_size / 1024 / 1024).toFixed(2)} MB)`, 4);
+	if (!files.some((f) => f.relativePath === entryPath)) throw new CliError(`manifest entry "${entryPath}" not found in bundle dir ${bundleDir}`, 4);
+	const fingerprint = manifestFingerprint(files);
+	const existing = await getBundle(client, appId, versionId);
+	if (existing && existing.status === "bundle_ready") {
+		if (existing.sha256_manifest === fingerprint) {
+			log?.(`  bundle unchanged (${files.length} files, sha ${fingerprint.slice(0, 12)}…) — skipped`);
+			return {
+				status: "skipped",
+				reason: "unchanged",
+				detail: existing
+			};
+		}
+		throw new CliError("version already has a finalized bundle with different content; bump the app version (e.g. --bump patch) to upload a new bundle", 4);
+	}
+	log?.(`  uploading UI bundle: ${files.length} files, ${(totalBytes / 1024).toFixed(1)} KB`);
+	const fileMap = {};
+	for (const f of files) fileMap[f.relativePath] = f.entry;
+	const initResp = await initBundle(client, appId, versionId, {
+		file_map: fileMap,
+		total_size_bytes: totalBytes,
+		file_count: files.length,
+		bundle_format: bundleFormat,
+		entry_path: entryPath,
+		external_origins: externalOrigins
+	});
+	const proxyByPath = new Map(initResp.files.map((p) => [p.relative_path, p.proxy_upload_url]));
+	const queue = [...files];
+	const uploadOne = async () => {
+		for (;;) {
+			const f = queue.shift();
+			if (!f) return;
+			const proxyUrl = proxyByPath.get(f.relativePath);
+			if (!proxyUrl) throw new CliError(`server did not return an upload URL for ${f.relativePath}`, 6);
+			const ab = f.bytes.buffer.slice(f.bytes.byteOffset, f.bytes.byteOffset + f.bytes.byteLength);
+			const blob = new Blob([ab], { type: f.entry.content_type });
+			await uploadBundleFile(client, appId, versionId, f.relativePath, blob);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(UPLOAD_PARALLEL, files.length) }, uploadOne));
+	const detail = await finalizeBundle(client, appId, versionId, false);
+	log?.(`  ✓ bundle finalized (${detail.file_count} files, status=${detail.status})`);
+	return {
+		status: "uploaded",
+		detail,
+		fileCount: files.length,
+		totalBytes
+	};
+}
+/** True when `path` is an existing directory. */
+function isExistingDir(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* Stage + finalize the working (mutable) UI bundle. When `knownFingerprint`
+* matches the freshly-computed manifest fingerprint, skips the upload
+* (the working bundle already reflects these bytes).
+*/
+async function uploadWorkingBundle(params) {
+	const { client, appId, bundleDir, entryPath, bundleFormat = "static-spa", externalOrigins = [], knownFingerprint, log } = params;
+	const files = collectFiles(bundleDir);
+	if (files.length === 0) throw new CliError(`bundle directory is empty: ${bundleDir}`, 4);
+	if (files.length > MAX_FILES) throw new CliError(`too many bundle files (${files.length} > ${MAX_FILES})`, 4);
+	const totalBytes = files.reduce((s, f) => s + f.entry.byte_size, 0);
+	if (totalBytes > MAX_TOTAL_BYTES) throw new CliError(`bundle is ${(totalBytes / 1024 / 1024).toFixed(2)} MB — exceeds 50 MB limit`, 4);
+	const tooBig = files.find((f) => f.entry.byte_size > MAX_FILE_BYTES);
+	if (tooBig) throw new CliError(`bundle file exceeds 10 MB: ${tooBig.relativePath} (${(tooBig.entry.byte_size / 1024 / 1024).toFixed(2)} MB)`, 4);
+	if (!files.some((f) => f.relativePath === entryPath)) throw new CliError(`manifest entry "${entryPath}" not found in bundle dir ${bundleDir}`, 4);
+	const fingerprint = manifestFingerprint(files);
+	if (knownFingerprint && knownFingerprint === fingerprint) {
+		log?.(`  working bundle unchanged (${files.length} files, sha ${fingerprint.slice(0, 12)}…) — skipped`);
+		return {
+			status: "skipped",
+			fileCount: files.length,
+			totalBytes,
+			fingerprint,
+			bundleStatus: "ready"
+		};
+	}
+	log?.(`  staging working bundle: ${files.length} files, ${(totalBytes / 1024).toFixed(1)} KB`);
+	const fileMap = {};
+	for (const f of files) fileMap[f.relativePath] = f.entry;
+	const initResp = await initWorkingBundle(client, appId, {
+		file_map: fileMap,
+		total_size_bytes: totalBytes,
+		file_count: files.length,
+		bundle_format: bundleFormat,
+		entry_path: entryPath,
+		external_origins: externalOrigins
+	});
+	const proxyByPath = new Map(initResp.files.map((p) => [p.relative_path, p.proxy_upload_url]));
+	const queue = [...files];
+	const uploadOne = async () => {
+		for (;;) {
+			const f = queue.shift();
+			if (!f) return;
+			const proxyUrl = proxyByPath.get(f.relativePath);
+			if (!proxyUrl) throw new CliError(`server did not return an upload URL for ${f.relativePath}`, 6);
+			const ab = f.bytes.buffer.slice(f.bytes.byteOffset, f.bytes.byteOffset + f.bytes.byteLength);
+			const blob = new Blob([ab], { type: f.entry.content_type });
+			await uploadWorkingBundleFile(client, appId, f.relativePath, blob);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(UPLOAD_PARALLEL, files.length) }, uploadOne));
+	const detail = await finalizeWorkingBundle(client, appId, false);
+	log?.(`  ✓ working bundle staged (${detail.file_count} files, status=${detail.bundle_status})`);
+	return {
+		status: "uploaded",
+		fileCount: files.length,
+		totalBytes,
+		fingerprint,
+		bundleStatus: detail.bundle_status
+	};
+}
+
+//#endregion
+export { isExistingDir, uploadAppBundle, uploadWorkingBundle };

package/dist/app-cache-BEM653Th.js

@@ -0,0 +1,53 @@
+import { canonicalHost } from "./credentials-BTv2IfUZ.js";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+
+//#region src/identity/app-cache.ts
+const CACHE_DIR = ".anna";
+const CACHE_FILE = "app.json";
+function appCachePath(cwd) {
+	return resolve(cwd, CACHE_DIR, CACHE_FILE);
+}
+function readAppIdentity(cwd) {
+	const p = appCachePath(cwd);
+	if (!existsSync(p)) return null;
+	try {
+		const raw = JSON.parse(readFileSync(p, "utf-8"));
+		if (typeof raw.host === "string" && typeof raw.slug === "string" && typeof raw.app_id === "number") return {
+			$schema: "anna-app-identity/v1",
+			host: canonicalHost(raw.host),
+			app_id: raw.app_id,
+			slug: raw.slug,
+			first_published_at: raw.first_published_at
+		};
+	} catch {}
+	return null;
+}
+function writeAppIdentity(cwd, identity) {
+	const p = appCachePath(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 appCacheMatches(identity, host, slug) {
+	if (!identity) return false;
+	return identity.host === canonicalHost(host) && identity.slug === slug;
+}
+const _internal = {
+	CACHE_DIR,
+	CACHE_FILE: join(CACHE_DIR, CACHE_FILE)
+};
+
+//#endregion
+export { appCacheMatches, readAppIdentity, writeAppIdentity };

package/dist/apps-B1Nd8l_t.js

@@ -0,0 +1,221 @@
+//#region src/api/apps.ts
+async function findAppBySlug(client, slug) {
+	const r = await client.request({
+		path: "/api/v1/developer/apps",
+		query: { slug },
+		allowStatuses: [404]
+	});
+	if (r.status === 404) return null;
+	if (Array.isArray(r.data) && r.data.length > 0) return r.data[0] ?? null;
+	return null;
+}
+async function listMyApps(client) {
+	const r = await client.request({ path: "/api/v1/developer/apps" });
+	return Array.isArray(r.data) ? r.data : [];
+}
+async function getApp(client, appId) {
+	const r = await client.request({ path: `/api/v1/developer/apps/${appId}` });
+	return r.data;
+}
+async function createApp(client, body) {
+	const r = await client.request({
+		method: "POST",
+		path: "/api/v1/developer/apps",
+		body
+	});
+	return r.data;
+}
+async function patchApp(client, appId, body) {
+	const r = await client.request({
+		method: "PATCH",
+		path: `/api/v1/developer/apps/${appId}`,
+		body
+	});
+	return r.data;
+}
+async function listVersions(client, appId) {
+	const r = await client.request({ path: `/api/v1/developer/apps/${appId}/versions` });
+	return Array.isArray(r.data) ? r.data : [];
+}
+async function createVersion(client, appId, body, contentHash) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/versions`,
+		query: contentHash ? { content_hash: contentHash } : void 0,
+		body
+	});
+	return {
+		version: r.data,
+		idempotentHit: r.idempotentHit
+	};
+}
+async function submitForReview(client, appId) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/submit-review`
+	});
+	return r.data;
+}
+/**
+* Freeze & publish an existing immutable version (`publish_version`):
+* marks `is_latest`, sets `published_at`, freezes executa dependency
+* snapshots and flips the app to PUBLISHED. Idempotent on the server
+* (re-running on the already-latest version is harmless).
+*/
+async function publishVersion(client, appId, versionId) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/versions/${versionId}/publish`
+	});
+	return r.data;
+}
+async function unpublishApp(client, appId) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/unpublish`
+	});
+	return r.data;
+}
+async function archiveApp(client, appId) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/archive`
+	});
+	return r.data;
+}
+async function unarchiveApp(client, appId) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/unarchive`
+	});
+	return r.data;
+}
+async function deleteApp(client, appId) {
+	await client.request({
+		method: "DELETE",
+		path: `/api/v1/developer/apps/${appId}`,
+		allowStatuses: [204]
+	});
+}
+async function getAppGrants(client, appId) {
+	const r = await client.request({
+		path: `/api/v1/apps/${appId}/grants`,
+		allowStatuses: [404]
+	});
+	return r.status === 404 ? null : r.data;
+}
+/** GET the bundle for a version, or `null` when none is initialized (404). */
+async function getBundle(client, appId, versionId) {
+	const r = await client.request({
+		path: `/api/v1/developer/apps/${appId}/versions/${versionId}/bundle`,
+		allowStatuses: [404]
+	});
+	return r.status === 404 ? null : r.data;
+}
+async function initBundle(client, appId, versionId, body) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/versions/${versionId}/bundle/init`,
+		body
+	});
+	return r.data;
+}
+/** Upload one file via the same-origin proxy endpoint (multipart). */
+async function uploadBundleFile(client, appId, versionId, relativePath, blob) {
+	await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/versions/${versionId}/bundle/file`,
+		multipart: { fields: {
+			relative_path: relativePath,
+			file: blob
+		} },
+		allowStatuses: [201]
+	});
+}
+async function finalizeBundle(client, appId, versionId, skipRemoteCheck = false) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/versions/${versionId}/bundle/finalize`,
+		body: { skip_remote_check: skipRemoteCheck }
+	});
+	return r.data;
+}
+/**
+* Upsert the single mutable working draft for an app. `ifMatch` sends an
+* `If-Match: <revision>` optimistic-lock header (stale → 409). Returns
+* `unchanged: true` (server-side dedupe on `content_hash`) without bumping
+* the revision.
+*/
+async function upsertWorkingDraft(client, appId, body, ifMatch) {
+	const r = await client.request({
+		method: "PUT",
+		path: `/api/v1/developer/apps/${appId}/working`,
+		body,
+		headers: ifMatch !== void 0 ? { "If-Match": String(ifMatch) } : void 0
+	});
+	const unchanged = r.data.unchanged || r.idempotentHit;
+	return {
+		...r.data,
+		unchanged
+	};
+}
+/** GET the working draft, or `null` when none exists yet (404). */
+async function getWorkingDraft(client, appId) {
+	const r = await client.request({
+		path: `/api/v1/developer/apps/${appId}/working`,
+		allowStatuses: [404]
+	});
+	return r.status === 404 ? null : r.data;
+}
+/** Discard the working draft (idempotent). */
+async function deleteWorkingDraft(client, appId) {
+	await client.request({
+		method: "DELETE",
+		path: `/api/v1/developer/apps/${appId}/working`,
+		allowStatuses: [204, 404]
+	});
+}
+/**
+* Snapshot the working draft into an immutable `AnnaAppVersion` and freeze
+* executa deps. `allow409` lets the caller inspect a duplicate-version 409
+* (`{ conflict: true }`) instead of throwing.
+*/
+async function cutWorkingDraft(client, appId, body) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/working/cut`,
+		body
+	});
+	return r.data;
+}
+async function initWorkingBundle(client, appId, body) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/working/bundle/init`,
+		body
+	});
+	return r.data;
+}
+/** Upload one working-bundle file via the same-origin proxy (multipart). */
+async function uploadWorkingBundleFile(client, appId, relativePath, blob) {
+	await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/working/bundle/file`,
+		multipart: { fields: {
+			relative_path: relativePath,
+			file: blob
+		} },
+		allowStatuses: [201]
+	});
+}
+async function finalizeWorkingBundle(client, appId, skipRemoteCheck = false) {
+	const r = await client.request({
+		method: "POST",
+		path: `/api/v1/developer/apps/${appId}/working/bundle/finalize`,
+		body: { skip_remote_check: skipRemoteCheck }
+	});
+	return r.data;
+}
+
+//#endregion
+export { archiveApp, createApp, createVersion, cutWorkingDraft, deleteApp, deleteWorkingDraft, finalizeBundle, finalizeWorkingBundle, findAppBySlug, getApp, getAppGrants, getBundle, getWorkingDraft, initBundle, initWorkingBundle, listMyApps, listVersions, patchApp, publishVersion, submitForReview, unarchiveApp, unpublishApp, uploadBundleFile, uploadWorkingBundleFile, upsertWorkingDraft };

package/dist/apps-BTn9EN0x.js

@@ -0,0 +1,53 @@
+import "./credentials-BTv2IfUZ.js";
+import { listMyApps } from "./apps-B1Nd8l_t.js";
+import "./client-Dn9zThOd.js";
+import { resolveClient, withErrorHandling } from "./_lifecycle-shared-sbea9HtH.js";
+import { bold, cyan, dim, green, magenta, red, yellow } from "kleur/colors";
+
+//#region src/commands/apps.ts
+/** Colorize the lifecycle status so the next action is obvious at a glance. */
+function statusTag(status) {
+	switch (status.toUpperCase()) {
+		case "PUBLISHED": return green("[PUBLISHED]");
+		case "APPROVED": return cyan("[APPROVED]");
+		case "PENDING_REVIEW": return yellow("[PENDING_REVIEW]");
+		case "REJECTED": return red("[REJECTED]");
+		case "ARCHIVED": return dim("[ARCHIVED]");
+		case "DRAFT": return magenta("[DRAFT]");
+		default: return dim(`[${status}]`);
+	}
+}
+async function runAppsList(opts) {
+	return withErrorHandling(async () => {
+		const { client, host } = resolveClient({ account: opts.account });
+		const apps = await listMyApps(client);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				host,
+				apps: apps.map((a) => ({
+					id: a.id,
+					slug: a.slug,
+					name: a.name,
+					status: a.status,
+					is_dev: a.is_dev ?? false,
+					updated_at: a.updated_at ?? null
+				}))
+			}, null, 2));
+			return 0;
+		}
+		console.log(bold(cyan("apps you authored on")) + " " + cyan(host));
+		if (apps.length === 0) {
+			console.log(dim("  (none — run `anna-app apps publish` in a project to create one)"));
+			return 0;
+		}
+		for (const a of apps) {
+			const dev = a.is_dev ? " " + yellow("[dev]") : "";
+			console.log(`  ${statusTag(a.status)}${dev} ${bold(a.slug)} ${dim(`(id=${a.id})`)}`);
+			if (a.name && a.name !== a.slug) console.log(`        ${dim(a.name)}`);
+		}
+		return 0;
+	});
+}
+
+//#endregion
+export { runAppsList };