@alexkroman1/aai-cli 0.12.3 → 1.0.2

package/dist/_agent-CzbSa09n.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { n as ensureApiKey, r as readProjectConfig } from "./_config-Dv-T6uRj.mjs";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const DEFAULT_DEV_SERVER = "http://localhost:8080";
+let _cachedMonorepoRoot;
+function getMonorepoRoot() {
+	if (_cachedMonorepoRoot !== void 0) return _cachedMonorepoRoot;
+	const cliDir = path.dirname(fileURLToPath(import.meta.url));
+	const root1 = path.resolve(cliDir, "../..");
+	const root2 = path.resolve(cliDir, "../../..");
+	if (existsSync(path.join(root1, "pnpm-workspace.yaml"))) _cachedMonorepoRoot = root1;
+	else if (existsSync(path.join(root2, "pnpm-workspace.yaml"))) _cachedMonorepoRoot = root2;
+	else _cachedMonorepoRoot = null;
+	return _cachedMonorepoRoot;
+}
+function isDevMode() {
+	if (process.env.AAI_NO_DEV === "1") return false;
+	return getMonorepoRoot() !== null;
+}
+function resolveServerUrl(explicit, configUrl) {
+	if (explicit) return explicit;
+	if (isDevMode()) return DEFAULT_DEV_SERVER;
+	return configUrl ?? "https://aai-agent.fly.dev";
+}
+async function getServerInfo(cwd, explicitServer, explicitApiKey) {
+	const config = await readProjectConfig(cwd);
+	if (!config) throw new Error("No .aai/project.json found — run `aai deploy` first");
+	const apiKey = explicitApiKey ?? await ensureApiKey();
+	return {
+		serverUrl: resolveServerUrl(explicitServer, config.serverUrl),
+		slug: config.slug,
+		apiKey
+	};
+}
+//#endregion
+export { DEFAULT_DEV_SERVER, getMonorepoRoot, getServerInfo, isDevMode, resolveServerUrl };

package/dist/{_api-client-H4MFOr8j.mjs → _api-client-CFfjWfNa.mjs}

@@ -3,7 +3,7 @@
 /**
 * Shared HTTP helpers for platform API calls (deploy, delete, secrets).
 */
-const HINT_INVALID_API_KEY = "Your API key may be invalid. Check ~/.config/aai/config.json or set ASSEMBLYAI_API_KEY.";
+const HINT_INVALID_API_KEY = "Your API key may be invalid. Run `aai` to re-enter your AssemblyAI API key.";
 /**
 * Send an authenticated request to the platform API.
 *
@@ -31,5 +31,16 @@ async function apiRequest(url, init, fetchFn = globalThis.fetch.bind(globalThis)
 function apiError(action, status, body, hint) {
 	return /* @__PURE__ */ new Error(`${action} failed (HTTP ${status}): ${body}${hint ? `\n  ${hint}` : ""}`);
 }
+/**
+* Like `apiRequest`, but throws on non-ok responses with status-specific hints.
+* The 401 hint is always included. Pass additional hints via `opts.hints`.
+*/
+async function apiRequestOrThrow(url, init, opts) {
+	const resp = await apiRequest(url, init, opts?.fetch);
+	if (resp.ok) return resp;
+	const text = await resp.text();
+	const hint = resp.status === 401 ? HINT_INVALID_API_KEY : opts?.hints?.[resp.status];
+	throw apiError(init.action, resp.status, text, hint);
+}
 //#endregion
-export { apiError as n, apiRequest as r, HINT_INVALID_API_KEY as t };
+export { apiRequestOrThrow as t };

