@alexkroman1/aai-cli 1.8.3 → 1.9.0

package/dist/{_output-vvoR6N1x.mjs → _output-fy2bXRNb.mjs}

@@ -1,13 +1,5 @@
 #!/usr/bin/env node
-import { t as __exportAll } from "./rolldown-runtime-uZa2dNXj.mjs";
 //#region _output.ts
-var _output_exports = /* @__PURE__ */ __exportAll({
-	CliError: () => CliError,
-	fail: () => fail,
-	getOutputMode: () => getOutputMode,
-	ok: () => ok,
-	withOutput: () => withOutput
-});
 /**
 * Determine output mode from CLI flags and TTY state.
 *
@@ -21,19 +13,20 @@ function getOutputMode(args, isTTY = Boolean(process.stdout.isTTY)) {
 /**
 * Wrap a command function to handle output formatting.
 *
-* - `fn` does the work and returns a `CommandResult<T>`. It must not print.
-* - `humanRender` formats the result for human-readable TTY output.
+* - `fn` does the work and returns a `CommandResult<T>`. Human-readable
+*   output is printed inside `fn` itself.
 * - In JSON mode, writes exactly one JSON line to stdout.
 */
-async function withOutput(mode, fn, humanRender) {
+async function withOutput(mode, fn) {
 	const result = await fn();
-	if (mode === "json") {
-		process.stdout.write(`${JSON.stringify(result)}\n`);
-		if (!result.ok) process.exit(1);
-	} else {
-		humanRender(result);
-		if (!result.ok) process.exit(1);
-	}
+	if (mode === "json") await writeLine(`${JSON.stringify(result)}\n`);
+	if (!result.ok) process.exit(1);
+}
+/** Write a line to stdout, resolving only once it has been flushed. */
+function writeLine(line) {
+	return new Promise((resolve) => {
+		process.stdout.write(line, () => resolve());
+	});
 }
 /** Create an ok result. */
 function ok(data) {
@@ -67,4 +60,4 @@ var CliError = class extends Error {
 	}
 };
 //#endregion
-export { ok as a, getOutputMode as i, _output_exports as n, fail as r, CliError as t };
+export { withOutput as a, ok as i, fail as n, writeLine as o, getOutputMode as r, CliError as t };

package/dist/{_ui-nOp7hFVy.mjs → _ui-YqQ6Fi8K.mjs}

@@ -1,30 +1,24 @@
 #!/usr/bin/env node
-import { t as __exportAll } from "./rolldown-runtime-uZa2dNXj.mjs";
-import { log } from "@clack/prompts";
+import * as p from "@clack/prompts";
 import { colorize } from "consola/utils";
 //#region _ui.ts
-var _ui_exports = /* @__PURE__ */ __exportAll({
-	fmtUrl: () => fmtUrl,
-	log: () => log$1,
-	parsePort: () => parsePort,
-	silenceOutput: () => silenceOutput
-});
 const noop = () => {};
-let _delegate = log;
+let silenced = false;
 /** Log instance that delegates to clack (human mode) or no-ops (JSON mode). */
-const log$1 = new Proxy(log, { get(_target, prop, receiver) {
-	return Reflect.get(_delegate, prop, receiver);
+const log = new Proxy(p.log, { get(target, prop, receiver) {
+	return silenced ? noop : Reflect.get(target, prop, receiver);
 } });
 /** Replace all log methods with no-ops. Call once in JSON mode. */
 function silenceOutput() {
-	_delegate = {
-		info: noop,
-		success: noop,
-		error: noop,
-		warn: noop,
-		step: noop,
-		message: noop
-	};
+	silenced = true;
+}
+/** Unwrap a clack prompt result, exiting cleanly if the user cancelled. */
+function unwrapCancel(result) {
+	if (p.isCancel(result)) {
+		p.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	return result;
 }
 /** Format a URL for display. */
 function fmtUrl(url) {
@@ -37,4 +31,4 @@ function parsePort(raw) {
 	return port;
 }
 //#endregion
-export { silenceOutput as a, parsePort as i, fmtUrl as n, log$1 as r, _ui_exports as t };
+export { unwrapCancel as a, silenceOutput as i, log as n, parsePort as r, fmtUrl as t };

package/dist/_utils-BeU10C7O.mjs

@@ -0,0 +1,55 @@
+#!/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);
+}
+/** True when `err` is a filesystem EEXIST error (target already exists). */
+function isEexist(err) {
+	return err instanceof Error && "code" in err && err.code === "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 if the file is missing or malformed. */
+async function readJson(filePath) {
+	try {
+		return JSON.parse(await fs.readFile(filePath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+/** Write `data` as pretty-printed JSON (+ trailing newline), creating parent dirs. */
+async function writeJson(filePath, data) {
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}\n`);
+}
+//#endregion
+export { readJson as a, writeJson as c, isEexist as i, errorMessage as n, resolveCwd as o, fileExists as r, validateAgentExport as s, errorDetail as t };

package/dist/_vite-env-CmXG4ZAu.mjs

@@ -0,0 +1,31 @@
+#!/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.
+*/
+async function withPreservedNodeEnv(fn) {
+	const saved = process.env.NODE_ENV;
+	try {
+		return await fn();
+	} finally {
+		if (saved === void 0) delete process.env.NODE_ENV;
+		else process.env.NODE_ENV = saved;
+	}
+}
+//#endregion
+export { withPreservedNodeEnv as t };

package/dist/cli.mjs

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
-import { i as getOutputMode, r as fail, t as CliError } from "./_output-vvoR6N1x.mjs";
-import { a as silenceOutput } from "./_ui-nOp7hFVy.mjs";
-import { n as resolveCwd, t as fileExists } from "./_utils-DZo3_J_v.mjs";
+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 { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { errorMessage } from "@alexkroman1/aai";
 import { defineCommand, runMain } from "citty";
 //#region cli.ts
 /** Shared arg definitions for citty commands. */
@@ -57,26 +56,33 @@ async function handleErrors(mode, fn) {
 		const hint = err instanceof CliError ? err.hint : void 0;
 		if (mode === "json") {
 			const result = fail(code, errorMessage(err), hint);
-			process.stdout.write(`${JSON.stringify(result)}\n`);
+			await writeLine(`${JSON.stringify(result)}\n`);
 			process.exit(1);
 		}
-		const { log } = await import("./_ui-nOp7hFVy.mjs").then((n) => n.t);
 		log.error(errorMessage(err));
 		process.exit(1);
 	}
 }
 /**
 * Run a command body with standard error handling, output mode resolution, and withOutput wrapping.
-* `setYes` controls whether json mode sets `args.yes = true` (default true for most commands).
+*
+* - `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).
 */
 async function runCommand(args, fn, opts = {}) {
 	const mode = getOutputMode(args);
 	if (mode === "json") {
 		silenceOutput();
-		if (opts.setYes !== false) args.yes = true;
+		if (opts.setYes) args.yes = true;
 	}
-	const { withOutput } = await import("./_output-vvoR6N1x.mjs").then((n) => n.n);
-	await handleErrors(mode, () => withOutput(mode, () => fn(mode), () => {}));
+	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);
+	}));
 }
 const init = defineCommand({
 	meta: {
@@ -113,16 +119,18 @@ const init = defineCommand({
 	},
 	async run({ args }) {
 		await runCommand(args, async (mode) => {
-			const { executeInit } = await import("./init-GWTdzrrm.mjs");
+			const { executeInit } = await import("./init-kYsRaf7e.mjs");
 			return executeInit({
 				dir: args.dir,
 				force: args.force,
 				template: args.template,
 				yes: args.yes,
-				skipApi: args.skipApi,
 				skipDeploy: args.skipDeploy,
 				server: args.server
 			}, mode === "json" ? { silent: true } : void 0);
+		}, {
+			setYes: true,
+			apiKey: !args.skipApi
 		});
 	}
 });
@@ -133,14 +141,12 @@ const dev = defineCommand({
 	},
 	args: {
 		port: sharedArgs.port,
-		server: sharedArgs.server,
-		yes: sharedArgs.yes,
 		json: sharedArgs.json
 	},
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDev } = await import("./dev-D2EwGHYi.mjs");
+			const { executeDev } = await import("./dev-BvjnXK2x.mjs");
 			return executeDev({
 				cwd,
 				port: args.port
@@ -157,9 +163,9 @@ const test = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup();
-			const { executeTest } = await import("./test-BLYrV5ap.mjs");
+			const { executeTest } = await import("./test-C6jwCnFu.mjs");
 			return executeTest(cwd);
-		}, { setYes: false });
+		}, { apiKey: false });
 	}
 });
 const build = defineCommand({
@@ -168,8 +174,6 @@ const build = defineCommand({
 		description: "Bundle agent without deploying"
 	},
 	args: {
-		server: sharedArgs.server,
-		yes: sharedArgs.yes,
 		json: sharedArgs.json,
 		skipTests: {
 			type: "boolean",
@@ -180,12 +184,12 @@ const build = defineCommand({
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
 			if (!args.skipTests) {
-				const { runVitest } = await import("./test-BLYrV5ap.mjs");
+				const { runVitest } = await import("./test-C6jwCnFu.mjs");
 				runVitest(cwd);
 			}
-			const { executeBuild } = await import("./_bundler-CMMSjh9o.mjs");
+			const { executeBuild } = await import("./_bundler-BRQFvx00.mjs");
 			return executeBuild(cwd);
-		});
+		}, { apiKey: false });
 	}
 });
 const deploy = defineCommand({
@@ -195,13 +199,12 @@ const deploy = defineCommand({
 	},
 	args: {
 		server: sharedArgs.server,
-		yes: sharedArgs.yes,
 		json: sharedArgs.json
 	},
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDeploy } = await import("./deploy-D8uMWSDH.mjs");
+			const { executeDeploy } = await import("./deploy-C0LittrE.mjs");
 			return executeDeploy({
 				cwd,
 				...args.server ? { server: args.server } : {}
@@ -221,12 +224,12 @@ const del = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup();
-			const { executeDelete } = await import("./delete-BEC2ZXbk.mjs");
+			const { executeDelete } = await import("./delete-DE35s3d5.mjs");
 			return executeDelete({
 				cwd,
 				...args.server ? { server: args.server } : {}
 			});
-		}, { setYes: false });
+		});
 	}
 });
 const secret = defineCommand({
@@ -252,15 +255,11 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async (mode) => {
 					const cwd = await setup();
-					const { executeSecretPut, readStdin } = await import("./secret-DlSN4FdF.mjs");
+					const { executeSecretPut, readStdin } = await import("./secret-D-90QtDQ.mjs");
 					const value = mode === "json" ? await readStdin() : void 0;
-					if (mode === "json" && !value) {
-						const result = fail("no_input", "No value provided", "Pipe secret value to stdin");
-						process.stdout.write(`${JSON.stringify(result)}\n`);
-						process.exit(1);
-					}
+					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);
-				}, { setYes: false });
+				});
 			}
 		}),
 		delete: defineCommand({
@@ -280,9 +279,9 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretDelete } = await import("./secret-DlSN4FdF.mjs");
+					const { executeSecretDelete } = await import("./secret-D-90QtDQ.mjs");
 					return executeSecretDelete(cwd, args.name, args.server);
-				}, { setYes: false });
+				});
 			}
 		}),
 		list: defineCommand({
@@ -297,9 +296,9 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretList } = await import("./secret-DlSN4FdF.mjs");
+					const { executeSecretList } = await import("./secret-D-90QtDQ.mjs");
 					return executeSecretList(cwd, args.server);
-				}, { setYes: false });
+				});
 			}
 		})
 	}
