@alexkroman1/aai-cli 1.8.3 → 1.9.1

package/dist/_agent-cHGzbDVG.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { a as readProjectConfig, c as __exportAll, i as readGlobalConfig, n as approveServer, o as serverOrigin, r as ensureApiKey } from "./_config-zV70t71V.mjs";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region _agent.ts
+var _agent_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_DEV_SERVER: () => DEFAULT_DEV_SERVER,
+	DEFAULT_SERVER: () => DEFAULT_SERVER,
+	getMonorepoRoot: () => getMonorepoRoot,
+	getServerInfo: () => getServerInfo,
+	isDevMode: () => isDevMode,
+	resolveDeployTarget: () => resolveDeployTarget,
+	resolveServerUrl: () => resolveServerUrl
+});
+const DEFAULT_SERVER = "https://aai-agent.fly.dev";
+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 stripTrailingSlash(url) {
+	return url.replace(/\/+$/, "");
+}
+/** Hostnames that are always safe to target — the request never leaves the machine. */
+const LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1",
+	"[::1]"
+]);
+/**
+* Whether `origin` may receive a credential without prior user approval:
+* the shipped platform, or anything on this machine.
+*/
+function isImplicitlyTrusted(origin) {
+	if (origin === serverOrigin("https://aai-agent.fly.dev")) return true;
+	try {
+		return LOOPBACK_HOSTNAMES.has(new URL(origin).hostname);
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve which platform server to talk to.
+*
+* Precedence: an explicit `--server` flag, then dev mode, then the project
+* config, then the shipped default.
+*
+* `configUrl` comes from `.aai/project.json` — a file in the working tree, so
+* a cloned repo controls it. Because callers pair this URL with the user's API
+* key (and, for `aai secret`, with secret values), a config-supplied origin is
+* only honored when it is implicitly trusted or previously approved by the
+* user via `--server`. Otherwise a repo could redirect a credentialed request
+* to a host of its choosing simply by shipping a `project.json`, and
+* `aai deploy` would hand over the developer's key on first run.
+*
+* @param approvedOrigins - Origins from the user-owned global config.
+*/
+function resolveServerUrl(explicit, configUrl, approvedOrigins = []) {
+	if (explicit) return stripTrailingSlash(explicit);
+	if (isDevMode()) return DEFAULT_DEV_SERVER;
+	if (!configUrl) return DEFAULT_SERVER;
+	const url = stripTrailingSlash(configUrl);
+	const origin = serverOrigin(url);
+	if (origin === null) throw new Error(`Invalid serverUrl in .aai/project.json: ${configUrl}\n  Expected an absolute http(s) URL.`);
+	if (isImplicitlyTrusted(origin) || approvedOrigins.includes(origin)) return url;
+	throw new Error(`Refusing to send your API key to ${origin}.\n  It came from .aai/project.json, which is part of this project's files, not from you.
+  If you do intend to use that server, re-run with --server ${origin} to approve it.`);
+}
+/**
+* Resolve everything needed to talk to the platform: project config (null if
+* the project has never been deployed), server URL, and API key.
+*/
+async function resolveDeployTarget(cwd, explicitServer) {
+	const config = await readProjectConfig(cwd);
+	const globalConfig = await readGlobalConfig();
+	const serverUrl = resolveServerUrl(explicitServer, config?.serverUrl, globalConfig.approvedServers ?? []);
+	if (explicitServer) await approveServer(serverUrl);
+	return {
+		config,
+		serverUrl,
+		apiKey: await ensureApiKey()
+	};
+}
+/** Like resolveDeployTarget, but requires an existing deployment (project config). */
+async function getServerInfo(cwd, explicitServer) {
+	const { config, serverUrl, apiKey } = await resolveDeployTarget(cwd, explicitServer);
+	if (!config) throw new Error("No .aai/project.json found — run `aai deploy` first");
+	return {
+		serverUrl,
+		slug: config.slug,
+		apiKey
+	};
+}
+//#endregion
+export { resolveDeployTarget as a, isDevMode as i, getMonorepoRoot as n, getServerInfo as r, _agent_exports as t };

package/dist/_api-client-yJD7xGfd.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { FetchError, ofetch } from "ofetch";
+//#region _api-client.ts
+/**
+* Shared HTTP helper for platform API calls (deploy, delete, secrets).
+*
+* Built on ofetch: JSON bodies are serialized (with Content-Type set) and
+* responses parsed automatically, and transient failures (network errors,
+* 5xx/429) are retried before surfacing an error.
+*/
+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 and return the parsed
+* JSON response. Throws a descriptive error with status-specific hints on
+* failure (the 401 hint is always included; pass more via `hints`).
+*/
+async function apiRequest(url, opts) {
+	const client = opts.fetch ? ofetch.create({}, { fetch: opts.fetch }) : ofetch;
+	try {
+		return await client(url, {
+			method: opts.method ?? "GET",
+			headers: {
+				Authorization: `Bearer ${opts.apiKey}`,
+				...opts.headers
+			},
+			...opts.body !== void 0 ? { body: opts.body } : {},
+			retry: 2,
+			retryDelay: 300
+		});
+	} catch (err) {
+		throw toApiError(err, url, opts);
+	}
+}
+/** Format an ofetch failure into a descriptive, action-centric error. */
+function toApiError(err, url, opts) {
+	if (err instanceof FetchError && err.statusCode !== void 0) {
+		const status = err.statusCode;
+		const body = typeof err.data === "string" ? err.data : JSON.stringify(err.data ?? "");
+		const hint = status === 401 ? HINT_INVALID_API_KEY : opts.hints?.[status];
+		return /* @__PURE__ */ new Error(`${opts.action} failed (HTTP ${status}): ${body}${hint ? `\n  ${hint}` : ""}`);
+	}
+	const hint = "Check your network connection and verify the server URL is correct.";
+	const cause = err instanceof FetchError && err.cause !== void 0 ? err.cause : err;
+	return new Error(`${opts.action} failed: could not reach ${url}\n  ${hint}`, { cause });
+}
+//#endregion
+export { apiRequest as t };

package/dist/_bundler-BRQFvx00.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { i as ok } from "./_output-fy2bXRNb.mjs";
+import { n as log } from "./_ui-YqQ6Fi8K.mjs";
+import { s as validateAgentExport } from "./_utils-BeU10C7O.mjs";
+import { t as buildClient } from "./client-bundler-D4VKqCxw.mjs";
+import { buildWorker } from "./worker-bundler.mjs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import fs from "node:fs/promises";
+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.
+*/
+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(() => {});
+	}
+}
+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, evalWorkerBundle, executeBuild };