package/dist/_bundler-DgRDzBzD.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { a as ok } from "./_output-BKdAJaM5.mjs";
+import { r as validateAgentExport, t as fileExists } from "./_utils-DZo3_J_v.mjs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import fs from "node:fs/promises";
+import { agentToolsToSchemas, toAgentConfig } from "@alexkroman1/aai/manifest";
+import { build } from "vite";
+//#region _bundler.ts
+/** Shared Vite build base config for agent bundles. */
+function agentViteBuildBase(entry) {
+	return {
+		logLevel: "silent",
+		build: {
+			lib: {
+				entry,
+				formats: ["es"]
+			},
+			target: "node20",
+			minify: false,
+			rollupOptions: { output: { entryFileNames: "[name].js" } }
+		}
+	};
+}
+/**
+* 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) {
+	const { log } = await import("./_ui-r2t6_2eP.mjs").then((n) => n.t);
+	const [worker, clientFiles] = await Promise.all([buildWorker(cwd), buildClient(cwd)]);
+	const agentDef = await evalWorkerBundle(worker, 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.
+*/
+async function evalWorkerBundle(code, cwd) {
+	const evalDir = path.join(cwd, ".aai", "eval");
+	await fs.mkdir(evalDir, { recursive: true });
+	const tmpPath = path.join(evalDir, `agent-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`);
+	try {
+		await fs.writeFile(tmpPath, code);
+		const mod = await import(pathToFileURL(tmpPath).href);
+		const agentDef = mod.default ?? mod;
+		validateAgentExport(agentDef);
+		return agentDef;
+	} finally {
+		await fs.rm(tmpPath).catch(() => {});
+	}
+}
+/**
+* Bundle agent.ts into a single ESM string for the sandbox worker.
+*
+* Zod is bundled in — zod 4's `Function()` usage is wrapped in try/catch
+* and gracefully degrades in restricted environments like Deno.
+*/
+async function buildWorker(cwd) {
+	const base = agentViteBuildBase(path.join(cwd, "agent.ts"));
+	const result = await build({
+		...base,
+		plugins: [{
+			name: "raw-md",
+			transform(code, id) {
+				if (id.endsWith(".md")) return `export default ${JSON.stringify(code)}`;
+			}
+		}],
+		build: {
+			...base.build,
+			lib: {
+				...base.build.lib,
+				fileName: "worker"
+			},
+			write: false,
+			rollupOptions: { output: { entryFileNames: "[name].js" } }
+		}
+	});
+	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);
+	if (!chunk) throw new Error("Vite produced no entry chunk for agent.ts");
+	return chunk.code;
+}
+/**
+* Build the client SPA using Vite if client.tsx exists.
+* Returns a map of relative file paths to string contents for deploy.
+*/
+async function buildClient(cwd) {
+	if (!await fileExists(path.join(cwd, "client.tsx"))) return {};
+	const clientDir = path.join(cwd, ".aai", "client");
+	await build({
+		root: cwd,
+		base: "./",
+		logLevel: "silent",
+		build: {
+			outDir: ".aai/client",
+			emptyOutDir: true
+		}
+	});
+	const files = {};
+	async function walk(dir, prefix) {
+		for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+			const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) await walk(path.join(dir, entry.name), rel);
+			else files[rel] = await fs.readFile(path.join(dir, entry.name), "utf-8");
+		}
+	}
+	await walk(clientDir, "");
+	return files;
+}
+async function executeBuild(cwd) {
+	const { log } = await import("./_ui-r2t6_2eP.mjs").then((n) => n.t);
+	const bundle = await buildAgentBundle(cwd);
+	log.success("Build complete");
+	return ok({
+		name: bundle.agentConfig.name,
+		workerBytes: bundle.worker.length
+	});
+}
+//#endregion
+export { buildAgentBundle, executeBuild };

