@alexkroman1/aai-cli 5.6.0 → 5.7.0

package/dist/{_agent-BB1ZaZsX.mjs → _agent-2nVugrN3.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as readProjectConfig, i as readGlobalConfig, n as ensureApiKey, o as serverOrigin, t as approveServer } from "./_config-PIC0nzRu.mjs";
+import { a as readProjectConfig, i as readGlobalConfig, n as ensureApiKey, o as serverOrigin, t as approveServer } from "./_config-Y5V-5Krn.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -67,6 +67,25 @@ function resolveServerUrl(explicit, configUrl, approvedOrigins = []) {
   If you do intend to use that server, re-run with --server ${origin} to approve it.`);
 }
 /**
+* Reject a repo-supplied slug that isn't the platform's slug shape.
+*
+* Enforced before a slug is ever interpolated into a URL path.
+* `.aai/project.json` is part of the working tree, so a cloned repo controls
+* this value, and callers pair it with the user's API key — `aai publish`
+* hands it to `syncEnvSecrets`, which PUTs the whole `.env` to
+* `${serverUrl}/${slug}/secret`. A hostile `"slug": "x/../admin"` must not
+* steer that request to a path of the repo's choosing.
+*
+* Lives here, at the single point where repo-controlled config becomes a
+* credentialed target, rather than at each call site: the check used to
+* exist only in `getServerInfo` (secret/storage/delete), so `publish` — the
+* command users actually run — had no guard at all.
+*/
+function assertValidConfigSlug(slug) {
+	if (slug === void 0 || VALID_SLUG_RE.test(slug)) return;
+	throw new Error(`Invalid slug in .aai/project.json: ${JSON.stringify(slug)}\n  Expected lowercase letters, digits, \`-\`, \`_\` (2-64 chars). Fix or delete the file — \`aai publish\` will create a fresh deployment.`);
+}
+/**
 * Resolve everything needed to talk to the platform: project config (null if
 * the project has never been deployed), server URL, and API key.
 */