package/dist/_config-zV70t71V.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { a as unwrapCancel } from "./_ui-YqQ6Fi8K.mjs";
+import { a as readJson, c as writeJson } from "./_utils-BeU10C7O.mjs";
+import "node:module";
+import path from "node:path";
+import * as p from "@clack/prompts";
+import os from "node:os";
+import { consola } from "consola";
+import { z } from "zod";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region _config.ts
+var _config_exports = /* @__PURE__ */ __exportAll({
+	approveServer: () => approveServer,
+	ensureApiKey: () => ensureApiKey,
+	getConfigDir: () => getConfigDir,
+	readGlobalConfig: () => readGlobalConfig,
+	readProjectConfig: () => readProjectConfig,
+	serverOrigin: () => serverOrigin,
+	writeGlobalConfig: () => writeGlobalConfig,
+	writeProjectConfig: () => writeProjectConfig
+});
+/**
+* `.aai/project.json` lives in the working tree, so everything in it is
+* untrusted input — a cloned repo can supply any value.
+*
+* `serverUrl` is deliberately NOT validated here. A failed field makes
+* `readProjectConfig` return null for the whole file, which discards the
+* `slug` too — and a deploy with no slug generates a fresh one, silently
+* creating a duplicate agent and overwriting the config. The URL is instead
+* validated where it is used, by `resolveServerUrl`, which rejects anything
+* that isn't an approved http(s) origin.
+*/
+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) {
+	const file = path.join(agentDir, ".aai", "project.json");
+	const parsed = ProjectConfigSchema.safeParse(await readJson(file));
+	if (!parsed.success) {
+		consola.debug(`Failed to read project config from ${file}:`, parsed.error);
+		return null;
+	}
+	return parsed.data;
+}
+async function writeProjectConfig(agentDir, data) {
+	await writeJson(path.join(agentDir, ".aai", "project.json"), data);
+}
+/**
+* Origin of `url`, or `null` when it is not an absolute http(s) URL.
+*
+* Non-HTTP schemes are rejected rather than returned: `new URL()` yields the
+* opaque origin `"null"` for them, which would otherwise flow on as if it
+* were a real origin.
+*/
+function serverOrigin(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return null;
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+	return parsed.origin;
+}
+/**
+* Record `url`'s origin as user-approved, so later commands in this project
+* may send credentials there without re-passing `--server`.
+*/
+async function approveServer(url, configDir) {
+	const origin = serverOrigin(url);
+	if (!origin) return;
+	const dir = configDir ?? getConfigDir();
+	const config = await readGlobalConfig(dir);
+	const approved = config.approvedServers ?? [];
+	if (approved.includes(origin)) return;
+	await writeGlobalConfig(dir, {
+		...config,
+		approvedServers: [...approved, origin]
+	});
+}
+async function readGlobalConfig(configDir) {
+	const dir = configDir ?? getConfigDir();
+	return await readJson(path.join(dir, "config.json")) ?? {};
+}
+async function writeGlobalConfig(configDir, data) {
+	await writeJson(path.join(configDir, "config.json"), data);
+}
+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 apiKey = unwrapCancel(await p.password({ message: "Enter your AssemblyAI API key" }));
+	await writeGlobalConfig(dir, {
+		...config,
+		apiKey
+	});
+	return apiKey;
+}
+//#endregion
+export { readProjectConfig as a, __exportAll as c, readGlobalConfig as i, approveServer as n, serverOrigin as o, ensureApiKey as r, writeProjectConfig as s, _config_exports as t };

