@alexkroman1/aai-cli 0.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_build-p1HHkdon.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import { o as loadAgent } from "./_discover-BzlCDVZ6.mjs";
+import { a as step, i as runCommand } from "./_ui-kJIua5L9.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";
+//#region _bundler.ts
+/**
+* Error thrown when bundling fails.
+*
+* @param message Human-readable error message (typically formatted build output).
+*/
+var BundleError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "BundleError";
+	}
+};
+/** Read all files in a directory as a map of relative paths to contents. */
+async function readDirFiles(dir) {
+	let entries;
+	try {
+		entries = await fs.readdir(dir, {
+			recursive: true,
+			withFileTypes: true
+		});
+	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "ENOENT") return {};
+		throw err;
+	}
+	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");
+	}));
+	return files;
+}
+/**
+* Bundles an agent project into deployable artifacts using Vite.
+*
+* Writes all output to `.aai/` on disk:
+* - `.aai/build/worker.js` — the platform worker bundle
+* - `.aai/client/` — standard Vite multi-file output (index.html + assets/)
+*
+* Both `aai dev` and `aai deploy` use this function identically.
+*/
+async function bundleAgent(agent, opts) {
+	const aaiDir = path.join(agent.dir, ".aai");
+	const buildDir = path.join(aaiDir, "build");
+	const clientDir = path.join(aaiDir, "client");
+	try {
+		await build({
+			configFile: false,
+			root: agent.dir,
+			logLevel: "warn",
+			build: {
+				rollupOptions: {
+					input: path.join(agent.dir, "agent.ts"),
+					output: {
+						format: "es",
+						entryFileNames: "worker.js"
+					}
+				},
+				outDir: buildDir,
+				emptyOutDir: true,
+				minify: true,
+				target: "es2022"
+			}
+		});
+	} catch (err) {
+		throw new BundleError(errorMessage(err));
+	}
+	if (!(opts?.skipClient || !agent.clientEntry)) try {
+		await build({
+			root: agent.dir,
+			base: "./",
+			logLevel: "warn",
+			plugins: [preact(), tailwindcss()],
+			resolve: { dedupe: ["preact", "@preact/signals"] },
+			build: {
+				outDir: clientDir,
+				emptyOutDir: true,
+				minify: true,
+				target: "es2022"
+			}
+		});
+	} catch (err) {
+		throw new BundleError(errorMessage(err));
+	}
+	const worker = await fs.readFile(path.join(buildDir, "worker.js"), "utf-8");
+	return {
+		worker,
+		clientFiles: await readDirFiles(clientDir),
+		clientDir,
+		workerBytes: Buffer.byteLength(worker)
+	};
+}
+//#endregion
+//#region _build.ts
+/**
+* Discover the agent entry and bundle both worker and client.
+*
+* Shared by `aai build`, `aai dev`, and `aai deploy`.
+*/
+async function buildAgentBundle(cwd, log) {
+	const agent = await loadAgent(cwd);
+	if (!agent) throw new Error("No agent found — run `aai init` first");
+	log(step("Bundle", agent.slug));
+	let bundle;
+	try {
+		bundle = await bundleAgent(agent);
+	} catch (err) {
+		if (err instanceof BundleError) throw new Error(`Bundle failed: ${err.message}`);
+		throw err;
+	}
+	const kb = (bundle.workerBytes / 1024).toFixed(1);
+	const clientCount = Object.keys(bundle.clientFiles).length;
+	log(`worker: ${kb} KB, client: ${clientCount} file(s)`);
+	return bundle;
+}
+/** Bundle the agent and report success. Used by `aai build`. */
+async function runBuildCommand(cwd) {
+	await runCommand(async ({ log }) => {
+		await buildAgentBundle(cwd, log);
+		log(step("Build", "ok"));
+	});
+}
+//#endregion
+export { buildAgentBundle, runBuildCommand };