@@ -74,6 +93,7 @@ async function resolveDeployTarget(cwd, explicitServer) {
 	const [config, globalConfig] = await Promise.all([readProjectConfig(cwd), readGlobalConfig()]);
 	const serverUrl = resolveServerUrl(explicitServer, config?.serverUrl, globalConfig.approvedServers ?? []);
 	if (explicitServer) await approveServer(serverUrl);
+	assertValidConfigSlug(config?.slug);
 	return {
 		config,
 		serverUrl,
@@ -84,7 +104,6 @@ async function resolveDeployTarget(cwd, explicitServer) {
 async function getServerInfo(cwd, explicitServer) {
 	const { config, serverUrl, apiKey } = await resolveDeployTarget(cwd, explicitServer);
 	if (!config?.slug) throw new Error("This project has no deployed agent — run `aai publish` first");
-	if (!VALID_SLUG_RE.test(config.slug)) throw new Error(`Invalid slug in .aai/project.json: ${JSON.stringify(config.slug)}\n  Expected lowercase letters, digits, \`-\`, \`_\` (2-64 chars). Fix the file or run \`aai publish\` to create a fresh deployment.`);
 	return {
 		serverUrl,
 		slug: config.slug,

package/dist/{_api-client-B6_uvuLs.mjs → _api-client-B-upMGkc.mjs}

@@ -34,11 +34,65 @@ async function apiRequest(url, opts) {
 		throw toApiError(err, url, opts);
 	}
 }
+/**
+* Collapse `{"error": "..."}` payloads embedded in a message into their own
+* text. Studio Publish runs the real `aai deploy` inside the sandbox, so its
+* failures arrive wrapped twice and stringifying them produced a
+* triple-escaped wall of JSON around one actionable sentence.
+*/
+function unwrapEmbeddedErrors(message, depth = 0) {
+	if (depth > 3) return message;
+	const start = message.indexOf("{\"error\"");
+	if (start === -1) return message;
+	const json = message.slice(start);
+	try {
+		const inner = JSON.parse(json).error;
+		if (typeof inner !== "string") return message;
+		return unwrapEmbeddedErrors(message.slice(0, start) + inner, depth + 1);
+	} catch {
+		return message;
+	}
+}
+/** The messages of a Zod issue tree, deduped and flattened. */
+function zodIssueMessages(value) {
+	if (Array.isArray(value)) return value.flatMap(zodIssueMessages);
+	if (value === null || typeof value !== "object") return [];
+	const node = value;
+	const nested = zodIssueMessages(node.issues);
+	if (nested.length > 0) return nested;
+	return typeof node.message === "string" ? [node.message] : [];
+}
+/**
+* A human-readable one-liner for a server error body.
+*
+* Servers answer with `{ error }`, or with a serialized ZodError whose useful
+* part is buried several levels down. Dumping the raw JSON turned a
+* one-character mistake (`aai secret put MY-KEY`) into a 515-character escaped
+* blob, so the shapes we actually emit are unwrapped here and anything else
+* falls back to the raw body rather than being dropped.
+*/
+function describeErrorBody(data) {
+	if (typeof data === "string") return data;
+	if (data === null || typeof data !== "object") return JSON.stringify(data ?? "");
+	const error = data.error;
+	if (typeof error === "string") return unwrapEmbeddedErrors(error);
+	if (error !== null && typeof error === "object") {
+		const { message } = error;
+		if (typeof message === "string") {
+			try {
+				const issues = zodIssueMessages(JSON.parse(message));
+				if (issues.length > 0) return [...new Set(issues)].join("; ");
+			} catch {}
+			return message;
+		}
+	}
+	return JSON.stringify(data);
+}
 /** Format an ofetch failure into a descriptive, action-centric error. */
 function toApiError(err, url, opts) {
 	if (err instanceof FetchError && err.statusCode !== void 0) {
 		const status = err.statusCode;
-		const body = typeof err.data === "string" ? err.data : JSON.stringify(err.data ?? "");
+		const body = describeErrorBody(err.data);
 		const hint = status === 401 ? HINT_INVALID_API_KEY : opts.hints?.[status];
 		return /* @__PURE__ */ new Error(`${opts.action} failed (HTTP ${status}): ${body}${hint ? `\n  ${hint}` : ""}`);
 	}

package/dist/_api-client.d.ts

@@ -41,3 +41,13 @@ export type ApiRequestOptions = {
  * failure (the 401 hint is always included; pass more via `hints`).
  */
 export declare function apiRequest<T = unknown>(url: string, opts: ApiRequestOptions): Promise<T>;
+/**
+ * A human-readable one-liner for a server error body.
+ *
+ * Servers answer with `{ error }`, or with a serialized ZodError whose useful
+ * part is buried several levels down. Dumping the raw JSON turned a
+ * one-character mistake (`aai secret put MY-KEY`) into a 515-character escaped
+ * blob, so the shapes we actually emit are unwrapped here and anything else
+ * falls back to the raw body rather than being dropped.
+ */
+export declare function describeErrorBody(data: unknown): string;

package/dist/_cli-common.d.ts

@@ -1,3 +1,4 @@
+import type { ArgsDef, CommandDef } from "citty";
 import { type CommandResult, type OutputMode } from "./_output.ts";
 /** Shared arg definitions for citty commands. */
 export declare const sharedArgs: {
@@ -16,6 +17,31 @@ export declare const sharedArgs: {
         readonly description: "Output JSON (auto-detected in non-TTY)";
     };
 };
+/**
+ * Flags in `rawArgs` that `argsDef` doesn't declare, in the form the user
+ * typed them.
+ *
+ * citty silently drops an unrecognized flag, so `aai push --serverr=http://x`
+ * exited 0 having pushed to the DEFAULT server — production, for an installed
+ * CLI — as if the flag had been honoured. Since `--server` is what decides
+ * where the API key and secret values are sent, a typo quietly retargeting it
+ * is worth failing on.
+ */
+export declare function findUnknownFlags(rawArgs: string[], argsDef: ArgsDef): string[];
+/**
+ * Any command in the tree, regardless of its args shape — the walk below only
+ * reads `subCommands` and `args`, and the concrete generics differ per command.
+ */
+type AnyCommandDef = CommandDef<ArgsDef>;
+/**
+ * Unknown flags in `argv` for whichever (possibly nested) subcommand it
+ * selects — `[]` when everything is declared.
+ *
+ * Walks the real command tree rather than re-listing flags, so this cannot
+ * drift from what the commands accept. An unknown SUBCOMMAND is not reported:
+ * citty already answers that with usage text and a non-zero exit.
+ */
+export declare function unknownFlagsForArgv(root: AnyCommandDef, argv: string[]): Promise<string[]>;
 /** Shared command setup: resolve cwd, optionally require agent.ts. */
 export declare function setup(opts?: {
     agent?: boolean;
@@ -36,3 +62,4 @@ export declare function setup(opts?: {
 export declare function runCommand(args: {
     json?: boolean | undefined;
 }, fn: (mode: OutputMode) => Promise<CommandResult<unknown>>): Promise<void>;
+export {};

package/dist/{_config-PIC0nzRu.mjs → _config-Y5V-5Krn.mjs}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { a as unwrapCancel, n as log, o as CliError } from "./_ui-8kOEB-JH.mjs";
+import { n as log, o as CliError } from "./_ui-8kOEB-JH.mjs";
 import { a as errorMessage, c as readJson, d as writeJson } from "./_utils-Ch0J4s6a.mjs";
+import { mkdtempSync } from "node:fs";
 import path from "node:path";
-import * as p from "@clack/prompts";
+import { tmpdir } from "node:os";
 import envPaths from "env-paths";
 import { z } from "zod";
 //#region _config.ts
@@ -42,8 +43,19 @@ const ProjectConfigSchema = z.object({
 function getConfigDir() {
 	const override = process.env.AAI_CONFIG_DIR?.trim();
 	if (override) return override;
+	if (process.env.VITEST) return testConfigDir();
 	return envPaths("aai", { suffix: "" }).config;
 }
+/**
+* Per-process throwaway config dir used only under vitest. Memoized: callers
+* read-modify-write the same config across calls, so a fresh dir per call
+* would silently drop what the previous one wrote.
+*/
+let _testConfigDir;
+function testConfigDir() {
+	_testConfigDir ??= mkdtempSync(path.join(tmpdir(), "aai-vitest-config-"));
+	return _testConfigDir;
+}
 async function readProjectConfig(agentDir) {
 	const file = path.join(agentDir, ".aai", "project.json");
 	let data;
@@ -132,6 +144,20 @@ async function trySaveApiKey(dir, config, apiKey) {
 		log.warn(`Couldn't save your API key to ${path.join(dir, "config.json")}: ${errorMessage(err)} — you'll be prompted again next run.`);
 	}
 }
+/**
+* The credential every platform command runs on.
+*
+* Two sources, in order: the key `aai login` saved, then
+* `ASSEMBLYAI_API_KEY` for non-interactive callers (CI, scripts, the eval
+* harnesses).
+*
+* There is deliberately NO "paste a key" prompt. Pasting one produced a
+* half-configured CLI — able to push and publish while linked to no account
+* the user could see in the studio — and it made `aai login`, which is the
+* real onboarding path, optional in practice. It was also the riskier code
+* path: a hidden password prompt reads stdin, so a piped invocation could
+* have its input eaten and persisted as the API key.
+*/
 async function ensureApiKey(configDir) {
 	const dir = configDir ?? getConfigDir();
 	const config = await readGlobalConfig(dir);
@@ -141,10 +167,7 @@ async function ensureApiKey(configDir) {
 		await trySaveApiKey(dir, config, envKey);
 		return envKey;
 	}
-	if (!process.stdin.isTTY) throw new CliError("no_api_key", "No API key configured and no TTY to prompt for one.", "Set the ASSEMBLYAI_API_KEY environment variable, or run `aai login` interactively once to save a key.");
-	const apiKey = unwrapCancel(await p.password({ message: "Enter your AssemblyAI API key" }), "Setup cancelled");
-	await trySaveApiKey(dir, config, apiKey);
-	return apiKey;
+	throw new CliError("not_logged_in", "You're not logged in.", "Run `aai login` to link your account, or set ASSEMBLYAI_API_KEY for non-interactive use.");
 }
 //#endregion
-export { readProjectConfig as a, writeGlobalConfig as c, readGlobalConfig as i, ensureApiKey as n, serverOrigin as o, getConfigDir as r, updateProjectConfig as s, approveServer as t };
+export { readProjectConfig as a, writeGlobalConfig as c, readGlobalConfig as i, writeProjectConfig as l, ensureApiKey as n, serverOrigin as o, getConfigDir as r, updateProjectConfig as s, approveServer as t };

package/dist/_config.d.ts

@@ -61,5 +61,19 @@ export declare function serverOrigin(url: string): string | null;
 export declare function approveServer(url: string, configDir?: string): Promise<void>;
 export declare function readGlobalConfig(configDir?: string): Promise<GlobalConfig>;
 export declare function writeGlobalConfig(configDir: string, data: GlobalConfig): Promise<void>;
+/**
+ * The credential every platform command runs on.
+ *
+ * Two sources, in order: the key `aai login` saved, then
+ * `ASSEMBLYAI_API_KEY` for non-interactive callers (CI, scripts, the eval
+ * harnesses).
+ *
+ * There is deliberately NO "paste a key" prompt. Pasting one produced a
+ * half-configured CLI — able to push and publish while linked to no account
+ * the user could see in the studio — and it made `aai login`, which is the
+ * real onboarding path, optional in practice. It was also the riskier code
+ * path: a hidden password prompt reads stdin, so a piped invocation could
+ * have its input eaten and persisted as the API key.
+ */
 export declare function ensureApiKey(configDir?: string): Promise<string>;
 export {};

package/dist/{_dev-server-CGptLIAm.mjs → _dev-server-BB5N8kdh.mjs}

@@ -4,7 +4,7 @@ import { a as errorMessage, r as errorCode } from "./_utils-Ch0J4s6a.mjs";
 import { n as fallbackHtmlPlugin } from "./client-bundler-yiWoXrgb.mjs";
 import { buildWorker } from "./worker-bundler.mjs";
 import { n as createWorkerEvaluator } from "./_bundler-Cjaxa2wi.mjs";
-import { n as ensureApiKey } from "./_config-PIC0nzRu.mjs";
+import { n as ensureApiKey } from "./_config-Y5V-5Krn.mjs";
 import { t as resolveServerEnv } from "./_server-common-CnaP_Urf.mjs";
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";

package/dist/{_init-BPFM4uBH.mjs → _init-D7JIT-IJ.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { c as readJson, d as writeJson, s as isEexist } from "./_utils-Ch0J4s6a.mjs";
-import { r as isDevMode, t as getMonorepoRoot } from "./_agent-BB1ZaZsX.mjs";
-import { REPO_URL, downloadAndMergeTemplate } from "./_templates-jmjgdgcd.mjs";
+import { r as isDevMode, t as getMonorepoRoot } from "./_agent-2nVugrN3.mjs";
+import { REPO_URL, downloadAndMergeTemplate } from "./_templates-Bt6u9_68.mjs";
 import path from "node:path";
 import fs from "node:fs/promises";
 //#region _init.ts

package/dist/{_slug-api-dcaQ_Uho.mjs → _slug-api-CGJSST9B.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { n as getServerInfo } from "./_agent-BB1ZaZsX.mjs";
-import { n as apiRequest, t as HINT_NOT_DEPLOYED } from "./_api-client-B6_uvuLs.mjs";
+import { n as getServerInfo } from "./_agent-2nVugrN3.mjs";
+import { n as apiRequest, t as HINT_NOT_DEPLOYED } from "./_api-client-B-upMGkc.mjs";
 //#region _slug-api.ts
 /**
 * Authenticated request against a deployed agent's slug-scoped resource

package/dist/_studio.d.ts

@@ -17,14 +17,23 @@ export declare const MAX_STUDIO_FILES = 100;
 /**
  * Walk a local project into the path→content record a workspace stores —
  * the CLI-side twin of the guest's `snapshotWorkspace`: same ignored
- * directories, same caps, oversized files skipped with a warning rather
- * than failing the whole push.
+ * directories, same caps, oversized and non-text files skipped with a
+ * warning rather than failing the whole push.
  */
 export declare function collectSourceFiles(dir: string): Promise<{
     files: Record<string, string>;
     warnings: string[];
 }>;
-/** A studio project name derived from a directory name, or null if unusable. */
+/**
+ * A studio project name derived from a directory name, or null if unusable.
+ *
+ * A `-preview` suffix is deliberately unusable. Publishing a project deploys
+ * it under the project's own name, so a `*-preview` project would claim a
+ * slug the studio's orphan-preview sweep reaps hourly — deleting the agent,
+ * its app-database schema, and its secrets on a schedule the user never
+ * asked for. Refusing the name is recoverable (rename the directory); losing
+ * a published agent to the reaper is not.
+ */
 export declare function projectNameFromDir(dir: string): string | null;
 /** The shareable studio URL for a project — what every command prints. */
 export declare function studioProjectUrl(serverUrl: string, project: string): string;

package/dist/{_templates-jmjgdgcd.mjs → _templates-Bt6u9_68.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { a as errorMessage } from "./_utils-Ch0J4s6a.mjs";
-import { t as getMonorepoRoot } from "./_agent-BB1ZaZsX.mjs";
+import { t as getMonorepoRoot } from "./_agent-2nVugrN3.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import fs from "node:fs/promises";

package/dist/cli.mjs

@@ -23,6 +23,95 @@ const sharedArgs = {
 		description: "Output JSON (auto-detected in non-TTY)"
 	}
 };
+/** Flags citty handles itself, so no command declares them. */
+const BUILTIN_FLAGS = /* @__PURE__ */ new Set([
+	"help",
+	"h",
+	"version",
+	"v"
+]);
+/**
+* Flags in `rawArgs` that `argsDef` doesn't declare, in the form the user
+* typed them.
+*
+* citty silently drops an unrecognized flag, so `aai push --serverr=http://x`
+* exited 0 having pushed to the DEFAULT server — production, for an installed
+* CLI — as if the flag had been honoured. Since `--server` is what decides
+* where the API key and secret values are sent, a typo quietly retargeting it
+* is worth failing on.
+*/
+function findUnknownFlags(rawArgs, argsDef) {
+	const declared = declaredFlagNames(argsDef);
+	const unknown = [];
+	for (const raw of rawArgs) {
+		if (raw === "--") break;
+		const token = flagToken(raw);
+		if (token && !declared.has(canonicalFlag(token))) unknown.push(token);
+	}
+	return unknown;
+}
+/**
+* A flag's comparison key: dashes dropped and lower-cased, with a leading
+* `no` negation removed.
+*
+* citty accepts both `--allowMissingSecrets` and `--allow-missing-secrets` for
+* an arg declared as `allowMissingSecrets`, and the guest's in-sandbox Publish
+* spawns the kebab-case spelling. Comparing the literal text rejected
+* `--allow-missing-secrets` as unknown and broke Publish for every studio
+* user, so both sides are normalized to one key.
+*/
+function canonicalFlag(flag) {
+	return flag.replace(/^--?/, "").replace(/^no-/, "").replace(/-/g, "").toLowerCase();
+}
+/** Every flag name and alias `argsDef` declares, plus citty's built-ins. */
+function declaredFlagNames(argsDef) {
+	const declared = new Set([...BUILTIN_FLAGS].map(canonicalFlag));
+	for (const [name, def] of Object.entries(argsDef)) {
+		const { type, alias } = def;
+		if (type === "positional") continue;
+		declared.add(canonicalFlag(name));
+		if (typeof alias === "string") declared.add(canonicalFlag(alias));
+		else if (Array.isArray(alias)) for (const a of alias) declared.add(canonicalFlag(a));
+	}
+	return declared;
+}
+/** The flag part of `raw` (`--server` from `--server=x`), or null if positional. */
+function flagToken(raw) {
+	if (!raw.startsWith("-") || raw === "-" || /^-\d/.test(raw)) return null;
+	const eq = raw.indexOf("=");
+	return eq === -1 ? raw : raw.slice(0, eq);
+}
+/** Resolve a possibly-nested `Resolvable` citty field. */
+async function resolve(value) {
+	return typeof value === "function" ? await value() : await value;
+}
+/**
+* Unknown flags in `argv` for whichever (possibly nested) subcommand it
+* selects — `[]` when everything is declared.
+*
+* Walks the real command tree rather than re-listing flags, so this cannot
+* drift from what the commands accept. An unknown SUBCOMMAND is not reported:
+* citty already answers that with usage text and a non-zero exit.
+*/
+async function unknownFlagsForArgv(root, argv) {
+	let cmd = root;
+	let i = 0;
+	for (; i < argv.length; i++) {
+		const token = argv[i];
+		if (token === void 0 || token.startsWith("-")) break;
+		const subCommands = await resolve(cmd.subCommands);
+		const next = subCommands?.[token];
+		if (next === void 0) {
+			if (subCommands && Object.keys(subCommands).length > 0) return [];
+			break;
+		}
+		const resolved = await resolve(next);
+		if (resolved === void 0) break;
+		cmd = resolved;
+	}
+	const argsDef = await resolve(cmd.args) ?? {};
+	return findUnknownFlags(argv.slice(i), argsDef);
+}
 /** Shared command setup: resolve cwd, optionally require agent.ts. */
 async function setup(opts) {
 	const cwd = resolveCwd();
@@ -76,7 +165,7 @@ const list = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = resolveCwd();
-			const { executeList } = await import("./studio-CsRn2J1a.mjs");
+			const { executeList } = await import("./studio-sXvYUxr5.mjs");
 			return executeList({
 				cwd,
 				server: args.server
@@ -111,7 +200,7 @@ const pull = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = resolveCwd();
-			const { executePull } = await import("./studio-CsRn2J1a.mjs");
+			const { executePull } = await import("./studio-sXvYUxr5.mjs");
 			return executePull({
 				cwd,
 				project: args.project,
@@ -139,7 +228,7 @@ const push = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executePush } = await import("./studio-CsRn2J1a.mjs");
+			const { executePush } = await import("./studio-sXvYUxr5.mjs");
 			return executePush({
 				cwd,
 				server: args.server,
@@ -169,7 +258,7 @@ const publish = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executePublish } = await import("./studio-CsRn2J1a.mjs");
+			const { executePublish } = await import("./studio-sXvYUxr5.mjs");
 			return executePublish({
 				cwd,
 				server: args.server,
@@ -227,7 +316,7 @@ const init = defineCommand({
 	},
 	async run({ args }) {
 		await runCommand(args, async (mode) => {
-			const { executeInit } = await import("./init-BGlOhIOl.mjs");
+			const { executeInit } = await import("./init-BT-IU9AR.mjs");
 			return executeInit({
 				dir: args.dir,
 				force: args.force,
@@ -256,7 +345,7 @@ const dev = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDev } = await import("./dev-C5P8amSg.mjs");
+			const { executeDev } = await import("./dev-C4KyxouE.mjs");
 			return executeDev({
 				cwd,
 				port: args.port
@@ -331,7 +420,7 @@ const deploy = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDeploy } = await import("./deploy-D-O-Q_mW.mjs");
+			const { executeDeploy } = await import("./deploy-Cp-wgME3.mjs");
 			return executeDeploy({
 				cwd,
 				server: args.server,
@@ -354,7 +443,7 @@ const del = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup();
-			const { executeDelete } = await import("./delete-BaHgd9cN.mjs");
+			const { executeDelete } = await import("./delete-DRNfvczK.mjs");
 			return executeDelete({
 				cwd,
 				server: args.server
@@ -385,7 +474,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async (mode) => {
 					const cwd = await setup();
-					const { executeSecretPut, NO_INPUT, readStdin } = await import("./secret-_bHo4rqt.mjs");
+					const { executeSecretPut, NO_INPUT, readStdin } = await import("./secret-Dr0qnxeb.mjs");
 					const value = mode === "json" ? await readStdin() : void 0;
 					if (mode === "json" && !value) throw new CliError(...NO_INPUT);
 					return executeSecretPut(cwd, args.name, value, args.server);
@@ -409,7 +498,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretDelete } = await import("./secret-_bHo4rqt.mjs");
+					const { executeSecretDelete } = await import("./secret-Dr0qnxeb.mjs");
 					return executeSecretDelete(cwd, args.name, args.server);
 				});
 			}
@@ -426,7 +515,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretList } = await import("./secret-_bHo4rqt.mjs");
+					const { executeSecretList } = await import("./secret-Dr0qnxeb.mjs");
 					return executeSecretList(cwd, args.server);
 				});
 			}
@@ -461,7 +550,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageStatus } = await import("./storage-MWiVx_mV.mjs");
+					const { executeStorageStatus } = await import("./storage-CoQB8d-u.mjs");
 					return executeStorageStatus(resolveStorageCwd(args.dir), args.server);
 				});
 			}
@@ -478,7 +567,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageEnable } = await import("./storage-MWiVx_mV.mjs");
+					const { executeStorageEnable } = await import("./storage-CoQB8d-u.mjs");
 					return executeStorageEnable(resolveStorageCwd(args.dir), args.server);
 				});
 			}
@@ -500,7 +589,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageDisable } = await import("./storage-MWiVx_mV.mjs");
+					const { executeStorageDisable } = await import("./storage-CoQB8d-u.mjs");
 					return executeStorageDisable(resolveStorageCwd(args.dir), {
 						server: args.server,
 						force: args.force
@@ -521,7 +610,7 @@ const login = defineCommand({
 	},
 	async run({ args }) {
 		await runCommand(args, async () => {
-			const { executeLogin } = await import("./login-B6IhXski.mjs");
+			const { executeLogin } = await import("./login-AA_UdRI-.mjs");
 			return executeLogin({ server: args.server });
 		});
 	}
@@ -534,7 +623,7 @@ const templates = defineCommand({
 	args: { json: sharedArgs.json },
 	async run({ args }) {
 		await runCommand(args, async (mode) => {
-			const { listTemplates } = await import("./_templates-jmjgdgcd.mjs");
+			const { listTemplates } = await import("./_templates-Bt6u9_68.mjs");
 			const names = await listTemplates();
 			if (mode === "human") {
 				for (const name of names) log.message(name);
@@ -586,7 +675,21 @@ if (process.env.VITEST !== "true") {
 		}
 		process.argv.splice(2, 0, "publish");
 	};
-	runDefault().then(() => runMain(mainCommand)).catch((err) => {
+	/**
+	* Refuse an unrecognized flag instead of ignoring it.
+	*
+	* citty drops one silently, so `aai push --serverr=http://x` exited 0 having
+	* pushed to the DEFAULT server. `--server` decides where the API key and
+	* secret values go, so a typo that quietly retargets it is worth failing on.
+	*/
+	const assertKnownFlags = async () => {
+		const unknown = await unknownFlagsForArgv(mainCommand, process.argv.slice(2));
+		if (unknown.length === 0) return;
+		log.error(`Unknown ${unknown.length === 1 ? "option" : "options"}: ${unknown.join(", ")}`);
+		log.info("Run `aai <command> --help` to see the options it accepts.");
+		process.exit(1);
+	};
+	runDefault().then(assertKnownFlags).then(() => runMain(mainCommand)).catch((err) => {
 		log.error(errorMessage(err));
 		process.exitCode = 1;
 	});

package/dist/{delete-BaHgd9cN.mjs → delete-DRNfvczK.mjs}

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import { n as log, u as ok } from "./_ui-8kOEB-JH.mjs";
-import { i as resolveDeployTarget, n as getServerInfo } from "./_agent-BB1ZaZsX.mjs";
-import { n as apiRequest, t as HINT_NOT_DEPLOYED } from "./_api-client-B6_uvuLs.mjs";
+import { l as writeProjectConfig } from "./_config-Y5V-5Krn.mjs";
+import { i as resolveDeployTarget, n as getServerInfo } from "./_agent-2nVugrN3.mjs";
+import { n as apiRequest, t as HINT_NOT_DEPLOYED } from "./_api-client-B-upMGkc.mjs";
 //#region delete.ts
 async function runDelete(opts) {
 	await apiRequest(`${opts.url}/${opts.slug}`, {
@@ -32,6 +33,7 @@ async function executeDelete(opts) {
 			hints: { 404: "Run `aai list` to see your projects." }
 		});
 		log.success(`Deleted ${project}`);
+		await writeProjectConfig(cwd, { serverUrl });
 		return ok({
 			project,
 			...config.slug ? { slug: config.slug } : {}

package/dist/{deploy-D-O-Q_mW.mjs → deploy-Cp-wgME3.mjs}

@@ -2,11 +2,11 @@
 import { n as log, t as fmtUrl, u as ok } from "./_ui-8kOEB-JH.mjs";
 import { a as errorMessage } from "./_utils-Ch0J4s6a.mjs";
 import { t as buildAgentBundle } from "./_bundler-Cjaxa2wi.mjs";
-import { s as updateProjectConfig } from "./_config-PIC0nzRu.mjs";
+import { s as updateProjectConfig } from "./_config-Y5V-5Krn.mjs";
 import { t as resolveServerEnv } from "./_server-common-CnaP_Urf.mjs";
-import { i as resolveDeployTarget } from "./_agent-BB1ZaZsX.mjs";
+import { i as resolveDeployTarget } from "./_agent-2nVugrN3.mjs";
 import { assertTypechecks } from "./_typecheck-gate-DvE8S3aQ.mjs";
-import { n as apiRequest } from "./_api-client-B6_uvuLs.mjs";
+import { n as apiRequest } from "./_api-client-B-upMGkc.mjs";
 import { gzipSync } from "node:zlib";
 //#region _deploy.ts
 async function runDeploy(opts) {

package/dist/{dev-C5P8amSg.mjs → dev-C4KyxouE.mjs}

@@ -11,7 +11,7 @@ import { styleText } from "node:util";
 async function executeDev(opts) {
 	const port = parsePort(opts.port);
 	const agentName = path.basename(path.resolve(opts.cwd));
-	const { startDevServer } = await import("./_dev-server-CGptLIAm.mjs");
+	const { startDevServer } = await import("./_dev-server-BB5N8kdh.mjs");
 	let cleanup;
 	let shuttingDown = false;
 	const onSignal = () => {

package/dist/{init-BGlOhIOl.mjs → init-BT-IU9AR.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { a as unwrapCancel, n as log, u as ok } from "./_ui-8kOEB-JH.mjs";
 import { a as errorMessage, c as readJson, l as resolveCwd, o as fileExists, t as AGENT_ENTRY } from "./_utils-Ch0J4s6a.mjs";
-import { r as isDevMode, t as getMonorepoRoot } from "./_agent-BB1ZaZsX.mjs";
+import { r as isDevMode, t as getMonorepoRoot } from "./_agent-2nVugrN3.mjs";
 import path from "node:path";
 import { styleText } from "node:util";
 import * as p from "@clack/prompts";
@@ -74,7 +74,7 @@ function resolveTargetDir(dir) {
 }
 /** Publish after init and return deploy metadata if successful. */
 async function tryPublish(cwd, server) {
-	const { executePublish } = await import("./studio-CsRn2J1a.mjs");
+	const { executePublish } = await import("./studio-sXvYUxr5.mjs");
 	try {
 		const result = await executePublish({
 			cwd,
@@ -93,7 +93,7 @@ async function tryPublish(cwd, server) {
 }
 /** Scaffold the project, optionally showing a spinner. */
 async function scaffoldProject(dir, cwd, template, silent) {
-	const { runInit } = await import("./_init-BPFM4uBH.mjs");
+	const { runInit } = await import("./_init-D7JIT-IJ.mjs");
 	const s = silent ? void 0 : p.spinner();
 	s?.start(`Creating ${dir}`);
 	await runInit({

package/dist/{login-B6IhXski.mjs → login-AA_UdRI-.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { n as log, o as CliError, u as ok } from "./_ui-8kOEB-JH.mjs";
-import { c as writeGlobalConfig, i as readGlobalConfig, r as getConfigDir, t as approveServer } from "./_config-PIC0nzRu.mjs";
-import { a as resolveServerUrl } from "./_agent-BB1ZaZsX.mjs";
+import { c as writeGlobalConfig, i as readGlobalConfig, r as getConfigDir, t as approveServer } from "./_config-Y5V-5Krn.mjs";
+import { a as resolveServerUrl } from "./_agent-2nVugrN3.mjs";
 import { spawn } from "node:child_process";
 import { setTimeout } from "node:timers/promises";
 import { randomBytes } from "node:crypto";
@@ -35,6 +35,73 @@ async function jsonBody(res, what) {
 	if (body === null) throw new CliError("login_failed", `${what} returned an invalid response`);
 	return body;
 }
+/**
+* Fetch, turning a transport failure into an error that names the server.
+*
+* A connection failure here is undici's bare `TypeError: fetch failed` — no
+* URL, no cause worth printing — and `aai login` is exactly where it is least
+* diagnosable: the target is resolved (dev mode pins `localhost:8080`
+* whenever the CLI itself lives in the monorepo, whatever the cwd), so the
+* user cannot tell which server was unreachable, or that a local one was
+* expected at all. `apiRequest` has always said "could not reach <url>";
+* login used raw fetch and said nothing.
+*/
+async function reachable(fetchFn, url, serverUrl) {
+	try {
+		return await fetchFn(url);
+	} catch (err) {
+		throw unreachableError(serverUrl, err);
+	}
+}
+/**
+* "Could not reach <server>", with advice chosen by the kind of host and the
+* original transport failure preserved as the cause.
+*/
+function unreachableError(serverUrl, cause) {
+	const hint = isLoopback(serverUrl) ? "That's a local server — start it with `pnpm dev:aai-server`, or pass `--server <url>` to log in elsewhere. (A CLI installed from the monorepo targets localhost by default; set AAI_NO_DEV=1 to use the hosted platform.)" : "Check your network connection and verify the server URL is correct.";
+	return new CliError("login_unreachable", `Could not reach ${serverUrl}.`, hint, { cause });
+}
+/** Whether `url`'s host is loopback — used only to pick a better hint. */
+function isLoopback(url) {
+	try {
+		const { hostname } = new URL(url);
+		return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+	} catch {
+		return false;
+	}
+}
+/**
+* Poll the exchange until the browser approves the link, or the deadline.
+*
+* A transport failure is retried rather than fatal: the user is off in a
+* browser approving, and a dev server reloading in that window would
+* otherwise lose a login that was about to succeed. The last one is
+* remembered, so a server that never comes back is reported as unreachable
+* rather than as "you didn't approve in time" — which would blame the user
+* for someone else's outage.
+*/
+async function pollForGrant(fetchFn, serverUrl, code, opts) {
+	let lastTransportError;
+	for (;;) {
+		let res = null;
+		try {
+			res = await fetchFn(`${serverUrl}/studio/cli-link/exchange`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ code })
+			});
+			lastTransportError = void 0;
+		} catch (err) {
+			lastTransportError = err;
+		}
+		if (res && res.status !== 404) return await jsonBody(res, "Linking your account");
+		if (Date.now() >= opts.deadline) {
+			if (lastTransportError !== void 0) throw unreachableError(serverUrl, lastTransportError);
+			throw new CliError("login_timeout", "Timed out waiting for the link to be approved in the browser.", "Run `aai login` again and approve the link within five minutes.");
+		}
+		await setTimeout(opts.intervalMs);
+	}
+}
 function requireTty() {
 	if (!process.stdin.isTTY) throw new CliError("login_interactive", "`aai login` is interactive and needs a TTY.", "Non-interactive setups can set the ASSEMBLYAI_API_KEY environment variable instead.");
 }
@@ -77,29 +144,17 @@ async function executeLogin(opts, deps = {}) {
 	const globalConfig = await readGlobalConfig();
 	const serverUrl = resolveServerUrl(opts.server, void 0, globalConfig.approvedServers ?? []);
 	if (opts.server) await approveServer(serverUrl);
-	if ((await jsonBody(await fetchFn(`${serverUrl}/studio/auth`), "Reading the server's login configuration")).mode === "none") throw new CliError("login_unavailable", "This server has no browser login configured, so there is no account to link.", "Set the ASSEMBLYAI_API_KEY environment variable, or run any platform command to be prompted for a key.");
+	if ((await jsonBody(await reachable(fetchFn, `${serverUrl}/studio/auth`, serverUrl), "Reading the server's login configuration")).mode === "none") throw new CliError("login_unavailable", "This server has no browser login configured, so there is no account to link.", "Set the ASSEMBLYAI_API_KEY environment variable instead — it's the only other way to authenticate.");
 	const code = randomBytes(32).toString("base64url");
 	const linkUrl = `${serverUrl}/?cli-link=${code}`;
 	log.info(`Opening the browser to link your account…\n  ${linkUrl}`);
 	log.info(`Confirmation code: ${linkConfirmationCode(code)}`);
 	log.info("Approve the link in the browser (sign in there first if you need to) — the approval page shows the same code.");
 	(deps.openBrowser ?? defaultOpenBrowser)(linkUrl);
-	const pollInterval = deps.pollIntervalMs ?? LINK_POLL_INTERVAL_MS;
-	const deadline = Date.now() + (deps.timeoutMs ?? LINK_TIMEOUT_MS);
-	let granted;
-	for (;;) {
-		const res = await fetchFn(`${serverUrl}/studio/cli-link/exchange`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ code })
-		});
-		if (res.status !== 404) {
-			granted = await jsonBody(res, "Linking your account");
-			break;
-		}
-		if (Date.now() >= deadline) throw new CliError("login_timeout", "Timed out waiting for the link to be approved in the browser.", "Run `aai login` again and approve the link within five minutes.");
-		await setTimeout(pollInterval);
-	}
+	const granted = await pollForGrant(fetchFn, serverUrl, code, {
+		intervalMs: deps.pollIntervalMs ?? LINK_POLL_INTERVAL_MS,
+		deadline: Date.now() + (deps.timeoutMs ?? LINK_TIMEOUT_MS)
+	});
 	if (!granted.apiKey) throw new CliError("login_failed", "Linking your account did not return an API key.");
 	const dir = getConfigDir();
 	await writeGlobalConfig(dir, {

package/dist/scaffold/package.json

@@ -11,15 +11,15 @@
     "publish:agent": "aai publish"
   },
   "dependencies": {
-    "@alexkroman1/aai": "^5.6.0",
-    "@alexkroman1/aai-ui": "^5.6.0",
+    "@alexkroman1/aai": "^5.7.0",
+    "@alexkroman1/aai-ui": "^5.7.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "tailwindcss": "^4.0.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@alexkroman1/aai-cli": "^5.6.0",
+    "@alexkroman1/aai-cli": "^5.7.0",
     "@tailwindcss/vite": "^4.3.3",
     "@types/node": "^26.1.1",
     "@types/react": "^19.2.17",

package/dist/{secret-_bHo4rqt.mjs → secret-Dr0qnxeb.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { a as unwrapCancel, n as log, s as fail, u as ok } from "./_ui-8kOEB-JH.mjs";
-import { t as slugRequest } from "./_slug-api-dcaQ_Uho.mjs";
+import { t as slugRequest } from "./_slug-api-CGJSST9B.mjs";
 import * as p from "@clack/prompts";
 import { text } from "node:stream/consumers";
 //#region secret.ts

package/dist/{storage-MWiVx_mV.mjs → storage-CoQB8d-u.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { n as log, s as fail, u as ok } from "./_ui-8kOEB-JH.mjs";
-import { t as slugRequest } from "./_slug-api-dcaQ_Uho.mjs";
+import { t as slugRequest } from "./_slug-api-CGJSST9B.mjs";
 import * as p from "@clack/prompts";
 //#region storage.ts
 async function storageRequest(cwd, init, server) {

package/dist/{studio-CsRn2J1a.mjs → studio-sXvYUxr5.mjs}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { n as log, o as CliError, t as fmtUrl, u as ok } from "./_ui-8kOEB-JH.mjs";
-import { s as updateProjectConfig } from "./_config-PIC0nzRu.mjs";
+import { s as updateProjectConfig } from "./_config-Y5V-5Krn.mjs";
 import { t as resolveServerEnv } from "./_server-common-CnaP_Urf.mjs";
-import { i as resolveDeployTarget } from "./_agent-BB1ZaZsX.mjs";
-import { layerScaffold } from "./_templates-jmjgdgcd.mjs";
-import { n as apiRequest } from "./_api-client-B6_uvuLs.mjs";
+import { i as resolveDeployTarget } from "./_agent-2nVugrN3.mjs";
+import { layerScaffold } from "./_templates-Bt6u9_68.mjs";
+import { n as apiRequest } from "./_api-client-B-upMGkc.mjs";
 import path from "node:path";
 import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { VALID_SLUG_RE } from "@alexkroman1/aai/utils";
+import { PREVIEW_SLUG_SUFFIX, VALID_SLUG_RE } from "@alexkroman1/aai/utils";
 //#region _studio.ts
 /**
 * Internals of the studio-workspace commands (`aai list/pull/push/publish`):
@@ -60,10 +60,32 @@ async function walkProject(dir, current = dir) {
 	return out.sort((a, b) => a.localeCompare(b));
 }
 /**
+* Decode `buf` as UTF-8, or null when it isn't valid UTF-8.
+*
+* `fatal` makes an invalid sequence throw instead of becoming U+FFFD, which
+* is the whole point: a workspace is a JSON path→string map and cannot carry
+* arbitrary bytes, so a lossy read turned a pushed PNG into replacement
+* characters while reporting success — and a later `aai pull` wrote the
+* mangled version back over the local original. `ignoreBOM` keeps a leading
+* U+FEFF in the string; without it the decoder strips the BOM and the check
+* meant to stop corruption would quietly perform some of its own.
+*/
+const UTF8_STRICT = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+function decodeUtf8(buf) {
+	try {
+		return UTF8_STRICT.decode(buf);
+	} catch {
+		return null;
+	}
+}
+/**
 * Walk a local project into the path→content record a workspace stores —
 * the CLI-side twin of the guest's `snapshotWorkspace`: same ignored
-* directories, same caps, oversized files skipped with a warning rather
-* than failing the whole push.
+* directories, same caps, oversized and non-text files skipped with a
+* warning rather than failing the whole push.
 */
 async function collectSourceFiles(dir) {
 	const paths = await walkProject(dir);
@@ -77,16 +99,31 @@ async function collectSourceFiles(dir) {
 			warnings.push(`${rel} is ${st.size} bytes (max ${MAX_STUDIO_FILE_BYTES}) — not synced.`);
 			continue;
 		}
-		files[rel.split(path.sep).join("/")] = await readFile(abs, "utf-8");
+		const content = decodeUtf8(await readFile(abs));
+		if (content === null) {
+			warnings.push(`${rel} is not valid UTF-8 (binary file?) — not synced.`);
+			continue;
+		}
+		files[rel.split(path.sep).join("/")] = content;
 	}
 	return {
 		files,
 		warnings
 	};
 }
-/** A studio project name derived from a directory name, or null if unusable. */
+/**
+* A studio project name derived from a directory name, or null if unusable.
+*
+* A `-preview` suffix is deliberately unusable. Publishing a project deploys
+* it under the project's own name, so a `*-preview` project would claim a
+* slug the studio's orphan-preview sweep reaps hourly — deleting the agent,
+* its app-database schema, and its secrets on a schedule the user never
+* asked for. Refusing the name is recoverable (rename the directory); losing
+* a published agent to the reaper is not.
+*/
 function projectNameFromDir(dir) {
 	const name = path.basename(dir).toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/-{2,}/g, "-").replace(/^[-_]+|[-_]+$/g, "").slice(0, 64);
+	if (name.endsWith(PREVIEW_SLUG_SUFFIX)) return null;
 	return VALID_SLUG_RE.test(name) ? name : null;
 }
 /** The shareable studio URL for a project — what every command prints. */
@@ -217,7 +254,8 @@ async function pushProject(opts) {
 		created: result.created,
 		serverUrl,
 		apiKey,
-		slug
+		slug,
+		warnings
 	};
 }
 async function executePush(opts) {
@@ -227,7 +265,8 @@ async function executePush(opts) {
 	return ok({
 		project: pushed.project,
 		created: pushed.created,
-		url
+		url,
+		...pushed.warnings.length > 0 ? { warnings: pushed.warnings } : {}
 	});
 }
 /**
@@ -260,6 +299,7 @@ async function executePublish(opts) {
 	if (pushed.slug) await syncEnvSecrets(opts.cwd, serverUrl, apiKey, pushed.slug);
 	log.step(`Publishing ${project} (builds in the project's sandbox)…`);
 	const result = await publishStudioProject(serverUrl, apiKey, project);
+	if (typeof result?.slug !== "string" || typeof result?.output !== "string") throw new CliError("bad_publish_response", `Unexpected response from the publish route at ${serverUrl}.`, "Check that --server points at an aai platform server, then try again.");
 	if (result.output.trim()) log.message(result.output.trim());
 	await updateProjectConfig(opts.cwd, {
 		serverUrl,
@@ -277,7 +317,8 @@ async function executePublish(opts) {
 		slug: result.slug,
 		url: agentUrl,
 		studioUrl,
-		output: result.output
+		output: result.output,
+		...pushed.warnings.length > 0 ? { warnings: pushed.warnings } : {}
 	});
 }
 //#endregion

package/dist/studio.d.ts

@@ -37,6 +37,7 @@ export declare function executePush(opts: {
     project: string;
     created: boolean;
     url: string;
+    warnings?: string[];
 }>>;
 export declare function executePublish(opts: {
     cwd: string;
@@ -49,4 +50,5 @@ export declare function executePublish(opts: {
     url: string;
     studioUrl: string;
     output: string;
+    warnings?: string[];
 }>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-cli",
-  "version": "5.6.0",
+  "version": "5.7.0",
   "type": "module",
   "bin": {
     "aai": "dist/cli.mjs"
@@ -37,8 +37,8 @@
     "p-timeout": "^7.0.1",
     "vite": "^8.1.5",
     "zod": "^4.4.3",
-    "@alexkroman1/aai": "5.6.0",
-    "@alexkroman1/aai-ui": "5.6.0"
+    "@alexkroman1/aai": "5.7.0",
+    "@alexkroman1/aai-ui": "5.7.0"
   },
   "devDependencies": {
     "playwright": "^1.61.1",