@alexkroman1/aai-cli 4.0.0 → 5.0.1

package/dist/{_agent-dJAeDb38.mjs → _agent-D39qatZJ.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as serverOrigin, i as readProjectConfig, n as ensureApiKey, r as readGlobalConfig, t as approveServer } from "./_config-B7Ywbpfb.mjs";
+import { a as serverOrigin, i as readProjectConfig, n as ensureApiKey, r as readGlobalConfig, t as approveServer } from "./_config-Czjhvaax.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/_bundler-DdmuZzeR.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import { n as log, u as ok } from "./_ui-DXZ9prrM.mjs";
+import { c as validateAgentExport } from "./_utils-C502jKo8.mjs";
+import { t as buildClient } from "./client-bundler-DO3GgO6p.mjs";
+import { buildWorker } from "./worker-bundler.mjs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { hash } from "node:crypto";
+import { tmpdir } from "node:os";
+//#region _bundler.ts
+/**
+* Bundle an agent directory: build agent.ts into worker ESM + client files.
+*
+* agent.ts is the single entry point: `export default agent({...})`. The
+* worker self-describes (it exports `__aaiConfig` — see `worker-bundler.ts`),
+* so nothing here evaluates the bundle: the server extracts the config inside
+* a guest sandbox at deploy time.
+*/
+async function buildAgentBundle(cwd, opts = {}) {
+	const [worker, clientFiles] = await Promise.all([buildWorker(cwd, opts), buildClient(cwd)]);
+	return {
+		worker,
+		clientFiles
+	};
+}
+/**
+* Import the worker ESM from a uniquely named temp file and return the
+* AgentDef default export. A real `file:` URL, not a `data:` URL: deploy
+* bundles ship the SDK runtime, whose CJS interop calls
+* `createRequire(import.meta.url)` — which rejects anything that isn't a
+* file URL or absolute path. (The guest harness imports bundles the same
+* way, for the same reason.) The file is removed after import; the module
+* lives on in memory.
+*
+* Each call imports a unique URL, and Node's ESM registry never evicts — so
+* every call retains one bundle for the process lifetime. That is fine for
+* one-shot commands (`aai build`); long-lived callers must go through
+* `createWorkerEvaluator` to at least dedupe identical builds. Evaluating in
+* a discardable context is not an option: tool `execute` functions from the
+* returned AgentDef are called in-process by the dev runtime, which rules
+* out worker threads, and `node:vm` ESM evaluation is still flagged
+* experimental.
+*/
+async function evalWorkerBundle(code) {
+	const dir = await mkdtemp(path.join(tmpdir(), "aai-worker-"));
+	const file = path.join(dir, "worker.mjs");
+	let mod;
+	try {
+		await writeFile(file, code, "utf-8");
+		mod = await import(pathToFileURL(file).href);
+	} finally {
+		await rm(dir, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+	}
+	const agentDef = mod.default ?? mod;
+	validateAgentExport(agentDef);
+	return agentDef;
+}
+/**
+* Memoizing wrapper around `evalWorkerBundle` for long-lived callers (the
+* dev server): byte-identical worker code returns the previously evaluated
+* AgentDef without touching the ESM registry. No-op saves and formatter
+* churn are the common watcher events, so this caps the registry leak (see
+* `evalWorkerBundle`) to genuinely-new bundles — the residual one-module-per-
+* distinct-build leak is accepted for the reasons documented there.
+*/
+function createWorkerEvaluator() {
+	let lastHash;
+	let lastAgentDef;
+	return async (code) => {
+		const codeHash = hash("sha256", code);
+		if (lastAgentDef && codeHash === lastHash) return lastAgentDef;
+		const agentDef = await evalWorkerBundle(code);
+		lastHash = codeHash;
+		lastAgentDef = agentDef;
+		return agentDef;
+	};
+}
+async function executeBuild(cwd) {
+	const bundle = await buildAgentBundle(cwd, { minify: true });
+	const agentDef = await evalWorkerBundle(bundle.worker);
+	log.success("Build complete");
+	return ok({
+		name: agentDef.name,
+		workerBytes: bundle.worker.length
+	});
+}
+//#endregion
+export { buildAgentBundle, createWorkerEvaluator, executeBuild };

package/dist/{_config-B7Ywbpfb.mjs → _config-Czjhvaax.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as unwrapCancel, n as log, o as CliError } from "./_ui-CKEIHAtB.mjs";
+import { a as unwrapCancel, n as log, o as CliError } from "./_ui-DXZ9prrM.mjs";
 import { l as writeJson, o as readJson, r as errorMessage } from "./_utils-C502jKo8.mjs";
 import path from "node:path";
 import * as p from "@clack/prompts";

package/dist/{_dev-server-DvcbFgos.mjs → _dev-server-BCbEUhmv.mjs}

@@ -1,129 +1,19 @@
 #!/usr/bin/env node
-import { n as log } from "./_ui-CKEIHAtB.mjs";
+import { n as log } from "./_ui-DXZ9prrM.mjs";
 import { r as errorMessage, t as errorCode } from "./_utils-C502jKo8.mjs";
 import { n as fallbackHtmlPlugin } from "./client-bundler-DO3GgO6p.mjs";
 import { buildWorker } from "./worker-bundler.mjs";
-import { createWorkerEvaluator } from "./_bundler-DnZnKsIU.mjs";
-import { n as ensureApiKey } from "./_config-B7Ywbpfb.mjs";
-import { t as resolveServerEnv } from "./_server-common-CpVD57yn.mjs";
+import { createWorkerEvaluator } from "./_bundler-DdmuZzeR.mjs";
+import { n as ensureApiKey } from "./_config-Czjhvaax.mjs";
+import { t as resolveServerEnv } from "./_server-common-B75oco06.mjs";
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
 import path from "node:path";
-import fs from "node:fs/promises";
+import { setTimeout } from "node:timers/promises";
 import { requiredProviderEnvVars, withHostCredentialFallback } from "@alexkroman1/aai/runtime";
 import { watch } from "chokidar";
 import getPort, { portNumbers } from "get-port";
 import pDebounce from "p-debounce";
-//#region _dev-bundler.ts
-/**
-* Fast worker builds for `aai dev`.
-*
-* The deploy path (`buildWorker` in `worker-bundler.ts`) is a full Vite
-* pipeline pass — right for a one-shot `aai deploy`, but 1–3 s per save when
-* the dev watcher runs it on every change. This module builds with Rolldown
-* directly (the native bundler Vite 8 itself runs on, so it adds no install
-* weight), skipping Vite's config/plugin/CSS machinery: a from-scratch build
-* of a typical agent lands in tens of ms. Deploy keeps Vite untouched, so
-* nothing that ships is produced by this path.
-*
-* Parity with `buildWorker` where it matters for dev:
-*
-* - single-file ESM output, unminified (dev builds never minify);
-* - `node:` builtins external (Rolldown's `platform: "node"`), everything
-*   else — zod, workspace deps, local imports — bundled in;
-* - `.md` imports resolve to their raw text (`mdPlugin` below is
-*   `rawMdPlugin`'s transform), and Vite-style `?raw` suffix imports are
-*   honored via `rawSuffixPlugin`.
-*
-* Known dev/deploy differences, accepted: Vite's lib build applies
-* `define`/`import.meta.env` replacements this path does not. When a build
-* fails for anything other than a compile error in the agent's code, the
-* caller falls back to the cold Vite path (see `_dev-server.ts`), so a
-* resolution gap here degrades to the old slow-but-correct behavior rather
-* than a broken dev server.
-*
-* Rolldown does not touch `process.env` the way Vite's `build()` does, so
-* the `withPreservedNodeEnv` wrapper Vite builds need is not required here.
-*/
-const RAW_NAMESPACE = "\0aai-raw:";
-/**
-* Vite serves `import x from "./file?raw"` as the file's text. Rolldown
-* treats the suffix as part of the filename, so resolve it explicitly and
-* load the real file as a string export.
-*/
-const rawSuffixPlugin = {
-	name: "aai-raw-suffix",
-	resolveId: {
-		filter: { id: /\?raw$/ },
-		handler(id, importer) {
-			const file = id.slice(0, -4);
-			const base = importer ? path.dirname(importer) : process.cwd();
-			return RAW_NAMESPACE + path.resolve(base, file);
-		}
-	},
-	load: {
-		filter: { id: new RegExp(`^${RAW_NAMESPACE}`) },
-		async handler(id) {
-			const text = await fs.readFile(id.slice(9), "utf8");
-			return `export default ${JSON.stringify(text)};`;
-		}
-	}
-};
-/** `.md` imports resolve to their raw text (rawMdPlugin parity). */
-const mdPlugin = {
-	name: "aai-raw-md",
-	load: {
-		filter: { id: /\.md$/ },
-		async handler(id) {
-			const text = await fs.readFile(id, "utf8");
-			return `export default ${JSON.stringify(text)};`;
-		}
-	}
-};
-/**
-* True for bundler build failures — compile/resolve errors in the code being
-* built (Rolldown aggregates its diagnostics onto an `errors` array, the same
-* shape esbuild used). Anything else coming out of `build()` is a
-* bundler-infrastructure problem, which callers treat as "fall back to the
-* cold Vite path" rather than "the user's code is broken".
-*/
-function isBundlerBuildFailure(err) {
-	return err instanceof Error && "errors" in err && Array.isArray(err.errors);
-}
-/**
-* Create a dev builder for the agent at `cwd`.
-*
-* Each `build()` is a from-scratch Rolldown pass — native-code bundling is
-* fast enough (tens of ms for a typical agent) that no incremental context
-* is worth holding between saves. `dispose()` exists for interface parity
-* with resource-holding builders and is a no-op.
-*/
-function createDevWorkerBuilder(cwd) {
-	return {
-		async build() {
-			const { rolldown } = await import("rolldown");
-			const bundle = await rolldown({
-				input: path.join(cwd, "agent.ts"),
-				cwd,
-				platform: "node",
-				logLevel: "silent",
-				plugins: [rawSuffixPlugin, mdPlugin]
-			});
-			try {
-				const file = (await bundle.generate({
-					format: "esm",
-					minify: false
-				})).output[0];
-				if (!file) throw new Error("Rolldown produced no output for agent.ts");
-				return file.code;
-			} finally {
-				await bundle.close().catch(() => void 0);
-			}
-		},
-		async dispose() {}
-	};
-}
-//#endregion
 //#region _dev-server.ts
 /**
 * Dev server for directory-based agents.
@@ -133,12 +23,36 @@ function createDevWorkerBuilder(cwd) {
 * file changes and restarts automatically. Optionally runs Vite for
 * client SPA HMR.
 */
+/**
+* Warnings about the agent's credentials, computed against the `.env`-derived
+* env and the shell. Pure so it is directly testable; `resolveAgentEnv` logs
+* each entry. Three cases, in increasing subtlety:
+*
+* - a provider key found nowhere → the first session will fail auth;
+* - a provider key found only in the shell → works here (the
+*   `withHostCredentialFallback` ergonomic) but is invisible to `aai deploy`,
+*   which uploads `.env` — the classic "works locally, dead on deploy";
+* - a declared `requiredEnv` key absent from `.env` → `ctx.env` won't contain
+*   it at all: custom keys never fall back to the shell, so a shell export
+*   can't mask one that would be missing both here and after deploy.
+*/
+function agentEnvWarnings(agentDef, env, shellEnv = process.env) {
+	const s = (names) => names.length > 1 ? "s" : "";
+	const them = (names) => names.length > 1 ? "them" : "it";
+	const required = requiredProviderEnvVars(agentDef);
+	const warnings = [];
+	const missing = required.filter((name) => !(env[name] || shellEnv[name]));
+	if (missing.length > 0) warnings.push(`Missing provider credential${s(missing)}: ${missing.join(", ")}. Set ${them(missing)} in .env or the environment.`);
+	const shellOnly = required.filter((name) => !env[name] && shellEnv[name]);
+	if (shellOnly.length > 0) warnings.push(`${shellOnly.join(", ")} resolved from your shell, not .env — deployed agents won't have ${them(shellOnly)}. Declare ${them(shellOnly)} in .env before \`aai deploy\`.`);
+	const declared = (agentDef.requiredEnv ?? []).filter((name) => !env[name]);
+	if (declared.length > 0) warnings.push(`Missing requiredEnv key${s(declared)} declared by the agent: ${declared.join(", ")}. Set ${them(declared)} in .env — ctx.env will not contain ${them(declared)} otherwise.`);
+	return warnings;
+}
 async function resolveAgentEnv(root, agentDef) {
 	const env = await resolveServerEnv(root);
-	const required = requiredProviderEnvVars(agentDef);
-	if (required.includes("ASSEMBLYAI_API_KEY") && !env.ASSEMBLYAI_API_KEY) env.ASSEMBLYAI_API_KEY = await ensureApiKey();
-	const missing = required.filter((name) => !(env[name] || process.env[name]));
-	if (missing.length > 0) log.warn(`Missing provider credential${missing.length > 1 ? "s" : ""}: ${missing.join(", ")}. Set ${missing.length > 1 ? "them" : "it"} in .env or the environment.`);
+	if (requiredProviderEnvVars(agentDef).includes("ASSEMBLYAI_API_KEY") && !env.ASSEMBLYAI_API_KEY) env.ASSEMBLYAI_API_KEY = await ensureApiKey();
+	for (const warning of agentEnvWarnings(agentDef, env)) log.warn(warning);
 	return env;
 }
 /**
@@ -170,23 +84,14 @@ function devBindHost() {
 * stay in Node's ESM registry, so edits to them are ignored on reload.
 * Bundling picks them up.
 *
-* The bundle comes from the fast Rolldown builder (`_dev-bundler.ts`)
-* rather than the deploy path's cold Vite build — a save rebuilds in tens of
-* ms instead of 1–3 s. Compile errors in the agent's code propagate (the
-* restart loop reports them and keeps the old server); any other builder
-* failure falls back to the cold Vite build so a Rolldown-specific gap can't
-* take the dev loop down. Evaluation goes through the memoizing evaluator so
+* The bundle comes from the same Vite pass deploy runs (`buildWorker`), so
+* dev and deploy can't drift; a warm rebuild is well under 100ms. Compile
+* errors in the agent's code propagate — the restart loop reports them and
+* keeps the old server. Evaluation goes through the memoizing evaluator so
 * a no-op save doesn't leak another module into the ESM registry.
 */
-async function loadAgentDefWith(cwd, builder, evaluate) {
-	let code;
-	try {
-		code = await builder.build();
-	} catch (err) {
-		if (isBundlerBuildFailure(err)) throw err;
-		code = await buildWorker(cwd);
-	}
-	return evaluate(code);
+async function loadAgentDef(cwd, evaluate) {
+	return evaluate(await buildWorker(cwd, { runtime: false }));
 }
 /**
 * True for paths that should never trigger a restart: anything inside
@@ -283,11 +188,10 @@ async function startDevServer(opts) {
 	const backendPort = hasClient ? await getPort({ port: portNumbers(port + 1, port + 100) }) : port;
 	const vitePort = port;
 	const clientDirOpt = hasClient ? {} : { clientDir: resolveDefaultClientDir() };
-	const devBuilder = createDevWorkerBuilder(cwd);
-	const evaluateWorker = createWorkerEvaluator(cwd);
+	const evaluateWorker = createWorkerEvaluator();
 	/** Full build sequence, shared by initial startup and every restart. */
 	async function buildServer() {
-		const agentDef = await loadAgentDefWith(cwd, devBuilder, evaluateWorker);
+		const agentDef = await loadAgentDef(cwd, evaluateWorker);
 		const env = await resolveAgentEnv(cwd, agentDef);
 		const providerEnv = withHostCredentialFallback(env);
 		const runtime = createRuntime({
@@ -335,7 +239,6 @@ async function startDevServer(opts) {
 		}
 	} catch (err) {
 		await watcher.close().catch(() => void 0);
-		await devBuilder.dispose().catch(() => void 0);
 		await viteServer?.close().catch(() => void 0);
 		throw err;
 	}
@@ -389,7 +292,7 @@ async function startDevServer(opts) {
 			return;
 		} catch (err) {
 			if (attempt >= LISTEN_ATTEMPTS || closed) throw err;
-			await new Promise((resolve) => setTimeout(resolve, LISTEN_RETRY_DELAY_MS));
+			await setTimeout(LISTEN_RETRY_DELAY_MS);
 		}
 	}
 	let cleanupPromise;
@@ -397,7 +300,6 @@ async function startDevServer(opts) {
 		cleanupPromise ??= (async () => {
 			closed = true;
 			await watcher.close().catch(() => void 0);
-			await devBuilder.dispose().catch(() => void 0);
 			await viteServer?.close().catch(() => void 0);
 			await currentServer.close().catch(() => void 0);
 		})();

package/dist/{_init-B-Fd6Lm4.mjs → _init-H-lw7czL.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { a as isEexist, l as writeJson, o as readJson, r as errorMessage } from "./_utils-C502jKo8.mjs";
-import { r as isDevMode, t as getMonorepoRoot } from "./_agent-dJAeDb38.mjs";
+import { r as isDevMode, t as getMonorepoRoot } from "./_agent-D39qatZJ.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import fs from "node:fs/promises";

package/dist/_typecheck-gate-B1GcKZX-.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { n as log, o as CliError } from "./_ui-DXZ9prrM.mjs";
+import { typecheckProject } from "./typecheck.mjs";
+//#region _typecheck-gate.ts
+/**
+* The build/deploy typecheck gate: run the project's own `tsc --noEmit`
+* (see `typecheck.ts`) and turn a failure into a structured CliError. The
+* bundlers strip types unchecked, so without this a type-broken agent
+* ships and misbehaves at runtime instead of failing here.
+*/
+async function assertTypechecks(cwd) {
+	log.step("Type checking…");
+	const result = await typecheckProject(cwd);
+	if (!result.ok) throw new CliError("typecheck_failed", result.output, "Fix the type errors, or pass --skipTypecheck to build anyway");
+}
+//#endregion
+export { assertTypechecks };

package/dist/{_ui-CKEIHAtB.mjs → _ui-DXZ9prrM.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
+import { styleText } from "node:util";
 import * as p from "@clack/prompts";
-import pc from "picocolors";
 //#region _output.ts
 /**
 * Determine output mode from CLI flags and TTY state.
@@ -93,7 +93,7 @@ function unwrapCancel(result) {
 }
 /** Format a URL for display. */
 function fmtUrl(url) {
-	return pc.cyanBright(url);
+	return styleText("cyanBright", url);
 }
 /**
 * Parse and validate a port string. Returns the numeric port or throws.

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-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 { c as getOutputMode, d as writeLine, i as silenceOutput, l as installStdoutGuard, n as log, o as CliError, s as fail } from "./_ui-DXZ9prrM.mjs";
 import { i as fileExists, r as errorMessage, s as resolveCwd } from "./_utils-C502jKo8.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
@@ -115,7 +115,7 @@ const init = defineCommand({
 	},
 	async run({ args }) {
 		await runCommand(args, async (mode) => {
-			const { executeInit } = await import("./init-Dn3RNhsR.mjs");
+			const { executeInit } = await import("./init-B53rR3yD.mjs");
 			return executeInit({
 				dir: args.dir,
 				force: args.force,
@@ -139,7 +139,7 @@ const dev = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDev } = await import("./dev-CQPY9Cfx.mjs");
+			const { executeDev } = await import("./dev-C8o-p13B.mjs");
 			return executeDev({
 				cwd,
 				port: args.port
@@ -156,7 +156,7 @@ const test = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup();
-			const { executeTest } = await import("./test-B3BkLNn_.mjs");
+			const { executeTest } = await import("./test-CgWhus_Z.mjs");
 			return executeTest(cwd);
 		});
 	}
@@ -171,13 +171,17 @@ const build = defineCommand({
 		skipTests: {
 			type: "boolean",
 			description: "Skip running tests before build"
+		},
+		skipTypecheck: {
+			type: "boolean",
+			description: "Skip type checking before build"
 		}
 	},
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
 			if (!args.skipTests) {
-				const { classifyVitestError, runVitest } = await import("./test-B3BkLNn_.mjs");
+				const { classifyVitestError, runVitest } = await import("./test-CgWhus_Z.mjs");
 				const toCliError = (err) => {
 					const { code, message } = classifyVitestError(err);
 					return new CliError(code, message, "Re-run with --skipTests to build without tests", { cause: err });
@@ -188,7 +192,11 @@ const build = defineCommand({
 					throw toCliError(err);
 				}
 			}
-			const { executeBuild } = await import("./_bundler-DnZnKsIU.mjs");
+			if (!args.skipTypecheck) {
+				const { assertTypechecks } = await import("./_typecheck-gate-B1GcKZX-.mjs");
+				await assertTypechecks(cwd);
+			}
+			const { executeBuild } = await import("./_bundler-DdmuZzeR.mjs");
 			return executeBuild(cwd);
 		});
 	}
@@ -200,15 +208,25 @@ const deploy = defineCommand({
 	},
 	args: {
 		server: sharedArgs.server,
-		json: sharedArgs.json
+		json: sharedArgs.json,
+		allowMissingSecrets: {
+			type: "boolean",
+			description: "Deploy even when the agent's providers are missing credentials (the server warns instead of rejecting; set them afterwards with `aai secret put`)"
+		},
+		skipTypecheck: {
+			type: "boolean",
+			description: "Skip type checking before deploy"
+		}
 	},
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDeploy } = await import("./deploy-DzGsORJx.mjs");
+			const { executeDeploy } = await import("./deploy-D-dnt9L8.mjs");
 			return executeDeploy({
 				cwd,
-				...args.server ? { server: args.server } : {}
+				...args.server ? { server: args.server } : {},
+				...args.allowMissingSecrets ? { allowMissingSecrets: true } : {},
+				...args.skipTypecheck ? { skipTypecheck: true } : {}
 			});
 		});
 	}
@@ -225,7 +243,7 @@ const del = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup();
-			const { executeDelete } = await import("./delete-Br2Jj28e.mjs");
+			const { executeDelete } = await import("./delete-K24hW1ab.mjs");
 			return executeDelete({
 				cwd,
 				...args.server ? { server: args.server } : {}
@@ -256,7 +274,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async (mode) => {
 					const cwd = await setup();
-					const { executeSecretPut, readStdin } = await import("./secret-DTH-dXnP.mjs");
+					const { executeSecretPut, readStdin } = await import("./secret-C4unwCEw.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);
@@ -280,7 +298,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretDelete } = await import("./secret-DTH-dXnP.mjs");
+					const { executeSecretDelete } = await import("./secret-C4unwCEw.mjs");
 					return executeSecretDelete(cwd, args.name, args.server);
 				});
 			}
@@ -297,7 +315,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretList } = await import("./secret-DTH-dXnP.mjs");
+					const { executeSecretList } = await import("./secret-C4unwCEw.mjs");
 					return executeSecretList(cwd, args.server);
 				});
 			}
@@ -332,7 +350,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageStatus } = await import("./storage-DOtoALnS.mjs");
+					const { executeStorageStatus } = await import("./storage-tZM1J8qj.mjs");
 					return executeStorageStatus(resolveStorageCwd(args.dir), args.server);
 				});
 			}
@@ -349,7 +367,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageEnable } = await import("./storage-DOtoALnS.mjs");
+					const { executeStorageEnable } = await import("./storage-tZM1J8qj.mjs");
 					return executeStorageEnable(resolveStorageCwd(args.dir), args.server);
 				});
 			}
@@ -371,7 +389,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageDisable } = await import("./storage-DOtoALnS.mjs");
+					const { executeStorageDisable } = await import("./storage-tZM1J8qj.mjs");
 					return executeStorageDisable(resolveStorageCwd(args.dir), {
 						server: args.server,
 						force: args.force

package/dist/{delete-Br2Jj28e.mjs → delete-K24hW1ab.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { n as log, u as ok } from "./_ui-CKEIHAtB.mjs";
-import { n as getServerInfo } from "./_agent-dJAeDb38.mjs";
+import { n as log, u as ok } from "./_ui-DXZ9prrM.mjs";
+import { n as getServerInfo } from "./_agent-D39qatZJ.mjs";
 import { t as apiRequest } from "./_api-client-a6cPMebU.mjs";
 //#region delete.ts
 async function runDelete(opts) {

package/dist/{deploy-DzGsORJx.mjs → deploy-D-dnt9L8.mjs}

@@ -1,22 +1,23 @@
 #!/usr/bin/env node
-import { n as log, t as fmtUrl, u as ok } from "./_ui-CKEIHAtB.mjs";
+import { n as log, t as fmtUrl, u as ok } from "./_ui-DXZ9prrM.mjs";
 import { r as errorMessage } from "./_utils-C502jKo8.mjs";
-import { buildAgentBundle } from "./_bundler-DnZnKsIU.mjs";
-import { o as writeProjectConfig } from "./_config-B7Ywbpfb.mjs";
-import { t as resolveServerEnv } from "./_server-common-CpVD57yn.mjs";
-import { i as resolveDeployTarget } from "./_agent-dJAeDb38.mjs";
+import { buildAgentBundle } from "./_bundler-DdmuZzeR.mjs";
+import { o as writeProjectConfig } from "./_config-Czjhvaax.mjs";
+import { t as resolveServerEnv } from "./_server-common-B75oco06.mjs";
+import { i as resolveDeployTarget } from "./_agent-D39qatZJ.mjs";
+import { assertTypechecks } from "./_typecheck-gate-B1GcKZX-.mjs";
 import { t as apiRequest } from "./_api-client-a6cPMebU.mjs";
 import { gzipSync } from "node:zlib";
 //#region _deploy.ts
 async function runDeploy(opts) {
 	const body = gzipSync(JSON.stringify({
 		...opts.slug ? { slug: opts.slug } : {},
+		...opts.allowMissingSecrets ? { credentialPolicy: "warn" } : {},
 		env: opts.env,
 		worker: opts.bundle.worker,
-		clientFiles: opts.bundle.clientFiles,
-		agentConfig: opts.bundle.agentConfig
+		clientFiles: opts.bundle.clientFiles
 	}));
-	return { slug: (await apiRequest(`${opts.url}/deploy`, {
+	const data = await apiRequest(`${opts.url}/deploy`, {
 		method: "POST",
 		body,
 		headers: {
@@ -29,13 +30,18 @@ async function runDeploy(opts) {
 		...opts.slug ? {} : { retry: 0 },
 		...opts.retryDelay !== void 0 ? { retryDelay: opts.retryDelay } : {},
 		...opts.fetch ? { fetch: opts.fetch } : {}
-	})).slug };
+	});
+	return {
+		slug: data.slug,
+		...data.warnings ? { warnings: data.warnings } : {}
+	};
 }
 //#endregion
 //#region deploy.ts
 async function executeDeploy(opts) {
 	const { cwd } = opts;
 	const { config: projectConfig, serverUrl, apiKey } = await resolveDeployTarget(cwd, opts.server);
+	if (!opts.skipTypecheck) await assertTypechecks(cwd);
 	const bundle = await buildAgentBundle(cwd, { minify: true });
 	const slug = projectConfig?.slug;
 	const env = await resolveServerEnv(cwd);
@@ -48,6 +54,7 @@ async function executeDeploy(opts) {
 			...env
 		},
 		...slug ? { slug } : {},
+		...opts.allowMissingSecrets ? { allowMissingSecrets: true } : {},
 		apiKey
 	});
 	const agentUrl = `${serverUrl}/${deployed.slug}`;
@@ -63,10 +70,12 @@ async function executeDeploy(opts) {
 			serverUrl
 		})}`);
 	}
+	for (const warning of deployed.warnings ?? []) log.warn(warning);
 	log.success(`Deployed ${fmtUrl(agentUrl)}`);
 	return ok({
 		slug: deployed.slug,
-		url: agentUrl
+		url: agentUrl,
+		...deployed.warnings ? { warnings: deployed.warnings } : {}
 	});
 }
 //#endregion

package/dist/{dev-CQPY9Cfx.mjs → dev-C8o-p13B.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { n as log, r as parsePort, t as fmtUrl, u as ok } from "./_ui-CKEIHAtB.mjs";
+import { n as log, r as parsePort, t as fmtUrl, u as ok } from "./_ui-DXZ9prrM.mjs";
 import { n as errorDetail } from "./_utils-C502jKo8.mjs";
 import path from "node:path";
-import pc from "picocolors";
+import { styleText } from "node:util";
 //#region dev.ts
 /**
 * Start the dev server and return the result.
@@ -11,7 +11,7 @@ import pc from "picocolors";
 async function executeDev(opts) {
 	const port = parsePort(opts.port);
 	const agentName = path.basename(path.resolve(opts.cwd));
-	const { startDevServer } = await import("./_dev-server-DvcbFgos.mjs");
+	const { startDevServer } = await import("./_dev-server-BCbEUhmv.mjs");
 	let cleanup;
 	let shuttingDown = false;
 	const onSignal = () => {
@@ -30,7 +30,7 @@ async function executeDev(opts) {
 		port
 	});
 	const url = `http://localhost:${port}`;
-	log.success(`${pc.bold(agentName)} running at ${fmtUrl(url)}`);
+	log.success(`${styleText("bold", agentName)} running at ${fmtUrl(url)}`);
 	log.info("Press Ctrl-C to stop");
 	process.on("unhandledRejection", (err) => {
 		log.error(`Unhandled rejection: ${errorDetail(err)}`);

package/dist/{init-Dn3RNhsR.mjs → init-B53rR3yD.mjs}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { a as unwrapCancel, n as log, u as ok } from "./_ui-CKEIHAtB.mjs";
+import { a as unwrapCancel, n as log, u as ok } from "./_ui-DXZ9prrM.mjs";
 import { i as fileExists, o as readJson, r as errorMessage, s as resolveCwd } from "./_utils-C502jKo8.mjs";
-import { r as isDevMode, t as getMonorepoRoot } from "./_agent-dJAeDb38.mjs";
+import { r as isDevMode, t as getMonorepoRoot } from "./_agent-D39qatZJ.mjs";
 import path from "node:path";
+import { styleText } from "node:util";
 import * as p from "@clack/prompts";
-import pc from "picocolors";
 import { execa } from "execa";
 //#region init.ts
 const DEFAULT_PROJECT_NAME = "my-voice-agent";
@@ -74,7 +74,7 @@ function resolveTargetDir(dir) {
 }
 /** Run deploy after init and return deploy metadata if successful. */
 async function tryDeploy(cwd, server) {
-	const { executeDeploy } = await import("./deploy-DzGsORJx.mjs");
+	const { executeDeploy } = await import("./deploy-D-dnt9L8.mjs");
 	try {
 		const result = await executeDeploy({
 			cwd,
@@ -92,7 +92,7 @@ async function tryDeploy(cwd, server) {
 }
 /** Scaffold the project, optionally showing a spinner. */
 async function scaffoldProject(dir, cwd, template, silent) {
-	const { runInit } = await import("./_init-B-Fd6Lm4.mjs");
+	const { runInit } = await import("./_init-H-lw7czL.mjs");
 	if (silent) {
 		await runInit({
 			targetDir: cwd,
@@ -116,11 +116,11 @@ function printPostInitInfo(cwd, monorepoRoot) {
 }
 async function executeInit(opts, extra) {
 	const suppressUi = extra?.silent;
-	if (!suppressUi) p.intro(pc.cyanBright("Create a new voice agent"));
+	if (!suppressUi) p.intro(styleText("cyanBright", "Create a new voice agent"));
 	const dir = opts.dir ?? await promptProjectName(opts.yes);
 	const monorepoRoot = getMonorepoRoot();
 	const cwd = resolveTargetDir(dir);
-	if (!opts.force && await fileExists(path.join(cwd, "agent.ts"))) throw new Error(`agent.ts already exists in this directory. Use ${pc.cyanBright("--force")} to overwrite.`);
+	if (!opts.force && await fileExists(path.join(cwd, "agent.ts"))) throw new Error(`agent.ts already exists in this directory. Use ${styleText("cyanBright", "--force")} to overwrite.`);
 	const template = opts.template ?? "simple";
 	await scaffoldProject(dir, cwd, template, suppressUi);
 	const installed = await installDeps(cwd, suppressUi);

package/dist/{secret-DTH-dXnP.mjs → secret-C4unwCEw.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { a as unwrapCancel, n as log, s as fail, u as ok } from "./_ui-CKEIHAtB.mjs";
-import { n as getServerInfo } from "./_agent-dJAeDb38.mjs";
+import { a as unwrapCancel, n as log, s as fail, u as ok } from "./_ui-DXZ9prrM.mjs";
+import { n as getServerInfo } from "./_agent-D39qatZJ.mjs";
 import { t as apiRequest } from "./_api-client-a6cPMebU.mjs";
 import * as p from "@clack/prompts";
 import { text } from "node:stream/consumers";

package/dist/{storage-DOtoALnS.mjs → storage-tZM1J8qj.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { n as log, s as fail, u as ok } from "./_ui-CKEIHAtB.mjs";
-import { n as getServerInfo } from "./_agent-dJAeDb38.mjs";
+import { n as log, s as fail, u as ok } from "./_ui-DXZ9prrM.mjs";
+import { n as getServerInfo } from "./_agent-D39qatZJ.mjs";
 import { t as apiRequest } from "./_api-client-a6cPMebU.mjs";
 import * as p from "@clack/prompts";
 //#region storage.ts

package/dist/{test-B3BkLNn_.mjs → test-CgWhus_Z.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as log, s as fail, u as ok } from "./_ui-CKEIHAtB.mjs";
+import { n as log, s as fail, u as ok } from "./_ui-DXZ9prrM.mjs";
 import { r as errorMessage, t as errorCode } from "./_utils-C502jKo8.mjs";
 import { createRequire } from "node:module";
 import { existsSync, readFileSync } from "node:fs";

package/dist/typecheck.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+//#region typecheck.ts
+/**
+* Project typechecking — `tsc --noEmit` over the project's own tsconfig.
+*
+* Public (no `_` prefix) for the same reason as the bundlers: the guest
+* sandbox runs the same check before `test_agent` builds, so the studio's
+* coding agent sees type errors as build feedback instead of shipping
+* runtime-working-but-wrong code (the bundlers strip types unchecked —
+* excess-property bugs like `send`/`state` shipped exactly that way).
+*
+* Gated on `tsconfig.json`: a project that declares its type discipline is
+* checked with it; one that doesn't isn't (scaffolded projects and studio
+* workspaces always have one). TypeScript itself resolves from the
+* PROJECT'S node_modules — the user's pinned compiler, not ours.
+*/
+/** Bound on one typecheck run — a hung compiler must not wedge a deploy. */
+const TYPECHECK_TIMEOUT_MS = 12e4;
+/** Diagnostics tail kept for the failure message. */
+const OUTPUT_CAP = 16e3;
+/**
+* The project's own TypeScript package root — `node_modules/typescript`,
+* walking up from `cwd` exactly as a bare import would.
+*
+* Deliberately NOT `require.resolve("typescript")`. Node appends
+* `Module.globalPaths` — `NODE_PATH`, `~/.node_modules`, the install prefix —
+* to EVERY lookup, and the `paths` option does not suppress them, so an
+* ambient TypeScript anywhere on the host silently satisfies a project that
+* never declared one. That breaks the promise in this module's header twice
+* over: the gate would check a user's build with a compiler their project
+* doesn't pin, and the "TypeScript is not installed" branch below would be
+* unreachable on any host that sets NODE_PATH — which is how vitest runs its
+* workers (it points NODE_PATH at pnpm's hidden store), so the test for that
+* branch could not fail honestly either.
+*
+* The walk-up follows symlinks, which is what pnpm's `node_modules/typescript
+* -> .pnpm/typescript@x/node_modules/typescript` link needs, and what lets a
+* guest sandbox workspace reach the toolchain baked next to the harness.
+*/
+function findTypescriptPackage(cwd) {
+	let dir = path.resolve(cwd);
+	for (;;) {
+		const candidate = path.join(dir, "node_modules", "typescript");
+		if (existsSync(path.join(candidate, "package.json"))) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir) return;
+		dir = parent;
+	}
+}
+/** Resolve the project's TypeScript compiler entry (its own `tsc` bin). */
+function resolveTscEntry(cwd) {
+	const dir = findTypescriptPackage(cwd);
+	if (dir === void 0) throw new Error("no typescript package in the project's node_modules");
+	const pkg = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf-8"));
+	const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.tsc;
+	if (!bin) throw new Error("installed typescript package declares no tsc bin");
+	return path.join(dir, bin);
+}
+/**
+* Typecheck the project at `cwd` with its own tsconfig + compiler.
+* Skips (ok, skipped: true) when the project has no tsconfig.json.
+*/
+async function typecheckProject(cwd) {
+	if (!await readFile(path.join(cwd, "tsconfig.json"), "utf-8").then(() => true, () => false)) return {
+		ok: true,
+		skipped: true
+	};
+	let tscEntry;
+	try {
+		tscEntry = resolveTscEntry(cwd);
+	} catch (err) {
+		return {
+			ok: false,
+			output: `tsconfig.json is present but TypeScript is not installed — add it (npm install -D typescript) or remove tsconfig.json: ${errMessage(err)}`
+		};
+	}
+	const result = await new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, [
+			tscEntry,
+			"--noEmit",
+			"--pretty",
+			"false"
+		], {
+			cwd,
+			timeout: TYPECHECK_TIMEOUT_MS,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let output = "";
+		const keep = (s) => s.length > OUTPUT_CAP ? `…${s.slice(-16e3)}` : s;
+		child.stdout.on("data", (chunk) => {
+			output = keep(output + chunk.toString());
+		});
+		child.stderr.on("data", (chunk) => {
+			output = keep(output + chunk.toString());
+		});
+		child.on("error", reject);
+		child.on("close", (code, signal) => {
+			if (signal) {
+				reject(/* @__PURE__ */ new Error(`tsc killed by ${signal} after ${TYPECHECK_TIMEOUT_MS}ms`));
+				return;
+			}
+			resolve({
+				code,
+				output
+			});
+		});
+	});
+	if (result.code === 0) return {
+		ok: true,
+		skipped: false
+	};
+	return {
+		ok: false,
+		output: `Type check failed:\n${result.output.trim()}`
+	};
+}
+function errMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+export { typecheckProject };

package/dist/worker-bundler.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { t as withPreservedNodeEnv } from "./_vite-env-Dg_QlVv0.mjs";
 import path from "node:path";
+import fs from "node:fs/promises";
 import { build } from "vite";
 //#region worker-bundler.ts
 /**
@@ -12,26 +13,48 @@ import { build } from "vite";
 * worker published from the browser comes out of the same Vite/Rollup pass as
 * one from `aai deploy`.
 *
+* Every worker is built through a generated wrapper entry that re-exports the
+* agent *and* its extracted config as `__aaiConfig` (via the dependency-free
+* `@alexkroman1/aai/manifest` helpers, bundled in). The guest harness returns
+* that export from `bundle/load`, which is how the platform obtains an
+* agent's config without ever evaluating tenant code on the host — the
+* `POST /deploy` route and the studio's sandbox inspection both rely on it.
+*
+* **The worker ships its own runtime.** Deploy builds also export
+* `__aaiCreateRuntime` — a factory over the *user's installed* SDK's
+* `createRuntime`, bundled in alongside the provider SDKs. The guest harness
+* builds the session runtime through it, so a deployed agent runs exactly the
+* runtime version it was built and tested against (identical to `aai dev`),
+* instead of whatever SDK the platform's harness image was baked with. The
+* harness↔bundle contract is deliberately tiny: the factory takes
+* `{ env, db?, runCode? }` and returns `{ startSession, shutdown }`.
+*
 * What the studio supplies via options, because a workspace is not a project:
 *
-* - **`root` + `entry`.** The studio builds a generated entry that re-exports
-*   the agent *and* its extracted config, so the guest can report the config
-*   back without the host ever evaluating agent code.
 * - **`configFile: false`.** Workspace files are untrusted and a Vite config
 *   is executable host code.
 * - **`plugins`.** The studio adds its import allowlist; without it, Vite
 *   would happily resolve any package in the server's `node_modules`.
 */
 /**
-* Transform `.md` imports into raw string exports so templates that do
-* `import systemPrompt from "./system-prompt.md"` bundle correctly.
+* Generated wrapper entry, written under `.aai/` for the duration of the
+* build (the CLI's own scratch dir — dot-paths are ignored by the dev
+* watcher, and the studio's workspace materialization never writes there).
 */
-const rawMdPlugin = {
-	name: "raw-md",
-	transform(code, id) {
-		if (id.endsWith(".md")) return `export default ${JSON.stringify(code)}`;
-	}
+const WRAPPER_ENTRY_REL = path.join(".aai", "worker-entry.ts");
+function wrapperEntrySource(runtime) {
+	return `import def from "../agent.ts";
+import { agentToolsToSchemas, toAgentConfig } from "@alexkroman1/aai/manifest";
+${runtime ? `import { createRuntime } from "@alexkroman1/aai/runtime";` : ""}
+export default def;
+export const __aaiConfig = {
+  ...toAgentConfig(def),
+  toolSchemas: agentToolsToSchemas(def.tools ?? {}),
 };
+${runtime ? `export const __aaiCreateRuntime = (opts: Record<string, unknown>) =>
+  createRuntime({ ...opts, agent: def });
+` : ""}`;
+}
 /**
 * Bundle agent.ts into a single ESM string for the sandbox worker.
 *
@@ -39,25 +62,36 @@ const rawMdPlugin = {
 * and gracefully degrades in restricted environments like Deno.
 */
 async function buildWorker(cwd, opts = {}) {
-	const entry = opts.entry ?? "agent.ts";
-	const agentEntry = path.isAbsolute(entry) ? entry : path.join(cwd, entry);
-	const result = await withPreservedNodeEnv(() => build({
-		root: cwd,
-		logLevel: "silent",
-		...opts.configFile === false && { configFile: false },
-		plugins: [rawMdPlugin, ...opts.plugins ?? []],
-		build: {
-			lib: {
-				entry: agentEntry,
-				formats: ["es"],
-				fileName: "worker"
-			},
-			target: "node20",
-			minify: opts.minify ? "oxc" : false,
-			write: false,
-			rollupOptions: { output: { entryFileNames: "[name].js" } }
-		}
-	}));
+	const wrapperPath = path.join(cwd, WRAPPER_ENTRY_REL);
+	await fs.mkdir(path.dirname(wrapperPath), { recursive: true });
+	await fs.writeFile(wrapperPath, wrapperEntrySource(opts.runtime !== false), "utf-8");
+	let result;
+	try {
+		result = await withPreservedNodeEnv(() => build({
+			root: cwd,
+			logLevel: "silent",
+			...opts.configFile === false && { configFile: false },
+			...opts.plugins && { plugins: opts.plugins },
+			ssr: { noExternal: true },
+			build: {
+				ssr: true,
+				lib: {
+					entry: wrapperPath,
+					formats: ["es"],
+					fileName: "worker"
+				},
+				target: "node20",
+				minify: opts.minify ? "oxc" : false,
+				write: false,
+				rollupOptions: { output: {
+					entryFileNames: "[name].js",
+					codeSplitting: false
+				} }
+			}
+		}));
+	} finally {
+		await fs.rm(wrapperPath, { force: true }).catch(() => void 0);
+	}
 	const output = Array.isArray(result) ? result[0] : result;
 	if (!output) throw new Error("Vite produced no output for agent.ts");
 	const chunk = output.output.find((o) => o.type === "chunk" && o.isEntry);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-cli",
-  "version": "4.0.0",
+  "version": "5.0.1",
   "type": "module",
   "bin": {
     "aai": "dist/cli.mjs"
@@ -13,6 +13,10 @@
     "./worker-bundler": {
       "@dev/source": "./worker-bundler.ts",
       "import": "./dist/worker-bundler.mjs"
+    },
+    "./typecheck": {
+      "@dev/source": "./typecheck.ts",
+      "import": "./dist/typecheck.mjs"
     }
   },
   "files": [
@@ -28,12 +32,11 @@
     "giget": "^3.3.0",
     "ofetch": "^1.5.1",
     "p-debounce": "^5.1.0",
-    "picocolors": "^1.1.1",
-    "rolldown": "~1.1.4",
+    "p-timeout": "^7.0.1",
     "vite": "^8.1.5",
     "zod": "^4.4.3",
-    "@alexkroman1/aai": "4.0.0",
-    "@alexkroman1/aai-ui": "4.0.0"
+    "@alexkroman1/aai": "5.0.1",
+    "@alexkroman1/aai-ui": "5.0.1"
   },
   "devDependencies": {
     "playwright": "^1.61.1",
@@ -63,6 +66,8 @@
     "build": "tsdown",
     "typecheck": "tsc --noEmit",
     "lint": "biome check .",
+    "check:publint": "publint",
+    "check:attw": "attw --pack --profile esm-only",
     "test:e2e": "VITEST_PROFILE=e2e VITEST_INCLUDE=e2e*.test.ts vitest run -c ../../vitest.slow.config.ts",
     "check:e2e": "pnpm run test:e2e"
   }

package/dist/_bundler-DnZnKsIU.mjs

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-import { n as log, u as ok } from "./_ui-CKEIHAtB.mjs";
-import { c as validateAgentExport, r as errorMessage } from "./_utils-C502jKo8.mjs";
-import { t as buildClient } from "./client-bundler-DO3GgO6p.mjs";
-import { buildWorker } from "./worker-bundler.mjs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import fs from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { agentToolsToSchemas, toAgentConfig } from "@alexkroman1/aai/manifest";
-//#region _bundler.ts
-/**
-* Bundle an agent directory: build agent.ts into worker ESM + extract config.
-*
-* - agent.ts is the single entry point: `export default agent({...})`
-* - A single Vite build produces the worker ESM (all deps bundled in).
-*   The AgentDef is extracted from that bundle via dynamic import, avoiding a
-*   second build pass.
-*/
-async function buildAgentBundle(cwd, opts = {}) {
-	const [[worker, agentDef], clientFiles] = await Promise.all([buildWorker(cwd, opts).then(async (code) => [code, await evalWorkerBundle(code, cwd)]), buildClient(cwd)]);
-	log.step(`Bundling ${agentDef.name}`);
-	const config = toAgentConfig(agentDef);
-	const toolSchemas = agentToolsToSchemas(agentDef.tools ?? {});
-	return {
-		worker,
-		clientFiles,
-		agentConfig: {
-			...config,
-			toolSchemas
-		}
-	};
-}
-/**
-* Write the worker ESM to a temp file and dynamic-import it, returning
-* the AgentDef default export. All dependencies are bundled in, so the
-* file can be evaluated from any directory.
-*
-* Each call imports a uniquely-named file, and Node's ESM registry never
-* evicts — so every call retains one bundle for the process lifetime. That is
-* fine for one-shot commands (`aai build`/`aai deploy`); long-lived callers
-* must go through `createWorkerEvaluator` to at least dedupe identical
-* builds. Evaluating in a discardable context is not an option: tool
-* `execute` functions from the returned AgentDef are called in-process by the
-* dev runtime, which rules out worker threads, and `node:vm` ESM evaluation
-* is still flagged experimental.
-*/
-async function evalWorkerBundle(code, cwd) {
-	const evalDir = path.join(cwd, ".aai", "eval");
-	const tmpPath = path.join(evalDir, `agent-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`);
-	try {
-		await fs.mkdir(evalDir, { recursive: true });
-		await fs.writeFile(tmpPath, code);
-	} catch (err) {
-		await fs.rm(tmpPath, { force: true }).catch(() => void 0);
-		throw new Error(`Failed to write the eval bundle under ${evalDir} — is the project directory writable? (${errorMessage(err)})`, { cause: err });
-	}
-	try {
-		const mod = await import(pathToFileURL(tmpPath).href);
-		const agentDef = mod.default ?? mod;
-		validateAgentExport(agentDef);
-		return agentDef;
-	} finally {
-		await fs.rm(tmpPath).catch(() => {});
-	}
-}
-/**
-* Memoizing wrapper around `evalWorkerBundle` for long-lived callers (the
-* dev server): byte-identical worker code returns the previously evaluated
-* AgentDef without touching the ESM registry. No-op saves and formatter
-* churn are the common watcher events, so this caps the registry leak (see
-* `evalWorkerBundle`) to genuinely-new bundles — the residual one-module-per-
-* distinct-build leak is accepted for the reasons documented there.
-*/
-function createWorkerEvaluator(cwd) {
-	let lastHash;
-	let lastAgentDef;
-	return async (code) => {
-		const hash = createHash("sha256").update(code).digest("hex");
-		if (lastAgentDef && hash === lastHash) return lastAgentDef;
-		const agentDef = await evalWorkerBundle(code, cwd);
-		lastHash = hash;
-		lastAgentDef = agentDef;
-		return agentDef;
-	};
-}
-async function executeBuild(cwd) {
-	const bundle = await buildAgentBundle(cwd, { minify: true });
-	log.success("Build complete");
-	return ok({
-		name: bundle.agentConfig.name,
-		workerBytes: bundle.worker.length
-	});
-}
-//#endregion
-export { buildAgentBundle, createWorkerEvaluator, executeBuild };

package/dist/{_server-common-CpVD57yn.mjs → _server-common-B75oco06.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import path from "node:path";
-import fs from "node:fs/promises";
 import { parseEnv } from "node:util";
+import fs from "node:fs/promises";
 //#region _server-common.ts
 /**
 * Build the `ctx.env` record that agent tools will see at runtime.