package/dist/_discover-BzlCDVZ6.mjs

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs$1 from "node:fs/promises";
+import { humanId } from "human-id";
+import { z } from "zod";
+import * as p from "@clack/prompts";
+//#region _prompts.ts
+/**
+* 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);
+	}
+	return value;
+}
+/**
+* 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,
+		placeholder: defaultValue,
+		defaultValue
+	});
+	if (p.isCancel(value)) {
+		p.cancel("Cancelled.");
+		process.exit(0);
+	}
+	return value || 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()
+});
+/** Resolve the working directory from INIT_CWD or process.cwd(). */
+function resolveCwd() {
+	return process.env.INIT_CWD || process.cwd();
+}
+/**
+* Generates a human-readable slug using human-id.
+*/
+function generateSlug() {
+	return humanId({
+		separator: "-",
+		capitalize: false
+	});
+}
+const CONFIG_DIR = path.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".config", "aai");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+async function readAuthConfig() {
+	try {
+		return AuthConfigSchema.parse(JSON.parse(await fs$1.readFile(CONFIG_FILE, "utf-8")));
+	} catch {
+		return {};
+	}
+}
+async function writeAuthConfig(config) {
+	await fs$1.mkdir(CONFIG_DIR, { recursive: true });
+	await fs$1.writeFile(CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`);
+	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.
+*/
+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;
+	}
+	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;
+}
+/**
+* Reads `.aai/project.json` from an agent directory.
+* Returns null if the file doesn't exist.
+*/
+async function readProjectConfig(agentDir) {
+	try {
+		return ProjectConfigSchema.parse(JSON.parse(await fs$1.readFile(path.join(agentDir, ".aai", "project.json"), "utf-8")));
+	} catch {
+		return null;
+	}
+}
+/**
+* Writes `.aai/project.json` to an agent directory.
+*/
+async function writeProjectConfig(agentDir, data) {
+	const aaiDir = path.join(agentDir, ".aai");
+	await fs$1.mkdir(aaiDir, { recursive: true });
+	await fs$1.writeFile(path.join(aaiDir, "project.json"), `${JSON.stringify(data, null, 2)}\n`);
+}
+/**
+* Read project config (throws if missing), resolve API key and server URL.
+* Shared by secret and rag commands.
+*/
+async function getServerInfo(cwd, explicitServer, explicitApiKey) {
+	const config = await readProjectConfig(cwd);
+	if (!config) throw new Error("No .aai/project.json found — deploy first with `aai deploy`");
+	const apiKey = explicitApiKey ?? await getApiKey();
+	return {
+		serverUrl: resolveServerUrl(explicitServer, config.serverUrl),
+		slug: config.slug,
+		apiKey
+	};
+}
+/** Check if the CLI is running from the monorepo (dev mode). */
+function isDevMode() {
+	const cliDir = path.dirname(fileURLToPath(import.meta.url));
+	const packagesDir = path.resolve(cliDir, "..");
+	const altPackagesDir = path.resolve(cliDir, "../..");
+	return existsSync(path.join(packagesDir, "aai", "package.json")) || existsSync(path.join(altPackagesDir, "aai", "package.json"));
+}
+/** 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");
+}
+async function fileExists(p) {
+	try {
+		await fs$1.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 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`).
+*/
+async function loadAgent(dir) {
+	if (!await fileExists(path.join(dir, "agent.ts"))) return null;
+	const slug = (await readProjectConfig(dir))?.slug ?? generateSlug();
+	const clientEntry = await fileExists(path.join(dir, "client.tsx")) ? path.join(dir, "client.tsx") : "";
+	return {
+		slug,
+		dir,
+		entryPoint: path.join(dir, "agent.ts"),
+		clientEntry
+	};
+}
+//#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 };

package/dist/_init-l_uoyFCN.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region _init.ts
+async function listTemplates(dir) {
+	const templates = [];
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+	for (const entry of entries) if (entry.isDirectory() && !entry.name.startsWith("_")) templates.push(entry.name);
+	return templates.sort();
+}
+/**
+* Copy all files from `src` into `dest`, skipping files that already exist
+* in `dest` so that template-specific files take precedence over shared ones.
+*/
+async function copyDirNoOverwrite(src, dest) {
+	const entries = await fs.readdir(src, {
+		recursive: true,
+		withFileTypes: true
+	});
+	for (const entry of entries) {
+		if (!entry.isFile()) continue;
+		const rel = path.relative(src, path.join(entry.parentPath, entry.name));
+		const destPath = path.join(dest, rel);
+		await fs.mkdir(path.dirname(destPath), { recursive: true });
+		try {
+			await fs.copyFile(path.join(src, rel), destPath, fs.constants.COPYFILE_EXCL);
+		} catch (err) {
+			if (!(err instanceof Error && "code" in err && err.code === "EEXIST")) throw err;
+		}
+	}
+}
+async function runInit(opts) {
+	const { targetDir, template, templatesDir } = opts;
+	const available = await listTemplates(templatesDir);
+	if (!available.includes(template)) throw new Error(`unknown template '${template}' -- available: ${available.join(", ")}`);
+	await fs.cp(path.join(templatesDir, template), targetDir, {
+		recursive: true,
+		force: true
+	});
+	await copyDirNoOverwrite(path.join(templatesDir, "_shared"), targetDir);
+	try {
+		await fs.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
+\`\`\`
+
+## Environment variables
+
+Secrets are managed on the server, not in local files:
+
+\`\`\`sh
+aai env add MY_KEY # Set a secret (prompts for value)
+aai env ls         # List secret names
+aai env pull       # Pull names into .env for reference
+aai env rm MY_KEY  # Remove a secret
+\`\`\`
+
+Access secrets in your agent via \`ctx.env.MY_KEY\`.
+
+## Learn more
+
+See \`CLAUDE.md\` for the full agent API reference.
+`;
+	try {
+		await fs.writeFile(readmePath, readme, { flag: "wx" });
+	} catch (err) {
+		if (err.code !== "EEXIST") throw err;
+	}
+	return targetDir;
+}
+//#endregion
+export { runInit };

package/dist/_link-BGXGFYWa.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFileSync } from "node:child_process";
+//#region _link.ts
+const WORKSPACE_PKGS = ["aai", "aai-ui"];
+function getPackagesDir() {
+	const cliDir = path.dirname(fileURLToPath(import.meta.url));
+	const parent = path.resolve(cliDir, "..");
+	return fs.existsSync(path.join(parent, "aai", "package.json")) ? parent : path.resolve(parent, "..");
+}
+function rewriteWorkspaceDeps(cwd, rewrite, verb) {
+	const packagesDir = getPackagesDir();
+	const pkgJsonPath = path.join(cwd, "package.json");
+	const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+	const deps = pkgJson.dependencies ?? {};
+	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;
+		if (!deps[name]) continue;
+		const newVersion = rewrite(deps[name], localPath);
+		if (newVersion !== null) {
+			deps[name] = newVersion;
+			changed.push(name);
+		}
+	}
+	if (changed.length === 0) {
+		console.log(`No packages to ${verb}.`);
+		return;
+	}
+	fs.writeFileSync(pkgJsonPath, `${JSON.stringify(pkgJson, null, 2)}\n`);
+	console.log(`${verb}: ${changed.join(", ")} → installing...`);
+	execFileSync("npm", ["install"], {
+		cwd,
+		stdio: "inherit"
+	});
+}
+function runLinkCommand(cwd) {
+	rewriteWorkspaceDeps(cwd, (_cur, localPath) => `file:${localPath}`, "Linked");
+}
+function runUnlinkCommand(cwd) {
+	rewriteWorkspaceDeps(cwd, (cur) => cur.startsWith("file:") ? "*" : null, "Unlinked");
+}
+//#endregion
+export { runLinkCommand, runUnlinkCommand };