package/dist/_dev-server-CBrIeDoI.mjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+import { r as ensureApiKey } from "./_config-zV70t71V.mjs";
+import { n as log } from "./_ui-YqQ6Fi8K.mjs";
+import { n as errorMessage } from "./_utils-BeU10C7O.mjs";
+import { n as fallbackHtmlPlugin } from "./client-bundler-D4VKqCxw.mjs";
+import { buildWorker } from "./worker-bundler.mjs";
+import { evalWorkerBundle } from "./_bundler-BRQFvx00.mjs";
+import { t as resolveServerEnv } from "./_server-common-QpOTRZgi.mjs";
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { requiredProviderEnvVars, withHostCredentialFallback } from "@alexkroman1/aai/runtime";
+import { watch } from "chokidar";
+import getPort, { portNumbers } from "get-port";
+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, 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.`);
+	return env;
+}
+/**
+* The env handed to `createServer` for host-mode connections: provider
+* credentials plus the `AAI_ALLOW_HOST` gate read straight from the shell
+* (it is a control variable, not something an agent declares in `.env`).
+*/
+function hostModeEnv(providerEnv) {
+	const gate = process.env.AAI_ALLOW_HOST;
+	return gate === void 0 ? providerEnv : {
+		...providerEnv,
+		AAI_ALLOW_HOST: gate
+	};
+}
+/**
+* Explicit bind host for the dev server, or `undefined` to take the
+* loopback default. An empty `AAI_DEV_HOST` means "unset", not "every
+* interface" — Node treats `listen(port, "")` as 0.0.0.0, which would quietly
+* undo the loopback default this exists to guard.
+*/
+function devBindHost() {
+	const host = process.env.AAI_DEV_HOST?.trim();
+	return host ? host : void 0;
+}
+/**
+* Load the agent definition by bundling agent.ts (and all its local imports)
+* into a single ESM file, then importing that. A raw `import(agent.ts?t=...)`
+* only cache-busts agent.ts itself — transitive imports (./tools.ts, etc.)
+* stay in Node's ESM registry, so edits to them are ignored on reload.
+* Bundling picks them up and matches the deploy path exactly.
+*/
+async function loadAgentDef(cwd) {
+	return evalWorkerBundle(await buildWorker(cwd), cwd);
+}
+/**
+* True for paths that should never trigger a restart: anything inside
+* `node_modules/` and any dot-entry (`.git/`, `.aai/`, `.DS_Store`, …).
+* `.git/` especially matters — commits and status checks churn the index
+* and would otherwise cause spurious full backend restarts.
+*
+* Exception: `.env` / `.env.*` files stay watched — env edits should
+* restart the server with the new values.
+*/
+function isIgnoredPath(dir, filePath) {
+	const rel = path.relative(dir, filePath);
+	if (!rel || rel.startsWith("..")) return false;
+	return rel.split(path.sep).some((segment) => {
+		if (segment === "node_modules") return true;
+		if (segment === ".env" || segment.startsWith(".env.")) return false;
+		return segment.startsWith(".");
+	});
+}
+/**
+* Watch the agent directory for changes and call `onChange` when detected.
+* Debounces to avoid rapid restarts. Uses chokidar for reliable recursive
+* watching across platforms (raw `fs.watch` misses events on Linux).
+*/
+function watchDirectory(dir, onChange) {
+	const debouncedChange = pDebounce(() => {
+		log.info("File change detected, restarting...");
+		onChange();
+	}, 300);
+	const watcher = watch(dir, {
+		ignored: (filePath) => isIgnoredPath(dir, filePath),
+		ignoreInitial: true,
+		persistent: false
+	});
+	watcher.on("all", () => void debouncedChange());
+	return watcher;
+}
+/** Locate the pre-built default aai-ui client (served when no custom client.tsx). */
+function resolveDefaultClientDir() {
+	const pkgPath = createRequire(import.meta.url).resolve("@alexkroman1/aai-ui/package.json");
+	return path.join(path.dirname(pkgPath), "dist", "default-client");
+}
+/**
+* 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 ? await getPort({ port: portNumbers(port + 1, port + 100) }) : port;
+	const vitePort = port;
+	const clientDirOpt = hasClient ? {} : { clientDir: resolveDefaultClientDir() };
+	/** Full build sequence, shared by initial startup and every restart. */
+	async function buildServer() {
+		const agentDef = await loadAgentDef(cwd);
+		const env = await resolveAgentEnv(cwd, agentDef);
+		const providerEnv = withHostCredentialFallback(env);
+		const runtime = createRuntime({
+			agent: agentDef,
+			env,
+			providerEnv
+		});
+		return createServer({
+			runtime,
+			name: agentDef.name,
+			env: hostModeEnv(providerEnv),
+			hostBaseAgent: agentDef,
+			...clientDirOpt
+		});
+	}
+	const agentServer = await buildServer();
+	await agentServer.listen(backendPort, devBindHost());
+	let viteServer;
+	if (hasClient) {
+		const { createServer: createViteServer } = await import("vite");
+		const target = `http://localhost:${backendPort}`;
+		viteServer = await createViteServer({
+			root: cwd,
+			plugins: [fallbackHtmlPlugin(cwd)],
+			server: {
+				port: vitePort,
+				proxy: {
+					"/health": target,
+					"/websocket": {
+						target,
+						ws: true
+					}
+				}
+			}
+		});
+		await viteServer.listen();
+	}
+	let restarting = false;
+	let pendingRestart = false;
+	let closed = false;
+	let currentServer = agentServer;
+	const watcher = watchDirectory(cwd, () => {
+		if (restarting) {
+			pendingRestart = true;
+			return;
+		}
+		restarting = true;
+		restart().finally(() => {
+			restarting = false;
+		});
+	});
+	async function restart() {
+		do {
+			pendingRestart = false;
+			await restartOnce();
+		} while (pendingRestart && !closed);
+	}
+	async function restartOnce() {
+		let newServer;
+		try {
+			newServer = await buildServer();
+		} catch (err) {
+			log.error(`Restart failed: ${errorMessage(err)} (previous server still running)`);
+			return;
+		}
+		if (closed) {
+			await newServer.close().catch(() => void 0);
+			return;
+		}
+		try {
+			await currentServer.close();
+		} catch {}
+		try {
+			await newServer.listen(backendPort, devBindHost());
+			currentServer = newServer;
+			if (closed) {
+				await newServer.close().catch(() => void 0);
+				return;
+			}
+			log.success("Restarted");
+		} catch (err) {
+			log.error(`Restart failed: ${errorMessage(err)}`);
+			await newServer.close().catch(() => void 0);
+		}
+	}
+	return async () => {
+		closed = true;
+		await watcher.close();
+		await viteServer?.close();
+		await currentServer.close();
+	};
+}
+//#endregion
+export { startDevServer };

