@alexkroman1/aai-cli 1.9.2 → 1.10.0

package/dist/_utils-ECl2je7-.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region _utils.ts
+/** Resolve the working directory from INIT_CWD or process.cwd(). */
+function resolveCwd() {
+	return process.env.INIT_CWD || process.cwd();
+}
+/**
+* Extract a message from an unknown error. Local copy of `errorMessage` from
+* `@alexkroman1/aai` — importing the root barrel pulls zod into every CLI
+* invocation (including `aai --help`), so the one-liner lives here instead.
+*/
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* Extract a stack (falling back to the message) from an unknown error. Local
+* copy of `errorDetail` from `@alexkroman1/aai` for the same reason as
+* {@link errorMessage} above.
+*/
+function errorDetail(err) {
+	return err instanceof Error ? err.stack ?? err.message : String(err);
+}
+/** The `code` of a Node errno-style error (`"ENOENT"`, `"EPIPE"`, …), or undefined. */
+function errorCode(err) {
+	return err instanceof Error && "code" in err && typeof err.code === "string" ? err.code : void 0;
+}
+/** True when `err` is a filesystem EEXIST error (target already exists). */
+function isEexist(err) {
+	return errorCode(err) === "EEXIST";
+}
+/** Validate that a module's default export is a valid agent definition. Throws if invalid. */
+function validateAgentExport(mod) {
+	if (!mod?.name || typeof mod.name !== "string") throw new Error("agent.ts must export default agent({ name: ... })");
+}
+async function fileExists(p) {
+	try {
+		await fs.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Read and parse a JSON file. Returns null only when the file does not exist
+* (ENOENT — the "optional file" case). A file that exists but cannot be read
+* (EACCES, …) or parsed throws instead: treating a corrupted file as absent
+* hides real problems — e.g. a corrupted `.aai/project.json` would silently
+* deploy under a NEW slug, orphaning the live deployment.
+*/
+async function readJson(filePath) {
+	let raw;
+	try {
+		raw = await fs.readFile(filePath, "utf-8");
+	} catch (err) {
+		if (errorCode(err) === "ENOENT") return null;
+		throw err;
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (err) {
+		throw new Error(`Invalid JSON in ${filePath}: ${errorMessage(err)}`, { cause: err });
+	}
+}
+/**
+* Write `data` as pretty-printed JSON (+ trailing newline), creating parent dirs.
+*
+* Writes to a temp file in the same directory, then renames it into place.
+* A plain `writeFile` can be observed (or left, on crash) half-written; a
+* torn config.json fails `JSON.parse`, reads back as `{}`, and the next
+* read-modify-write silently wipes fields like `approvedServers`. Rename on
+* the same filesystem is atomic, so readers only ever see a complete file.
+* Two concurrent CLI processes can still lose each other's *updates*
+* (last rename wins) — acceptable for these small user-config files.
+*
+* `mode` restricts the file's permissions (the rename carries the temp
+* file's mode to the destination, so an existing world-readable file is
+* tightened on the next write). The parent directory is created 0o700 in
+* that case so a fresh config dir never goes through a readable window.
+*/
+async function writeJson(filePath, data, opts = {}) {
+	await fs.mkdir(path.dirname(filePath), {
+		recursive: true,
+		...opts.mode !== void 0 ? { mode: 448 } : {}
+	});
+	const tmpPath = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	await fs.writeFile(tmpPath, `${JSON.stringify(data, null, 2)}\n`, { ...opts.mode !== void 0 ? { mode: opts.mode } : {} });
+	try {
+		await fs.rename(tmpPath, filePath);
+	} catch (err) {
+		await fs.rm(tmpPath, { force: true }).catch(() => void 0);
+		throw err;
+	}
+}
+//#endregion
+export { isEexist as a, validateAgentExport as c, fileExists as i, writeJson as l, errorDetail as n, readJson as o, errorMessage as r, resolveCwd as s, errorCode as t };

package/dist/_vite-env-DNb9R8xq.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+//#region _vite-env.ts
+/**
+* Run a Vite build without letting it mutate the calling process's env.
+*
+* Vite's `build()` sets `process.env.NODE_ENV = "production"` when NODE_ENV is
+* unset — a global, permanent side effect on whatever process invoked it. That
+* is fine for a one-shot `aai build`, but both long-lived callers are broken by
+* it:
+*
+* - `aai dev` rebuilds on every file change, so the first rebuild would flip
+*   the dev server into production mode.
+* - The platform studio builds inside the server process, where flipping
+*   NODE_ENV makes the sandbox demand gVisor ("gVisor (runsc) is required in
+*   production but not found on PATH") and refuse every subsequent deploy on a
+*   dev machine.
+*
+* Snapshot and restore rather than pinning a value: callers that legitimately
+* run with NODE_ENV=production must keep it.
+*
+* The snapshot is refcounted, not per-call: both bundle paths run the worker
+* and client builds concurrently (`Promise.all`), and independent snapshots
+* interleave — the second entrant would snapshot the "production" the first
+* build's Vite just set, and "restore" it after the first exiter deleted it,
+* flipping the process permanently anyway. So the first entrant snapshots,
+* later entrants just join, and only the last exiter restores. This keeps the
+* builds parallel (a mutex serializing them would cost real deploy time).
+*/
+let activeBuilds = 0;
+let savedNodeEnv;
+/**
+* `env` is injectable for tests ONLY, so specs can exercise the
+* snapshot/refcount logic on a plain object instead of mutating (and
+* repeatedly deleting) the real `process.env.NODE_ENV` mid-suite.
+*/
+async function withPreservedNodeEnv(fn, env = process.env) {
+	if (activeBuilds === 0) savedNodeEnv = env.NODE_ENV;
+	activeBuilds++;
+	try {
+		return await fn();
+	} finally {
+		activeBuilds--;
+		if (activeBuilds === 0) if (savedNodeEnv === void 0) delete env.NODE_ENV;
+		else env.NODE_ENV = savedNodeEnv;
+	}
+}
+//#endregion
+export { withPreservedNodeEnv as t };

package/dist/cli.mjs

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
-import { a as withOutput, n as fail, o as writeLine, r as getOutputMode, t as CliError } from "./_output-fy2bXRNb.mjs";
-import { i as silenceOutput, n as log } from "./_ui-YqQ6Fi8K.mjs";
-import { n as errorMessage, o as resolveCwd, r as fileExists } from "./_utils-BeU10C7O.mjs";
+import { c as getOutputMode, d as writeLine, i as silenceOutput, l as installStdoutGuard, n as log, o as CliError, s as fail } from "./_ui-CKEIHAtB.mjs";
+import { i as fileExists, r as errorMessage, s as resolveCwd } from "./_utils-ECl2je7-.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -31,14 +30,20 @@ const sharedArgs = {
 	}
 };
 const cliDir = path.dirname(fileURLToPath(import.meta.url));
-function findPkgJson(dir) {
-	try {
-		return readFileSync(path.join(dir, "package.json"), "utf-8");
-	} catch {
-		return readFileSync(path.join(dir, "..", "package.json"), "utf-8");
-	}
+/**
+* Read this CLI's own version from its package.json (source layout keeps it
+* next to cli.ts; dist layout one level up). A missing or corrupt file must
+* not brick every command over a cosmetic string — warn and fall back.
+*/
+function readCliVersion(dir) {
+	for (const candidate of [path.join(dir, "package.json"), path.join(dir, "..", "package.json")]) try {
+		const parsed = JSON.parse(readFileSync(candidate, "utf-8"));
+		if (typeof parsed.version === "string") return parsed.version;
+	} catch {}
+	process.stderr.write("warning: could not read aai's package.json — reporting version unknown\n");
+	return "unknown";
 }
-const VERSION = JSON.parse(findPkgJson(cliDir)).version;
+const VERSION = readCliVersion(cliDir);
 /** Shared command setup: resolve cwd, optionally require agent.ts. */
 async function setup(opts) {
 	const cwd = resolveCwd();
@@ -47,28 +52,19 @@ async function setup(opts) {
 	}
 	return cwd;
 }
-/** Catch command errors and display a clean message instead of a raw stack trace. */
-async function handleErrors(mode, fn) {
-	try {
-		await fn();
-	} catch (err) {
-		const code = err instanceof CliError ? err.code : "command_failed";
-		const hint = err instanceof CliError ? err.hint : void 0;
-		if (mode === "json") {
-			const result = fail(code, errorMessage(err), hint);
-			await writeLine(`${JSON.stringify(result)}\n`);
-			process.exit(1);
-		}
-		log.error(errorMessage(err));
-		process.exit(1);
-	}
-}
 /**
-* Run a command body with standard error handling, output mode resolution, and withOutput wrapping.
+* Run a command body with standard output-mode resolution, error handling,
+* and result emission.
 *
 * - `setYes`: json mode sets `args.yes = true` (only meaningful for commands with a `yes` arg).
-* - `apiKey`: prompt for / resolve the AssemblyAI API key before the command body runs
-*   (default true — pass false for commands that never talk to the platform).
+* - API key acquisition is owned by `resolveDeployTarget`/`getServerInfo`
+*   inside the commands that talk to the platform — after the server-trust
+*   check, so an untrusted `serverUrl` is refused without prompting for a
+*   key, and commands with no platform traffic never prompt at all.
+*
+* A thrown error and a returned `fail(...)` converge here on one emitter:
+* human mode logs the message, JSON mode writes exactly one result line,
+* and both exit 1.
 */
 async function runCommand(args, fn, opts = {}) {
 	const mode = getOutputMode(args);
@@ -76,13 +72,17 @@ async function runCommand(args, fn, opts = {}) {
 		silenceOutput();
 		if (opts.setYes) args.yes = true;
 	}
-	await handleErrors(mode, () => withOutput(mode, async () => {
-		if (opts.apiKey !== false) {
-			const { ensureApiKey } = await import("./_config-zV70t71V.mjs").then((n) => n.t);
-			await ensureApiKey();
-		}
-		return fn(mode);
-	}));
+	let result;
+	try {
+		result = await fn(mode);
+	} catch (err) {
+		const code = err instanceof CliError ? err.code : "command_failed";
+		const hint = err instanceof CliError ? err.hint : void 0;
+		if (mode === "human") log.error(errorMessage(err));
+		result = fail(code, errorMessage(err), hint);
+	}
+	if (mode === "json") await writeLine(`${JSON.stringify(result)}\n`);
+	if (!result.ok) process.exit(1);
 }
 const init = defineCommand({
 	meta: {
@@ -110,7 +110,7 @@ const init = defineCommand({
 		json: sharedArgs.json,
 		skipApi: {
 			type: "boolean",
-			description: "Skip API key check"
+			description: "Deprecated no-op: the API key is now only requested when deploying"
 		},
 		skipDeploy: {
 			type: "boolean",
@@ -119,7 +119,7 @@ const init = defineCommand({
 	},
 	async run({ args }) {
 		await runCommand(args, async (mode) => {
-			const { executeInit } = await import("./init-BDhs6-jB.mjs");
+			const { executeInit } = await import("./init-CFwZf8q1.mjs");
 			return executeInit({
 				dir: args.dir,
 				force: args.force,
@@ -128,10 +128,7 @@ const init = defineCommand({
 				skipDeploy: args.skipDeploy,
 				server: args.server
 			}, mode === "json" ? { silent: true } : void 0);
-		}, {
-			setYes: true,
-			apiKey: !args.skipApi
-		});
+		}, { setYes: true });
 	}
 });
 const dev = defineCommand({
@@ -146,7 +143,7 @@ const dev = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDev } = await import("./dev-DGzDKzGZ.mjs");
+			const { executeDev } = await import("./dev-CtE0d-Gs.mjs");
 			return executeDev({
 				cwd,
 				port: args.port
@@ -163,9 +160,9 @@ const test = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup();
-			const { executeTest } = await import("./test-C6jwCnFu.mjs");
+			const { executeTest } = await import("./test-DXPY9Bqq.mjs");
 			return executeTest(cwd);
-		}, { apiKey: false });
+		});
 	}
 });
 const build = defineCommand({
@@ -184,12 +181,20 @@ const build = defineCommand({
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
 			if (!args.skipTests) {
-				const { runVitest } = await import("./test-C6jwCnFu.mjs");
-				runVitest(cwd);
+				const { classifyVitestError, runVitest } = await import("./test-DXPY9Bqq.mjs");
+				const toCliError = (err) => {
+					const { code, message } = classifyVitestError(err);
+					return new CliError(code, message, "Re-run with --skipTests to build without tests", { cause: err });
+				};
+				try {
+					runVitest(cwd);
+				} catch (err) {
+					throw toCliError(err);
+				}
 			}
-			const { executeBuild } = await import("./_bundler-CpLVjRzc.mjs");
+			const { executeBuild } = await import("./_bundler-CKz9Q15i.mjs");
 			return executeBuild(cwd);
-		}, { apiKey: false });
+		});
 	}
 });
 const deploy = defineCommand({
@@ -204,7 +209,7 @@ const deploy = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDeploy } = await import("./deploy-DOy6wOCd.mjs");
+			const { executeDeploy } = await import("./deploy-Ds1spTPC.mjs");
 			return executeDeploy({
 				cwd,
 				...args.server ? { server: args.server } : {}
@@ -224,7 +229,7 @@ const del = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup();
-			const { executeDelete } = await import("./delete-DE35s3d5.mjs");
+			const { executeDelete } = await import("./delete-xZ8PzM_4.mjs");
 			return executeDelete({
 				cwd,
 				...args.server ? { server: args.server } : {}
@@ -255,7 +260,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async (mode) => {
 					const cwd = await setup();
-					const { executeSecretPut, readStdin } = await import("./secret-D-90QtDQ.mjs");
+					const { executeSecretPut, readStdin } = await import("./secret-B4LRmUhF.mjs");
 					const value = mode === "json" ? await readStdin() : void 0;
 					if (mode === "json" && !value) throw new CliError("no_input", "No value provided", "Pipe secret value to stdin");
 					return executeSecretPut(cwd, args.name, value, args.server);
@@ -279,7 +284,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretDelete } = await import("./secret-D-90QtDQ.mjs");
+					const { executeSecretDelete } = await import("./secret-B4LRmUhF.mjs");
 					return executeSecretDelete(cwd, args.name, args.server);
 				});
 			}
@@ -296,7 +301,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretList } = await import("./secret-D-90QtDQ.mjs");
+					const { executeSecretList } = await import("./secret-B4LRmUhF.mjs");
 					return executeSecretList(cwd, args.server);
 				});
 			}