package/dist/_server-common-qLA1QU2C.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { r as getApiKey } from "./_discover-BzlCDVZ6.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region _server-common.ts
+/** 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())");
+	return agentDef;
+}
+/**
+* Build an env record, ensuring ASSEMBLYAI_API_KEY is set.
+*
+* @param baseEnv - Override the base environment (defaults to process.env).
+*/
+async function resolveServerEnv(baseEnv) {
+	const env = Object.fromEntries(Object.entries(baseEnv ?? process.env).filter((e) => e[1] !== void 0));
+	if (!env.ASSEMBLYAI_API_KEY) env.ASSEMBLYAI_API_KEY = await getApiKey();
+	return env;
+}
+/** Create and start an agent server with static file serving. */
+async function bootServer(agentDef, clientDir, env, port) {
+	const clientHtml = await fs.readFile(path.join(clientDir, "index.html"), "utf-8");
+	const { createServer } = await import("@alexkroman1/aai/server");
+	const server = createServer({
+		agent: agentDef,
+		clientHtml,
+		clientDir,
+		env
+	});
+	await server.listen(port);
+	return server;
+}
+//#endregion
+export { loadAgentDef as n, resolveServerEnv as r, bootServer as t };

package/dist/_ui-kJIua5L9.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import pc from "picocolors";
+//#region _ui.ts
+/** Interactive/info color wrapper. */
+function interactive(s) {
+	return pc.cyan(s);
+}
+/** Colored step message: bold action label + message. */
+function step(action, msg) {
+	return `${pc.bold(pc.yellow(action))} ${msg}`;
+}
+/** Informational step message: bold cyan action + message. */
+function stepInfo(action, msg) {
+	return `${pc.bold(pc.cyan(action))} ${msg}`;
+}
+/** Dimmed info sub-line (indented). */
+function info(msg) {
+	return pc.dim(`  ${msg}`);
+}
+/** Detail sub-line (indented). */
+function detail(msg) {
+	return `  ${msg}`;
+}
+/** Yellow warning message. */
+function warn(msg) {
+	return `${pc.yellow("!")} ${msg}`;
+}
+/**
+* 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${pc.dim(msg)}`);
+		else process.stdout.write("\r\x1B[K");
+	};
+	await fn({
+		log,
+		setStatus
+	});
+}
+//#endregion
+export { step as a, runCommand as i, info as n, stepInfo as o, interactive as r, warn as s, detail as t };