package/dist/_config-Dv-T6uRj.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { t as __exportAll } from "./rolldown-runtime-DacLjcLf.mjs";
+import path from "node:path";
+import * as p from "@clack/prompts";
+import fs from "node:fs/promises";
+import { consola } from "consola";
+import os from "node:os";
+import { z } from "zod";
+//#region _config.ts
+var _config_exports = /* @__PURE__ */ __exportAll({
+	ensureApiKey: () => ensureApiKey,
+	getConfigDir: () => getConfigDir,
+	readGlobalConfig: () => readGlobalConfig,
+	readProjectConfig: () => readProjectConfig,
+	writeGlobalConfig: () => writeGlobalConfig,
+	writeProjectConfig: () => writeProjectConfig
+});
+const ProjectConfigSchema = z.object({
+	slug: z.string(),
+	serverUrl: z.string(),
+	sessionId: z.string().optional()
+});
+function getConfigDir() {
+	if (process.platform === "win32") return path.join(process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"), "aai");
+	return path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"), "aai");
+}
+async function readProjectConfig(agentDir) {
+	try {
+		return ProjectConfigSchema.parse(JSON.parse(await fs.readFile(path.join(agentDir, ".aai", "project.json"), "utf-8")));
+	} catch (error) {
+		consola.debug(`Failed to read project config from ${path.join(agentDir, ".aai", "project.json")}:`, error);
+		return null;
+	}
+}
+async function writeProjectConfig(agentDir, data) {
+	const aaiDir = path.join(agentDir, ".aai");
+	await fs.mkdir(aaiDir, { recursive: true });
+	await fs.writeFile(path.join(aaiDir, "project.json"), `${JSON.stringify(data, null, 2)}\n`);
+}
+async function readGlobalConfig(configDir) {
+	const dir = configDir ?? getConfigDir();
+	try {
+		return JSON.parse(await fs.readFile(path.join(dir, "config.json"), "utf-8"));
+	} catch {
+		return {};
+	}
+}
+async function writeGlobalConfig(configDir, data) {
+	await fs.mkdir(configDir, { recursive: true });
+	await fs.writeFile(path.join(configDir, "config.json"), `${JSON.stringify(data, null, 2)}\n`);
+}
+async function ensureApiKey(configDir) {
+	const dir = configDir ?? getConfigDir();
+	const config = await readGlobalConfig(dir);
+	if (config.apiKey) return config.apiKey;
+	const envKey = process.env.ASSEMBLYAI_API_KEY;
+	if (envKey) {
+		await writeGlobalConfig(dir, {
+			...config,
+			apiKey: envKey
+		});
+		return envKey;
+	}
+	const result = await p.password({ message: "Enter your AssemblyAI API key" });
+	if (p.isCancel(result)) {
+		p.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	const apiKey = result;
+	await writeGlobalConfig(dir, {
+		...config,
+		apiKey
+	});
+	return apiKey;
+}
+//#endregion
+export { writeProjectConfig as i, ensureApiKey as n, readProjectConfig as r, _config_exports as t };

package/dist/_dev-server-Cag4LlkI.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import { r as log } from "./_ui-r2t6_2eP.mjs";
+import { r as validateAgentExport } from "./_utils-DZo3_J_v.mjs";
+import { n as ensureApiKey } from "./_config-Dv-T6uRj.mjs";
+import { t as resolveServerEnv } from "./_server-common-Pdb-KUSK.mjs";
+import { existsSync, watch } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { errorMessage } from "@alexkroman1/aai";
+import pDebounce from "p-debounce";
+//#region _dev-server.ts
+/**
+* Dev server for directory-based agents.
+*
+* Imports agent.ts directly for the full agent definition,
+* builds a runtime, and starts an HTTP+WebSocket server. Watches for
+* file changes and restarts automatically. Optionally runs Vite for
+* client SPA HMR.
+*/
+async function resolveAgentEnv(root) {
+	const env = await resolveServerEnv(root);
+	if (!env.ASSEMBLYAI_API_KEY) env.ASSEMBLYAI_API_KEY = await ensureApiKey();
+	return env;
+}
+/**
+* Load agent definition from agent.ts directly.
+* Uses cache-busting query param for hot reload support.
+*/
+async function loadAgentDef(cwd) {
+	const agentDef = (await import(`${pathToFileURL(path.join(cwd, "agent.ts")).href}?t=${Date.now()}`)).default;
+	validateAgentExport(agentDef);
+	return agentDef;
+}
+/**
+* Watch the agent directory for changes and call `onChange` when detected.
+* Debounces to avoid rapid restarts.
+*/
+function watchDirectory(dir, onChange) {
+	const watchers = [];
+	const debouncedChange = pDebounce((filename) => {
+		log.info("File change detected, restarting...");
+		onChange(filename);
+	}, 300);
+	function handleChange(filename) {
+		if (filename && (filename.startsWith(".aai") || filename.includes("node_modules"))) return;
+		debouncedChange(filename);
+	}
+	watchers.push(watch(dir, { persistent: false }, (_event, filename) => handleChange(filename)));
+	return watchers;
+}
+/**
+* Start the dev server for a directory-based agent.
+*
+* Returns a cleanup function to shut down the server and watchers.
+*/
+async function startDevServer(opts) {
+	const { cwd, port } = opts;
+	const { createRuntime, createServer } = await import("@alexkroman1/aai/runtime");
+	const hasClient = existsSync(path.join(cwd, "client.tsx"));
+	const backendPort = hasClient ? port + 1 : port;
+	const vitePort = port;
+	const agentDef = await loadAgentDef(cwd);
+	const env = await resolveAgentEnv(cwd);
+	const agentServer = createServer({
+		runtime: createRuntime({
+			agent: agentDef,
+			env
+		}),
+		name: agentDef.name
+	});
+	await agentServer.listen(backendPort);
+	let viteServer;
+	if (hasClient) {
+		const { createServer: createViteServer } = await import("vite");
+		const target = `http://localhost:${backendPort}`;
+		viteServer = await createViteServer({
+			root: cwd,
+			server: {
+				port: vitePort,
+				proxy: {
+					"/health": target,
+					"/websocket": {
+						target,
+						ws: true
+					}
+				}
+			}
+		});
+		await viteServer.listen();
+	}
+	let restarting = false;
+	let currentServer = agentServer;
+	let currentVite = viteServer;
+	let currentEnv = env;
+	const watchers = watchDirectory(cwd, () => {
+		if (restarting) return;
+		restarting = true;
+		restart().finally(() => {
+			restarting = false;
+		});
+	});
+	async function restart() {
+		try {
+			await currentServer.close();
+		} catch {}
+		try {
+			const newAgentDef = await loadAgentDef(cwd);
+			currentEnv = await resolveAgentEnv(cwd);
+			const newServer = createServer({
+				runtime: createRuntime({
+					agent: newAgentDef,
+					env: currentEnv
+				}),
+				name: newAgentDef.name
+			});
+			await newServer.listen(backendPort);
+			currentServer = newServer;
+			log.success("Restarted");
+		} catch (err) {
+			log.error(`Restart failed: ${errorMessage(err)}`);
+		}
+	}
+	return async () => {
+		for (const w of watchers) w.close();
+		if (currentVite) {
+			await currentVite.close();
+			currentVite = void 0;
+		}
+		await currentServer.close();
+	};
+}
+//#endregion
+export { startDevServer };

package/dist/_init-DhX1a2Zb.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import { isDevMode } from "./_agent-CzbSa09n.mjs";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs 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 (process.env.AAI_TEMPLATES_DIR) return process.env.AAI_TEMPLATES_DIR;
+	if (isDevMode()) return resolveLocalTemplatesDir();
+	const { dir } = await downloadTemplate(`${GIGET_SOURCE}#${GIGET_REF}`, { force: true });
+	return dir;
+}
+/**
+* Download a template into targetDir, merging scaffold files underneath.
+*/
+async function downloadAndMergeTemplate(template, targetDir) {
+	const root = await resolveTemplatesDir();
+	const templatesDir = path.join(root, "templates");
+	const names = (await fs.readdir(templatesDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+	if (!names.includes(template)) throw new Error(`Unknown template "${template}". Available templates: ${names.join(", ")}`);
+	await fs.cp(path.join(templatesDir, template), targetDir, {
+		recursive: true,
+		force: true
+	});
+	const scaffoldDir = path.join(root, "scaffold");
+	if (existsSync(scaffoldDir)) {
+		const entries = await fs.readdir(scaffoldDir, {
+			recursive: true,
+			withFileTypes: true
+		});
+		for (const entry of entries) {
+			if (!entry.isFile()) continue;
+			const rel = path.relative(scaffoldDir, path.join(entry.parentPath, entry.name));
+			const destPath = path.join(targetDir, rel);
+			await fs.mkdir(path.dirname(destPath), { recursive: true });
+			try {
+				await fs.copyFile(path.join(scaffoldDir, rel), destPath, fs.constants.COPYFILE_EXCL);
+			} catch (err) {
+				if (!(err instanceof Error && "code" in err && err.code === "EEXIST")) throw err;
+			}
+		}
+	}
+}
+//#endregion
+//#region _init.ts
+function readmeContent(slug) {
+	return `# ${slug}
+
+A voice agent built with [aai](https://github.com/anthropics/aai).
+
+## Getting started
+
+\`\`\`sh
+npm install        # Install dependencies
+aai dev            # Run locally (opens browser)
+aai 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
+\`\`\`
+
+`;
+}
+/**
+* Map from npm package name to directory name under packages/.
+* Used to rewrite published version ranges to link: paths in dev mode.
+*/
+const WORKSPACE_PKG_DIRS = {
+	"@alexkroman1/aai": "aai",
+	"@alexkroman1/aai-cli": "aai-cli",
+	"@alexkroman1/aai-ui": "aai-ui",
+	"aai-server": "aai-server",
+	"aai-templates": "aai-templates"
+};
+/** Rewrite workspace deps to link: paths so pnpm links to local source. */
+async function patchPackageJsonForWorkspace(targetDir) {
+	const pkgPath = path.join(targetDir, "package.json");
+	let raw;
+	try {
+		raw = await fs.readFile(pkgPath, "utf-8");
+	} catch {
+		return;
+	}
+	const pkgJson = JSON.parse(raw);
+	pkgJson.name = path.basename(targetDir);
+	delete pkgJson.packageManager;
+	const { getMonorepoRoot } = await import("./_agent-CzbSa09n.mjs");
+	const root = getMonorepoRoot();
+	if (!root) return;
+	const packagesDir = path.join(root, "packages");
+	for (const field of ["dependencies", "devDependencies"]) {
+		const deps = pkgJson[field];
+		if (!deps) continue;
+		for (const key of Object.keys(deps)) {
+			const dir = WORKSPACE_PKG_DIRS[key];
+			if (dir) deps[key] = `link:${path.relative(targetDir, path.join(packagesDir, dir))}`;
+		}
+	}
+	await fs.writeFile(pkgPath, `${JSON.stringify(pkgJson, null, 2)}\n`);
+}
+async function runInit(opts) {
+	const { targetDir } = opts;
+	await downloadAndMergeTemplate(opts.template ?? "simple", targetDir);
+	if (isDevMode()) {
+		await patchPackageJsonForWorkspace(targetDir);
+		try {
+			await fs.unlink(path.join(targetDir, ".npmrc"));
+		} catch {}
+	}
+	try {
+		await fs.copyFile(path.join(targetDir, ".env.example"), path.join(targetDir, ".env"));
+	} catch {}
+	const readmePath = path.join(targetDir, "README.md");
+	const slug = path.basename(path.resolve(targetDir));
+	try {
+		await fs.writeFile(readmePath, readmeContent(slug), { flag: "wx" });
+	} catch (err) {
+		if (!(err instanceof Error && "code" in err && err.code === "EEXIST")) throw err;
+	}
+	return targetDir;
+}
+//#endregion
+export { runInit };

package/dist/_output-BKdAJaM5.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { t as __exportAll } from "./rolldown-runtime-DacLjcLf.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.
+*
+* Priority: --json flag > --no-json flag > TTY auto-detection.
+*/
+function getOutputMode(args, isTTY = Boolean(process.stdout.isTTY)) {
+	if (args.json === true) return "json";
+	if (args.json === false) return "human";
+	return isTTY ? "human" : "json";
+}
+/**
+* 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.
+* - In JSON mode, writes exactly one JSON line to stdout.
+*/
+async function withOutput(mode, fn, humanRender) {
+	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);
+	}
+}
+/** Create an ok result. */
+function ok(data) {
+	return {
+		ok: true,
+		data
+	};
+}
+/** Create an error result. */
+function fail(code, error, hint) {
+	return hint ? {
+		ok: false,
+		error,
+		code,
+		hint
+	} : {
+		ok: false,
+		error,
+		code
+	};
+}
+/** Typed CLI error that carries a structured error code and optional hint. */
+var CliError = class extends Error {
+	code;
+	hint;
+	constructor(code, message, hint) {
+		super(message);
+		this.name = "CliError";
+		this.code = code;
+		if (hint !== void 0) this.hint = hint;
+	}
+};
+//#endregion
+export { ok as a, getOutputMode as i, _output_exports as n, fail as r, CliError as t };

package/dist/_server-common-Pdb-KUSK.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import path from "node:path";
+import fs from "node:fs/promises";
+import { parse } from "dotenv";
+//#region _server-common.ts
+/**
+* Build the `ctx.env` record that agent tools will see at runtime.
+*
+* Only variables explicitly declared in `.env` 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 by merging the `.env` file with the current
+* environment — existing shell exports take precedence over `.env`
+* defaults, without mutating `process.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 fileEntries = {};
+	if (cwd) try {
+		fileEntries = parse(await fs.readFile(path.join(cwd, ".env"), "utf-8"));
+	} catch {}
+	const source = baseEnv ?? process.env;
+	const env = {};
+	for (const [key, fileVal] of Object.entries(fileEntries)) {
+		const val = source[key] ?? fileVal;
+		if (val !== void 0) env[key] = val;
+	}
+	return env;
+}
+//#endregion
+export { resolveServerEnv as t };