@@ -320,18 +325,22 @@ const mainCommand = defineCommand({
 	}
 });
 if (process.env.VITEST !== "true") {
-	const sub = process.argv[2];
-	const helpFlags = /* @__PURE__ */ new Set([
-		"--help",
-		"--version",
-		"-h",
-		"-V"
-	]);
-	if (!sub || sub.startsWith("-") && !helpFlags.has(sub)) {
-		const defaultCmd = existsSync(path.join(resolveCwd(), "agent.ts")) ? "deploy" : "init";
-		process.argv.splice(2, 0, defaultCmd);
-	}
-	runMain(mainCommand).catch((err) => {
+	installStdoutGuard();
+	const runDefault = async () => {
+		if (process.argv.length > 2) return;
+		if (!existsSync(path.join(resolveCwd(), "agent.ts"))) {
+			process.argv.splice(2, 0, "init");
+			return;
+		}
+		if (process.stdin.isTTY && process.stdout.isTTY) {
+			if (await (await import("@clack/prompts")).confirm({ message: "Deploy this agent to production?" }) !== true) {
+				log.info("Cancelled. Run `aai --help` to see all commands.");
+				process.exit(0);
+			}
+		}
+		process.argv.splice(2, 0, "deploy");
+	};
+	runDefault().then(() => runMain(mainCommand)).catch((err) => {
 		log.error(errorMessage(err));
 		process.exitCode = 1;
 	});

package/dist/{client-bundler-Bki_Rned.mjs → client-bundler-VdcgFcos.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { r as fileExists } from "./_utils-BeU10C7O.mjs";
-import { t as withPreservedNodeEnv } from "./_vite-env-CmXG4ZAu.mjs";
+import { i as fileExists, r as errorMessage } from "./_utils-ECl2je7-.mjs";
+import { t as withPreservedNodeEnv } from "./_vite-env-DNb9R8xq.mjs";
 import { existsSync, unlinkSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import fs from "node:fs/promises";
@@ -41,7 +41,7 @@ function fallbackHtmlPlugin(root) {
 					server.transformIndexHtml("/", DEFAULT_HTML, req.originalUrl).then((html) => {
 						res.setHeader("Content-Type", "text/html");
 						res.end(html);
-					}, next);
+					}).catch(next);
 					return;
 				}
 				next();
@@ -56,29 +56,21 @@ function fallbackHtmlPlugin(root) {
 function writeTempHtml(root) {
 	const htmlPath = path.join(root, "index.html");
 	if (existsSync(htmlPath)) return () => {};
-	writeFileSync(htmlPath, DEFAULT_HTML);
-	return () => {
+	const cleanup = () => {
 		try {
 			unlinkSync(htmlPath);
 		} catch {}
 	};
+	try {
+		writeFileSync(htmlPath, DEFAULT_HTML);
+	} catch (err) {
+		cleanup();
+		throw new Error(`Failed to write a temporary index.html at ${htmlPath} for the client build — is the project directory writable? (${errorMessage(err)})`, { cause: err });
+	}
+	return cleanup;
 }
 //#endregion
 //#region client-bundler.ts
-/**
-* Client SPA bundling — the one implementation of "turn a `client.tsx` into
-* deployable `clientFiles`".
-*
-* Public (no `_` prefix) because the platform's browser studio reuses it: a
-* studio workspace is materialized to a directory and built through this same
-* function, so a UI published from the browser is byte-identical to one
-* deployed with `aai deploy`. Keep it that way — a second client bundler is
-* how the two paths would silently drift.
-*
-* The studio differs from a CLI project in two ways, hence the options:
-* it has no `vite.config.ts` to supply React/Tailwind plugins, and its files
-* are untrusted so any config the workspace *does* contain must be ignored.
-*/
 const DEFAULT_OUT_DIR = ".aai/client";
 /**
 * Packages resolved from the build root rather than from whichever
@@ -109,8 +101,9 @@ async function buildClient(cwd, opts = {}) {
 	if (!await fileExists(path.join(cwd, "client.tsx"))) return {};
 	const outDir = opts.outDir ?? DEFAULT_OUT_DIR;
 	const clientDir = path.join(cwd, outDir);
-	const cleanupHtml = writeTempHtml(cwd);
+	let cleanupHtml = () => {};
 	try {
+		cleanupHtml = writeTempHtml(cwd);
 		await withPreservedNodeEnv(() => build({
 			root: cwd,
 			base: "./",
@@ -131,10 +124,15 @@ async function buildClient(cwd, opts = {}) {
 /** Read a built client directory into an in-memory deploy payload. */
 async function readClientDir(clientDir) {
 	const files = {};
-	const entries = await fs.readdir(clientDir, {
-		recursive: true,
-		withFileTypes: true
-	});
+	let entries;
+	try {
+		entries = await fs.readdir(clientDir, {
+			recursive: true,
+			withFileTypes: true
+		});
+	} catch (err) {
+		throw new Error(`Client build produced no output at ${clientDir}: ${errorMessage(err)}`, { cause: err });
+	}
 	await Promise.all(entries.filter((entry) => entry.isFile()).map(async (entry) => {
 		const abs = path.join(entry.parentPath, entry.name);
 		const rel = path.relative(clientDir, abs).split(path.sep).join("/");

package/dist/client-bundler.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { t as buildClient } from "./client-bundler-Bki_Rned.mjs";
+import { t as buildClient } from "./client-bundler-VdcgFcos.mjs";
 export { buildClient };

package/dist/{delete-DE35s3d5.mjs → delete-xZ8PzM_4.mjs}

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
-import { i as ok } from "./_output-fy2bXRNb.mjs";
-import { n as log } from "./_ui-YqQ6Fi8K.mjs";
-import { r as getServerInfo } from "./_agent-cHGzbDVG.mjs";
-import { t as apiRequest } from "./_api-client-yJD7xGfd.mjs";
-//#region _delete.ts
+import { n as log, u as ok } from "./_ui-CKEIHAtB.mjs";
+import { n as getServerInfo } from "./_agent-Ba5Ykp05.mjs";
+import { t as apiRequest } from "./_api-client-a6cPMebU.mjs";
+//#region delete.ts
 async function runDelete(opts) {
 	await apiRequest(`${opts.url}/${opts.slug}`, {
 		method: "DELETE",
@@ -13,8 +12,6 @@ async function runDelete(opts) {
 		...opts.fetch ? { fetch: opts.fetch } : {}
 	});
 }
-//#endregion
-//#region delete.ts
 /** Execute delete and return structured result. */
 async function executeDelete(opts) {
 	const { cwd } = opts;

package/dist/{deploy-DOy6wOCd.mjs → deploy-Ds1spTPC.mjs}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { s as writeProjectConfig } from "./_config-zV70t71V.mjs";
-import { i as ok } from "./_output-fy2bXRNb.mjs";
-import { n as log, t as fmtUrl } from "./_ui-YqQ6Fi8K.mjs";
-import { a as resolveDeployTarget } from "./_agent-cHGzbDVG.mjs";
-import { buildAgentBundle } from "./_bundler-CpLVjRzc.mjs";
-import { t as resolveServerEnv } from "./_server-common-QpOTRZgi.mjs";
-import { t as apiRequest } from "./_api-client-yJD7xGfd.mjs";
+import { n as log, t as fmtUrl, u as ok } from "./_ui-CKEIHAtB.mjs";
+import { r as errorMessage } from "./_utils-ECl2je7-.mjs";
+import { buildAgentBundle } from "./_bundler-CKz9Q15i.mjs";
+import { o as writeProjectConfig } from "./_config-BMjZt5hG.mjs";
+import { t as resolveServerEnv } from "./_server-common-Bv-4Rskq.mjs";
+import { i as resolveDeployTarget } from "./_agent-Ba5Ykp05.mjs";
+import { t as apiRequest } from "./_api-client-a6cPMebU.mjs";
 import { gzipSync } from "node:zlib";
 //#region _deploy.ts
 async function runDeploy(opts) {
@@ -26,6 +26,8 @@ async function runDeploy(opts) {
 		apiKey: opts.apiKey,
 		action: "deploy",
 		hints: { 413: "Your bundle is too large. Try reducing dependencies or splitting your agent." },
+		...opts.slug ? {} : { retry: 0 },
+		...opts.retryDelay !== void 0 ? { retryDelay: opts.retryDelay } : {},
 		...opts.fetch ? { fetch: opts.fetch } : {}
 	})).slug };
 }
@@ -42,17 +44,25 @@ async function executeDeploy(opts) {
 		url: serverUrl,
 		bundle,
 		env: {
-			...env,
-			ASSEMBLYAI_API_KEY: apiKey
+			ASSEMBLYAI_API_KEY: apiKey,
+			...env
 		},
 		...slug ? { slug } : {},
 		apiKey
 	});
-	await writeProjectConfig(cwd, {
-		slug: deployed.slug,
-		serverUrl
-	});
 	const agentUrl = `${serverUrl}/${deployed.slug}`;
+	try {
+		await writeProjectConfig(cwd, {
+			slug: deployed.slug,
+			serverUrl
+		});
+	} catch (err) {
+		log.warn(`Deployed as ${deployed.slug}, but couldn't save .aai/project.json: ${errorMessage(err)}\n  Write it manually so future deploys reuse this slug:
+  ${JSON.stringify({
+			slug: deployed.slug,
+			serverUrl
+		})}`);
+	}
 	log.success(`Deployed ${fmtUrl(agentUrl)}`);
 	return ok({
 		slug: deployed.slug,

package/dist/{dev-DGzDKzGZ.mjs → dev-CtE0d-Gs.mjs}

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
-import { i as ok } from "./_output-fy2bXRNb.mjs";
-import { n as log, r as parsePort, t as fmtUrl } from "./_ui-YqQ6Fi8K.mjs";
-import { t as errorDetail } from "./_utils-BeU10C7O.mjs";
+import { n as log, r as parsePort, t as fmtUrl, u as ok } from "./_ui-CKEIHAtB.mjs";
+import { n as errorDetail } from "./_utils-ECl2je7-.mjs";
 import path from "node:path";
-import { colorize } from "consola/utils";
+import pc from "picocolors";
 //#region dev.ts
 /**
 * Start the dev server and return the result.
@@ -12,19 +11,27 @@ import { colorize } from "consola/utils";
 async function executeDev(opts) {
 	const port = parsePort(opts.port);
 	const agentName = path.basename(path.resolve(opts.cwd));
-	const { startDevServer } = await import("./_dev-server-8pf2tqvC.mjs");
-	const cleanup = await startDevServer({
+	const { startDevServer } = await import("./_dev-server-DZl-xNwH.mjs");
+	let cleanup;
+	let shuttingDown = false;
+	const onSignal = () => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		if (!cleanup) process.exit(130);
+		cleanup().then(() => process.exit(0), (err) => {
+			log.error(`Shutdown failed: ${errorDetail(err)}`);
+			process.exit(1);
+		});
+	};
+	process.on("SIGINT", onSignal);
+	process.on("SIGTERM", onSignal);
+	cleanup = await startDevServer({
 		cwd: opts.cwd,
 		port
 	});
 	const url = `http://localhost:${port}`;
-	log.success(`${colorize("bold", agentName)} running at ${fmtUrl(url)}`);
+	log.success(`${pc.bold(agentName)} running at ${fmtUrl(url)}`);
 	log.info("Press Ctrl-C to stop");
-	const onSignal = () => {
-		cleanup().finally(() => process.exit(0));
-	};
-	process.on("SIGINT", onSignal);
-	process.on("SIGTERM", onSignal);
 	process.on("unhandledRejection", (err) => {
 		log.error(`Unhandled rejection: ${errorDetail(err)}`);
 	});