@alexkroman1/aai-cli 0.9.2 → 0.10.0

package/dist/{_build-Dw66C1m4.mjs → _build-aW_zyPpr.mjs}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { o as loadAgent } from "./_discover-DsorPpR_.mjs";
-import { a as step, i as runCommand } from "./_ui-kJIua5L9.mjs";
+import { s as loadAgent } from "./_discover-D7HCLa_N.mjs";
+import { a as runCommand, o as step } from "./_ui-C9IvR7Fh.mjs";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { errorMessage } from "@alexkroman1/aai/utils";
 import preact from "@preact/preset-vite";
 import tailwindcss from "@tailwindcss/vite";
-import { build } from "vite";
+import { build, createServer } from "vite";
 //#region _bundler.ts
 /**
 * Error thrown when bundling fails.
@@ -14,11 +14,28 @@ import { build } from "vite";
 * @param message Human-readable error message (typically formatted build output).
 */
 var BundleError = class extends Error {
-	constructor(message) {
-		super(message);
+	constructor(message, options) {
+		super(message, options);
 		this.name = "BundleError";
 	}
 };
+/** File extensions that are safe to read as UTF-8 text. */
+const TEXT_EXTENSIONS = new Set([
+	".html",
+	".htm",
+	".css",
+	".js",
+	".mjs",
+	".cjs",
+	".ts",
+	".mts",
+	".json",
+	".map",
+	".svg",
+	".xml",
+	".txt",
+	".md"
+]);
 /** Read all files in a directory as a map of relative paths to contents. */
 async function readDirFiles(dir) {
 	let entries;
@@ -34,7 +51,10 @@ async function readDirFiles(dir) {
 	const files = {};
 	await Promise.all(entries.filter((e) => e.isFile()).map(async (e) => {
 		const full = path.join(e.parentPath, e.name);
-		files[path.relative(dir, full)] = await fs.readFile(full, "utf-8");
+		const ext = path.extname(e.name).toLowerCase();
+		const rel = path.relative(dir, full);
+		if (TEXT_EXTENSIONS.has(ext)) files[rel] = await fs.readFile(full, "utf-8");
+		else files[rel] = `base64:${(await fs.readFile(full)).toString("base64")}`;
 	}));
 	return files;
 }
@@ -57,12 +77,10 @@ async function bundleAgent(agent, opts) {
 			root: agent.dir,
 			logLevel: "warn",
 			build: {
-				rollupOptions: {
-					input: path.join(agent.dir, "agent.ts"),
-					output: {
-						format: "es",
-						entryFileNames: "worker.js"
-					}
+				lib: {
+					entry: path.join(agent.dir, "agent.ts"),
+					formats: ["es"],
+					fileName: () => "worker.js"
 				},
 				outDir: buildDir,
 				emptyOutDir: true,
@@ -71,9 +89,9 @@ async function bundleAgent(agent, opts) {
 			}
 		});
 	} catch (err) {
-		throw new BundleError(errorMessage(err));
+		throw new BundleError(errorMessage(err), { cause: err });
 	}
-	if (!(opts?.skipClient || !agent.clientEntry)) try {
+	if (!(opts?.skipClient ?? !agent.clientEntry)) try {
 		await build({
 			root: agent.dir,
 			base: "./",
@@ -88,7 +106,7 @@ async function bundleAgent(agent, opts) {
 			}
 		});
 	} catch (err) {
-		throw new BundleError(errorMessage(err));
+		throw new BundleError(errorMessage(err), { cause: err });
 	}
 	const worker = await fs.readFile(path.join(buildDir, "worker.js"), "utf-8");
 	return {
@@ -98,6 +116,32 @@ async function bundleAgent(agent, opts) {
 		workerBytes: Buffer.byteLength(worker)
 	};
 }
+/**
+* Create a Vite dev server for client HMR during development.
+*
+* The dev server serves client files with hot module replacement enabled and
+* proxies backend requests (`/health`, `/websocket`) to the agent server.
+*/
+async function createClientDevServer(agentDir, backendPort, port) {
+	const target = `http://localhost:${backendPort}`;
+	return await createServer({
+		configFile: false,
+		root: agentDir,
+		plugins: [preact(), tailwindcss()],
+		resolve: { dedupe: ["preact", "@preact/signals"] },
+		server: {
+			port,
+			strictPort: true,
+			proxy: {
+				"/health": target,
+				"/websocket": {
+					target,
+					ws: true
+				}
+			}
+		}
+	});
+}
 //#endregion
 //#region _build.ts
 /**
@@ -113,7 +157,7 @@ async function buildAgentBundle(cwd, log) {
 	try {
 		bundle = await bundleAgent(agent);
 	} catch (err) {
-		if (err instanceof BundleError) throw new Error(`Bundle failed: ${err.message}`);
+		if (err instanceof BundleError) throw new Error(`Bundle failed: ${err.message}`, { cause: err });
 		throw err;
 	}
 	const kb = (bundle.workerBytes / 1024).toFixed(1);
@@ -129,4 +173,4 @@ async function runBuildCommand(cwd) {
 	});
 }
 //#endregion
-export { buildAgentBundle, runBuildCommand };
+export { buildAgentBundle, runBuildCommand, createClientDevServer as t };

package/dist/{_discover-DsorPpR_.mjs → _discover-D7HCLa_N.mjs}

@@ -3,44 +3,69 @@ import { existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import fs$1 from "node:fs/promises";
+import { consola } from "consola";
 import { humanId } from "human-id";
 import { z } from "zod";
-import * as p from "@clack/prompts";
+import { createInterface } from "node:readline";
 //#region _prompts.ts
+const consola$1 = consola.create({ formatOptions: { date: false } });
 /**
 * Prompt the user for a password (masked input).
 * Returns the entered string.
 */
 async function askPassword(message) {
-	const value = await p.password({ message });
-	if (p.isCancel(value)) {
-		p.cancel("Cancelled.");
-		process.exit(0);
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	process.stdout.write(`${message}: `);
+	const stdin = process.stdin;
+	const wasRaw = stdin.isRaw;
+	if (stdin.isTTY) stdin.setRawMode(true);
+	try {
+		return await readMasked(stdin);
+	} finally {
+		if (stdin.isTTY) stdin.setRawMode(wasRaw ?? false);
+		rl.close();
 	}
-	return value;
+}
+function readMasked(stdin) {
+	return new Promise((resolve) => {
+		let buf = "";
+		const onData = (ch) => {
+			const c = ch.toString();
+			if (c === "\n" || c === "\r") {
+				stdin.removeListener("data", onData);
+				process.stdout.write("\n");
+				resolve(buf);
+			} else if (c === "") {
+				stdin.removeListener("data", onData);
+				process.exit(0);
+			} else if (c === "" || c === "\b") buf = buf.slice(0, -1);
+			else buf += c;
+		};
+		stdin.on("data", onData);
+	});
 }
 /**
 * Prompt the user for text input with a default value.
 * Returns the entered string, or the default if empty.
 */
 async function askText(message, defaultValue) {
-	const value = await p.text({
-		message,
+	return await consola$1.prompt(message, {
+		type: "text",
 		placeholder: defaultValue,
-		defaultValue
-	});
-	if (p.isCancel(value)) {
-		p.cancel("Cancelled.");
-		process.exit(0);
-	}
-	return value || defaultValue;
+		initial: defaultValue,
+		cancel: "reject"
+	}) || defaultValue;
 }
 //#endregion
 //#region _discover.ts
 const AuthConfigSchema = z.object({ assemblyai_api_key: z.string().optional() });
 const ProjectConfigSchema = z.object({
 	slug: z.string(),
-	serverUrl: z.string()
+	serverUrl: z.string(),
+	sessionId: z.string().optional()
 });
 /** Resolve the working directory from INIT_CWD or process.cwd(). */
 function resolveCwd() {
@@ -70,24 +95,34 @@ async function writeAuthConfig(config) {
 	if (process.platform !== "win32") await fs$1.chmod(CONFIG_FILE, 384);
 }
 /**
-* Retrieves the AssemblyAI API key from `~/.config/aai/config.json`.
-* If not found, interactively prompts the user and persists it.
+* Retrieves the AssemblyAI API key from `process.env`, `~/.config/aai/config.json`,
+* or by interactively prompting the user (persisting it to config).
+*
+* Does NOT mutate `process.env`. Callers that need the key available in the
+* environment for child processes should use {@link ensureApiKeyInEnv} instead.
 */
 async function getApiKey() {
 	if (process.env.ASSEMBLYAI_API_KEY) return process.env.ASSEMBLYAI_API_KEY;
 	const config = await readAuthConfig();
-	if (config.assemblyai_api_key) {
-		process.env.ASSEMBLYAI_API_KEY = config.assemblyai_api_key;
-		return config.assemblyai_api_key;
-	}
+	if (config.assemblyai_api_key) return config.assemblyai_api_key;
+	consola.info("Get your API key at https://www.assemblyai.com/dashboard/signup");
+	consola.info("Or set the ASSEMBLYAI_API_KEY environment variable to skip this prompt.\n");
 	let key;
 	while (!key) key = await askPassword("ASSEMBLYAI_API_KEY");
 	config.assemblyai_api_key = key;
-	process.env.ASSEMBLYAI_API_KEY = key;
 	await writeAuthConfig(config);
 	return key;
 }
 /**
+* Resolves the API key via {@link getApiKey} and sets it on `process.env.ASSEMBLYAI_API_KEY`
+* so that child processes and downstream code can read it from the environment.
+*/
+async function ensureApiKeyInEnv() {
+	const key = await getApiKey();
+	process.env.ASSEMBLYAI_API_KEY = key;
+	return key;
+}
+/**
 * Reads `.aai/project.json` from an agent directory.
 * Returns null if the file doesn't exist.
 */
@@ -129,7 +164,7 @@ function isDevMode() {
 }
 /** Resolve the server URL from an explicit value, project config, or default. */
 function resolveServerUrl(explicit, configUrl) {
-	return explicit || configUrl || (isDevMode() ? "http://localhost:8787" : "https://aai-agent.fly.dev");
+	return explicit ?? configUrl ?? (isDevMode() ? "http://localhost:8787" : "https://aai-agent.fly.dev");
 }
 async function fileExists(p) {
 	try {
@@ -143,8 +178,8 @@ async function fileExists(p) {
 * Loads agent metadata from a directory by checking for `agent.ts` and
 * resolving the client entry point.
 *
-* Env vars are NOT read from `.env` — they're managed on the server
-* via `aai env add` (like `vercel env add`).
+* Env vars for deployed agents are managed on the server via
+* `aai secret put`. For local dev, `.env` is loaded by `resolveServerEnv`.
 */
 async function loadAgent(dir) {
 	if (!await fileExists(path.join(dir, "agent.ts"))) return null;
@@ -158,4 +193,4 @@ async function loadAgent(dir) {
 	};
 }
 //#endregion
-export { isDevMode as a, resolveCwd as c, askPassword as d, askText as f, getServerInfo as i, resolveServerUrl as l, generateSlug as n, loadAgent as o, getApiKey as r, readProjectConfig as s, fileExists as t, writeProjectConfig as u };
+export { getServerInfo as a, readProjectConfig as c, writeProjectConfig as d, askPassword as f, getApiKey as i, resolveCwd as l, fileExists as n, isDevMode as o, askText as p, generateSlug as r, loadAgent as s, ensureApiKeyInEnv as t, resolveServerUrl as u };

package/dist/_init-CweK2mJJ.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { o as isDevMode } from "./_discover-D7HCLa_N.mjs";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs$1 from "node:fs/promises";
+import { downloadTemplate } from "giget";
+//#region _templates.ts
+const GIGET_SOURCE = "github:alexkroman/agent/packages/aai-templates";
+const GIGET_REF = process.env.AAI_TEMPLATES_REF ?? "main";
+/** Resolve the local aai-templates package directory (dev mode only). */
+function resolveLocalTemplatesDir() {
+	const cliDir = path.dirname(fileURLToPath(import.meta.url));
+	const fromSrc = path.resolve(cliDir, "../aai-templates");
+	const fromDist = path.resolve(cliDir, "../../aai-templates");
+	if (existsSync(fromSrc)) return fromSrc;
+	if (existsSync(fromDist)) return fromDist;
+	throw new Error("Cannot find local aai-templates package");
+}
+/** Resolve the templates directory — local in dev, giget download in prod. */
+async function resolveTemplatesDir() {
+	if (isDevMode()) return resolveLocalTemplatesDir();
+	const { dir } = await downloadTemplate(`${GIGET_SOURCE}#${GIGET_REF}`, { force: true });
+	return dir;
+}
+/**
+* Download a template into targetDir, merging _shared files underneath.
+*/
+async function downloadAndMergeTemplate(template, targetDir) {
+	const templatesDir = await resolveTemplatesDir();
+	const names = (await fs$1.readdir(templatesDir, { withFileTypes: true })).filter((e) => e.isDirectory() && !e.name.startsWith("_") && e.name !== "node_modules").map((e) => e.name);
+	if (!names.includes(template)) throw new Error(`unknown template '${template}' -- available: ${names.join(", ")}`);
+	await fs$1.cp(path.join(templatesDir, template), targetDir, {
+		recursive: true,
+		force: true
+	});
+	const sharedDir = path.join(templatesDir, "_shared");
+	if (existsSync(sharedDir)) {
+		const entries = await fs$1.readdir(sharedDir, {
+			recursive: true,
+			withFileTypes: true
+		});
+		for (const entry of entries) {
+			if (!entry.isFile()) continue;
+			const rel = path.relative(sharedDir, path.join(entry.parentPath, entry.name));
+			const destPath = path.join(targetDir, rel);
+			await fs$1.mkdir(path.dirname(destPath), { recursive: true });
+			try {
+				await fs$1.copyFile(path.join(sharedDir, rel), destPath, fs$1.constants.COPYFILE_EXCL);
+			} catch (err) {
+				if (!(err instanceof Error && "code" in err && err.code === "EEXIST")) throw err;
+			}
+		}
+	}
+}
+//#endregion
+//#region _init.ts
+async function runInit(opts) {
+	const { targetDir, template } = opts;
+	await downloadAndMergeTemplate(template, targetDir);
+	try {
+		await fs$1.copyFile(path.join(targetDir, ".env.example"), path.join(targetDir, ".env"));
+	} catch {}
+	const readmePath = path.join(targetDir, "README.md");
+	const readme = `# ${path.basename(path.resolve(targetDir))}
+
+A voice agent built with [aai](https://github.com/anthropics/aai).
+
+## Getting started
+
+\`\`\`sh
+npm install        # Install dependencies
+npm run dev        # Run locally (opens browser)
+npm run deploy     # Deploy to production
+\`\`\`
+
+## Secrets
+
+Access secrets in your agent via \`ctx.env.MY_KEY\`.
+
+**Local development** — add secrets to \`.env\` (auto-loaded by \`aai dev\`):
+
+\`\`\`sh
+ALPHA_VANTAGE_KEY=sk-abc123
+MY_API_KEY=secret-value
+\`\`\`
+
+**Production** — set secrets on the server:
+
+\`\`\`sh
+aai secret put MY_KEY    # Set a secret (prompts for value)
+aai secret list          # List secret names
+aai secret delete MY_KEY # Remove a secret
+\`\`\`
+
+## Learn more
+
+See \`CLAUDE.md\` for the full agent API reference.
+`;
+	try {
+		await fs$1.writeFile(readmePath, readme, { flag: "wx" });
+	} catch (err) {
+		if (!(err instanceof Error && "code" in err && err.code === "EEXIST")) throw err;
+	}
+	return targetDir;
+}
+//#endregion
+export { runInit };

package/dist/{_link-BGXGFYWa.mjs → _link-D6mmDQ0B.mjs}

@@ -2,6 +2,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { consola } from "consola";
+import { z } from "zod";
 import { execFileSync } from "node:child_process";
 //#region _link.ts
 const WORKSPACE_PKGS = ["aai", "aai-ui"];
@@ -18,7 +20,7 @@ function rewriteWorkspaceDeps(cwd, rewrite, verb) {
 	const changed = [];
 	for (const pkgDir of WORKSPACE_PKGS) {
 		const localPath = path.join(packagesDir, pkgDir);
-		const name = JSON.parse(fs.readFileSync(path.join(localPath, "package.json"), "utf-8")).name;
+		const name = z.object({ name: z.string() }).parse(JSON.parse(fs.readFileSync(path.join(localPath, "package.json"), "utf-8"))).name;
 		if (!deps[name]) continue;
 		const newVersion = rewrite(deps[name], localPath);
 		if (newVersion !== null) {
@@ -27,11 +29,11 @@ function rewriteWorkspaceDeps(cwd, rewrite, verb) {
 		}
 	}
 	if (changed.length === 0) {
-		console.log(`No packages to ${verb}.`);
+		consola.info(`No packages to ${verb}.`);
 		return;
 	}
 	fs.writeFileSync(pkgJsonPath, `${JSON.stringify(pkgJson, null, 2)}\n`);
-	console.log(`${verb}: ${changed.join(", ")} → installing...`);
+	consola.start(`${verb}: ${changed.join(", ")} → installing...`);
 	execFileSync("npm", ["install"], {
 		cwd,
 		stdio: "inherit"

package/dist/_server-common-B6EXxxB2.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import { i as getApiKey } from "./_discover-D7HCLa_N.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region _server-common.ts
+/**
+* Return the variable names declared in a `.env` file.
+*
+* Only used to determine *which* keys the developer intended as agent
+* secrets — actual values are resolved from `process.env` (so shell
+* overrides still win).
+*/
+function envFileKeys(content) {
+	const keys = [];
+	for (const raw of content.split("\n")) {
+		const line = raw.trim();
+		if (!line || line.startsWith("#")) continue;
+		const eq = line.indexOf("=");
+		if (eq === -1) continue;
+		const key = line.slice(0, eq).trim();
+		if (key) keys.push(key);
+	}
+	return keys;
+}
+/** Load an AgentDef by dynamically importing agent.ts via Node's native TS support. */
+async function loadAgentDef(cwd) {
+	const agentDef = (await import(path.resolve(cwd, "agent.ts"))).default;
+	if (!agentDef || typeof agentDef !== "object" || !agentDef.name) throw new Error("agent.ts must export a default agent definition (from defineAgent())");
+	const missing = [];
+	if (typeof agentDef.name !== "string") missing.push("name (string)");
+	if (typeof agentDef.instructions !== "string") missing.push("instructions (string)");
+	if (typeof agentDef.greeting !== "string") missing.push("greeting (string)");
+	if (typeof agentDef.maxSteps !== "number" && typeof agentDef.maxSteps !== "function") missing.push("maxSteps (number or function)");
+	if (!agentDef.tools || typeof agentDef.tools !== "object" || Array.isArray(agentDef.tools)) missing.push("tools (object)");
+	if (missing.length > 0) throw new Error(`Invalid agent definition: missing or invalid fields: ${missing.join(", ")}. Use defineAgent() to create a valid agent definition.`);
+	return agentDef;
+}
+/**
+* Build the `ctx.env` record that agent tools will see at runtime.
+*
+* Only variables explicitly declared in `.env` (plus `ASSEMBLYAI_API_KEY`)
+* are included — matching the platform sandbox behavior where `ctx.env`
+* contains only secrets set via `aai secret put`. This prevents agents
+* from accidentally depending on shell-level vars (PATH, HOME, etc.) that
+* won't exist in production.
+*
+* Values are resolved from `process.env` after loading `.env` via Node's
+* built-in `process.loadEnvFile()`, so shell exports override `.env`.
+*
+* @param cwd - Project directory containing `.env` (optional).
+* @param baseEnv - Override the environment to read values from (tests only).
+*/
+async function resolveServerEnv(cwd, baseEnv) {
+	let declaredKeys = [];
+	if (cwd) {
+		const envPath = path.join(cwd, ".env");
+		try {
+			declaredKeys = envFileKeys(await fs.readFile(envPath, "utf-8"));
+			process.loadEnvFile(envPath);
+		} catch {}
+	}
+	const source = baseEnv ?? process.env;
+	const env = {};
+	for (const key of declaredKeys) {
+		const val = source[key];
+		if (val !== void 0) env[key] = val;
+	}
+	if (!env.ASSEMBLYAI_API_KEY) env.ASSEMBLYAI_API_KEY = source.ASSEMBLYAI_API_KEY ?? await getApiKey();
+	return env;
+}
+/**
+* Create and start an agent server with static file serving.
+*
+* NOTE: This dynamically imports `@alexkroman1/aai/server` which has peer
+* dependencies on `hono` and `@hono/node-server`. Those packages are listed
+* as direct dependencies of aai-cli (in package.json) solely to satisfy
+* those peer deps — they are not imported directly by aai-cli code.
+*/
+async function bootServer(agentDef, clientDir, env, port) {
+	const { createServer } = await import("@alexkroman1/aai/server");
+	const server = createServer({
+		agent: agentDef,
+		clientDir,
+		env
+	});
+	await server.listen(port);
+	return server;
+}
+/**
+* Boot the agent server without client serving.
+*
+* Used in dev mode where Vite handles client files with HMR,
+* and only the backend (health, WebSocket) runs on this server.
+*/
+async function bootBackendServer(agentDef, env, port) {
+	const { createServer } = await import("@alexkroman1/aai/server");
+	const server = createServer({
+		agent: agentDef,
+		env
+	});
+	await server.listen(port);
+	return server;
+}
+//#endregion
+export { resolveServerEnv as a, loadAgentDef as i, bootServer as n, envFileKeys as r, bootBackendServer as t };

package/dist/_ui-C9IvR7Fh.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { colorize } from "consola/utils";
+//#region _ui.ts
+/** Interactive/info color wrapper (blue). */
+function interactive(s) {
+	return colorize("blueBright", s);
+}
+/** Colored step message: bold action label + message. */
+function step(action, msg) {
+	return `${colorize("bold", colorize("cyanBright", action))} ${msg}`;
+}
+/** Informational step message: bold blue action + message. */
+function stepInfo(action, msg) {
+	return `${colorize("bold", colorize("blueBright", action))} ${msg}`;
+}
+/** Dimmed info sub-line (indented). */
+function info(msg) {
+	return colorize("dim", `  ${msg}`);
+}
+/** Detail sub-line (indented). */
+function detail(msg) {
+	return `  ${msg}`;
+}
+/** Warning message. */
+function warn(msg) {
+	return `${colorize("yellowBright", "!")} ${msg}`;
+}
+/** Parse and validate a port string. Returns the numeric port or throws. */
+function parsePort(raw) {
+	const port = Number.parseInt(raw, 10);
+	if (Number.isNaN(port) || port < 0 || port > 65535) throw new Error(`Invalid port: ${raw}. Must be a number between 0 and 65535.`);
+	return port;
+}
+/**
+* Run an async command function, logging each step to stdout.
+* Replaces the Ink `runWithInk` pattern.
+*/
+async function runCommand(fn) {
+	const log = (msg) => console.log(msg);
+	const setStatus = (msg) => {
+		if (msg) process.stdout.write(`\r${colorize("dim", msg)}`);
+		else process.stdout.write("\r\x1B[K");
+	};
+	await fn({
+		log,
+		setStatus
+	});
+}
+//#endregion
+export { runCommand as a, warn as c, parsePort as i, info as n, step as o, interactive as r, stepInfo as s, detail as t };