package/dist/{_init-Bh5etNEh.mjs → _init-y7K-dzni.mjs}

@@ -1,27 +1,19 @@
 #!/usr/bin/env node
-import { isDevMode } from "./_agent-De8f1JdZ.mjs";
+import { a as readJson, c as writeJson, i as isEexist } from "./_utils-BeU10C7O.mjs";
+import { i as isDevMode, n as getMonorepoRoot } from "./_agent-cHGzbDVG.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import fs from "node:fs/promises";
 import os from "node:os";
 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 monorepoRoot = isDevMode() ? getMonorepoRoot() : null;
+	if (monorepoRoot) return path.join(monorepoRoot, "packages", "aai-templates");
 	const extractDir = await fs.mkdtemp(path.join(os.tmpdir(), "aai-templates-"));
 	const { dir } = await downloadTemplate(`${GIGET_SOURCE}#${GIGET_REF}`, {
 		dir: extractDir,
@@ -43,23 +35,11 @@ async function downloadAndMergeTemplate(template, targetDir) {
 		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;
-			}
-		}
-	}
+	if (existsSync(scaffoldDir)) await fs.cp(scaffoldDir, targetDir, {
+		recursive: true,
+		force: false,
+		errorOnExist: false
+	});
 }
 //#endregion
 //#region _init.ts