@@ -322,7 +321,7 @@ const mainCommand = defineCommand({
 });
 if (process.env.VITEST !== "true") {
 	const sub = process.argv[2];
-	const helpFlags = new Set([
+	const helpFlags = /* @__PURE__ */ new Set([
 		"--help",
 		"--version",
 		"-h",
@@ -332,8 +331,10 @@ if (process.env.VITEST !== "true") {
 		const defaultCmd = existsSync(path.join(resolveCwd(), "agent.ts")) ? "deploy" : "init";
 		process.argv.splice(2, 0, defaultCmd);
 	}
-	const cmd = process.argv[2];
-	(helpFlags.has(cmd ?? "") || cmd === "test" || cmd === "build" ? Promise.resolve() : import("./_config-B0FXR5GQ.mjs").then((n) => n.t).then((m) => m.ensureApiKey())).then(() => runMain(mainCommand));
+	runMain(mainCommand).catch((err) => {
+		log.error(errorMessage(err));
+		process.exitCode = 1;
+	});
 }
 //#endregion
 export { mainCommand };

package/dist/client-bundler-D4VKqCxw.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { r as fileExists } from "./_utils-BeU10C7O.mjs";
+import { t as withPreservedNodeEnv } from "./_vite-env-CmXG4ZAu.mjs";
+import { existsSync, unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { isTextAssetPath } from "@alexkroman1/aai";
+import { build } from "vite";
+//#region _default-html.ts
+/**
+* Default index.html for agents with a custom client.tsx but no index.html.
+* Used by both the dev server (Vite HMR) and the production bundler.
+* Users can override by placing their own index.html in the project root.
+*/
+const DEFAULT_HTML = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
+    <title>aai</title>
+    <link rel="icon" href="data:," />
+    <style>html, body { background: #FBF8F2; margin: 0; }</style>
+  </head>
+  <body>
+    <main id="app"></main>
+    <script type="module" src="./client.tsx"><\/script>
+  </body>
+</html>`;
+/**
+* Vite plugin that serves a fallback index.html in dev mode when one doesn't
+* exist on disk. No-op if index.html exists (user override).
+*/
+function fallbackHtmlPlugin(root) {
+	const htmlExists = existsSync(path.join(root, "index.html"));
+	return {
+		name: "aai-fallback-html",
+		configureServer(server) {
+			if (htmlExists) return;
+			server.middlewares.use((req, res, next) => {
+				if (req.url === "/" || req.url === "/index.html") {
+					server.transformIndexHtml("/", DEFAULT_HTML, req.originalUrl).then((html) => {
+						res.setHeader("Content-Type", "text/html");
+						res.end(html);
+					}, next);
+					return;
+				}
+				next();
+			});
+		}
+	};
+}
+/**
+* Write a temporary index.html for Vite build (HTML must be on disk for build).
+* Returns a cleanup function to remove it. No-op if index.html already exists.
+*/
+function writeTempHtml(root) {
+	const htmlPath = path.join(root, "index.html");
+	if (existsSync(htmlPath)) return () => {};
+	writeFileSync(htmlPath, DEFAULT_HTML);
+	return () => {
+		try {
+			unlinkSync(htmlPath);
+		} catch {}
+	};
+}
+//#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";
+/**
+* Build the client SPA with Vite if `client.tsx` exists.
+* Returns a map of relative file paths to string contents for deploy,
+* or `{}` when the project has no `client.tsx`.
+*/
+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);
+	try {
+		await withPreservedNodeEnv(() => build({
+			root: cwd,
+			base: "./",
+			logLevel: "silent",
+			...opts.configFile === false && { configFile: false },
+			...opts.plugins && { plugins: opts.plugins },
+			build: {
+				outDir,
+				emptyOutDir: true
+			}
+		}));
+	} finally {
+		cleanupHtml();
+	}
+	return readClientDir(clientDir);
+}
+/** 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
+	});
+	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("/");
+		files[rel] = isTextAssetPath(rel) ? await fs.readFile(abs, "utf-8") : (await fs.readFile(abs)).toString("base64");
+	}));
+	return files;
+}
+//#endregion
+export { fallbackHtmlPlugin as n, buildClient as t };

package/dist/client-bundler.mjs

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

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

@@ -1,17 +1,16 @@
 #!/usr/bin/env node
-import { a as ok } from "./_output-vvoR6N1x.mjs";
-import { r as log } from "./_ui-nOp7hFVy.mjs";
-import { getServerInfo } from "./_agent-De8f1JdZ.mjs";
-import { t as apiRequestOrThrow } from "./_api-client-Cf9Lv2Rw.mjs";
+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
 async function runDelete(opts) {
-	await apiRequestOrThrow(`${opts.url}/${opts.slug}`, {
+	await apiRequest(`${opts.url}/${opts.slug}`, {
 		method: "DELETE",
 		apiKey: opts.apiKey,
-		action: "delete"
-	}, {
+		action: "delete",
 		hints: { 404: "The agent may not be deployed. Check `.aai/project.json` for the correct slug." },
-		fetch: opts.fetch
+		...opts.fetch ? { fetch: opts.fetch } : {}
 	});
 }
 //#endregion

package/dist/{deploy-D8uMWSDH.mjs → deploy-C0LittrE.mjs}

@@ -1,39 +1,41 @@
 #!/usr/bin/env node
-import { a as ok } from "./_output-vvoR6N1x.mjs";
-import { n as fmtUrl, r as log } from "./_ui-nOp7hFVy.mjs";
-import { i as writeProjectConfig, n as ensureApiKey, r as readProjectConfig } from "./_config-B0FXR5GQ.mjs";
-import { resolveServerUrl } from "./_agent-De8f1JdZ.mjs";
-import { buildAgentBundle } from "./_bundler-CMMSjh9o.mjs";
-import { t as resolveServerEnv } from "./_server-common-BVkNI-o4.mjs";
-import { t as apiRequestOrThrow } from "./_api-client-Cf9Lv2Rw.mjs";
+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-BRQFvx00.mjs";
+import { t as resolveServerEnv } from "./_server-common-QpOTRZgi.mjs";
+import { t as apiRequest } from "./_api-client-yJD7xGfd.mjs";
+import { gzipSync } from "node:zlib";
 //#region _deploy.ts
 async function runDeploy(opts) {
-	const body = JSON.stringify({
+	const body = gzipSync(JSON.stringify({
 		...opts.slug ? { slug: opts.slug } : {},
 		env: opts.env,
 		worker: opts.bundle.worker,
 		clientFiles: opts.bundle.clientFiles,
 		agentConfig: opts.bundle.agentConfig
-	});
-	return { slug: (await (await apiRequestOrThrow(`${opts.url}/deploy`, {
+	}));
+	return { slug: (await apiRequest(`${opts.url}/deploy`, {
 		method: "POST",
 		body,
+		headers: {
+			"Content-Type": "application/json",
+			"Content-Encoding": "gzip"
+		},
 		apiKey: opts.apiKey,
-		action: "deploy"
-	}, {
+		action: "deploy",
 		hints: { 413: "Your bundle is too large. Try reducing dependencies or splitting your agent." },
-		fetch: opts.fetch
-	})).json()).slug };
+		...opts.fetch ? { fetch: opts.fetch } : {}
+	})).slug };
 }
 //#endregion
 //#region deploy.ts
 async function executeDeploy(opts) {
 	const { cwd } = opts;
-	const projectConfig = await readProjectConfig(cwd);
-	const serverUrl = resolveServerUrl(opts.server, projectConfig?.serverUrl);
-	const bundle = await buildAgentBundle(cwd);
+	const { config: projectConfig, serverUrl, apiKey } = await resolveDeployTarget(cwd, opts.server);
+	const bundle = await buildAgentBundle(cwd, { minify: true });
 	const slug = projectConfig?.slug;
-	const apiKey = await ensureApiKey();
 	const env = await resolveServerEnv(cwd);
 	log.step(`Deploying${slug ? ` ${slug}` : ""}…`);
 	const deployed = await runDeploy({

package/dist/{dev-D2EwGHYi.mjs → dev-BvjnXK2x.mjs}

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { a as ok } from "./_output-vvoR6N1x.mjs";
-import { i as parsePort, n as fmtUrl, r as log } from "./_ui-nOp7hFVy.mjs";
+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 path from "node:path";
 import { colorize } from "consola/utils";
 //#region dev.ts
@@ -11,7 +12,7 @@ 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-DMFyqc9v.mjs");
+	const { startDevServer } = await import("./_dev-server-CBrIeDoI.mjs");
 	const cleanup = await startDevServer({
 		cwd: opts.cwd,
 		port
@@ -24,6 +25,12 @@ async function executeDev(opts) {
 	};
 	process.on("SIGINT", onSignal);
 	process.on("SIGTERM", onSignal);
+	process.on("unhandledRejection", (err) => {
+		log.error(`Unhandled rejection: ${errorDetail(err)}`);
+	});
+	process.on("uncaughtException", (err) => {
+		log.error(`Uncaught exception: ${errorDetail(err)}`);
+	});
 	return ok({ url });
 }
 //#endregion