@@ -111,16 +91,11 @@ const WORKSPACE_PKG_DIRS = {
 /** 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);
+	const pkgJson = await readJson(pkgPath);
+	if (!pkgJson) return;
 	pkgJson.name = path.basename(targetDir);
 	delete pkgJson.packageManager;
-	const { getMonorepoRoot } = await import("./_agent-De8f1JdZ.mjs");
+	const { getMonorepoRoot } = await import("./_agent-cHGzbDVG.mjs").then((n) => n.t);
 	const root = getMonorepoRoot();
 	if (!root) return;
 	const packagesDir = path.join(root, "packages");
@@ -132,11 +107,11 @@ async function patchPackageJsonForWorkspace(targetDir) {
 			if (dir) deps[key] = `link:${path.relative(targetDir, path.join(packagesDir, dir))}`;
 		}
 	}
-	await fs.writeFile(pkgPath, `${JSON.stringify(pkgJson, null, 2)}\n`);
+	await writeJson(pkgPath, pkgJson);
 }
 async function runInit(opts) {
-	const { targetDir } = opts;
-	await downloadAndMergeTemplate(opts.template ?? "simple", targetDir);
+	const { targetDir, template } = opts;
+	await downloadAndMergeTemplate(template, targetDir);
 	if (isDevMode()) {
 		await patchPackageJsonForWorkspace(targetDir);
 		try {
@@ -144,16 +119,15 @@ async function runInit(opts) {
 		} catch {}
 	}
 	try {
-		await fs.copyFile(path.join(targetDir, ".env.example"), path.join(targetDir, ".env"));
+		await fs.copyFile(path.join(targetDir, ".env.example"), path.join(targetDir, ".env"), fs.constants.COPYFILE_EXCL);
 	} 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;
+		if (!isEexist(err)) throw err;
 	}
-	return targetDir;
 }
 //#endregion
 export { runInit };