@alexkroman1/aai-cli 5.1.0 → 5.2.0

package/dist/_output.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Structured output support for CLI commands.
+ *
+ * In JSON mode (non-TTY or --json), commands emit exactly one JSON line to
+ * stdout. In human mode (TTY, default), commands use @clack/prompts as before.
+ */
+export type OutputMode = "json" | "human";
+export type CommandResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+    code: string;
+    hint?: string;
+};
+/**
+ * Determine output mode from CLI flags and TTY state.
+ *
+ * Priority: --json flag > --no-json flag > TTY auto-detection.
+ */
+export declare function getOutputMode(args: {
+    json?: boolean | undefined;
+}, isTTY?: boolean): OutputMode;
+/**
+ * Write a line to stdout, resolving only once it has been flushed.
+ *
+ * Resolves (never rejects) even when the write fails: the common failure is
+ * EPIPE — the consumer closed the pipe (`aai … --json | head -1`) — and there
+ * is nothing useful to do about a broken stdout except carry on and exit.
+ * Stream-level `'error'` events are handled by {@link installStdoutGuard}.
+ */
+export declare function writeLine(line: string): Promise<void>;
+/**
+ * Install an `'error'` listener on stdout so a broken pipe doesn't crash the
+ * CLI with an unhandled `'error'` event. EPIPE (consumer went away, e.g.
+ * `aai … --json | head -1`) exits quietly; anything else is reported on
+ * stderr and exits non-zero.
+ */
+export declare function installStdoutGuard(stream?: NodeJS.WriteStream): void;
+/** Create an ok result. */
+export declare function ok<T>(data: T): CommandResult<T>;
+/** Create an error result. */
+export declare function fail<T>(code: string, error: string, hint?: string): CommandResult<T>;
+/** Typed CLI error that carries a structured error code and optional hint. */
+export declare class CliError extends Error {
+    readonly code: string;
+    readonly hint?: string | undefined;
+    constructor(code: string, message: string, hint?: string, options?: ErrorOptions);
+}

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { r as errorCode } from "./_utils-Ch0J4s6a.mjs";
 import path from "node:path";
 import { parseEnv } from "node:util";
 import fs from "node:fs/promises";
@@ -26,7 +27,7 @@ async function resolveServerEnv(cwd, baseEnv) {
 		try {
 			content = await fs.readFile(path.join(cwd, ".env"), "utf-8");
 		} catch (err) {
-			if (err.code !== "ENOENT") throw err;
+			if (errorCode(err) !== "ENOENT") throw err;
 		}
 		if (content !== null) fileEntries = parseEnv(content);
 	}

package/dist/_server-common.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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).
+ */
+export declare function resolveServerEnv(cwd?: string, baseEnv?: Record<string, string | undefined>): Promise<Record<string, string>>;

package/dist/_slug-api-19R5kZ0U.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { n as getServerInfo } from "./_agent-D8zBb3M5.mjs";
+import { n as apiRequest, t as HINT_NOT_DEPLOYED } from "./_api-client-MenP4-O7.mjs";
+//#region _slug-api.ts
+/**
+* Authenticated request against a deployed agent's slug-scoped resource
+* (`${serverUrl}/${slug}${resourcePath}`) — the one shape every per-agent
+* command (secret, storage) shares, including the standard "not deployed"
+* 404 hint.
+*
+* Its own module (rather than living beside `getServerInfo` in `_agent.ts`)
+* so tests can mock `_agent.ts`/`_api-client.ts` while this composition
+* stays real — an intra-module call would bypass those mocks.
+*/
+async function slugRequest(cwd, resourcePath, init, server) {
+	const { serverUrl, slug, apiKey } = await getServerInfo(cwd, server);
+	return {
+		data: await apiRequest(`${serverUrl}/${slug}${resourcePath}`, {
+			...init,
+			apiKey,
+			hints: { 404: HINT_NOT_DEPLOYED }
+		}),
+		slug
+	};
+}
+//#endregion
+export { slugRequest as t };

package/dist/_slug-api.d.ts

@@ -0,0 +1,15 @@
+import { type ApiRequestOptions } from "./_api-client.ts";
+/**
+ * Authenticated request against a deployed agent's slug-scoped resource
+ * (`${serverUrl}/${slug}${resourcePath}`) — the one shape every per-agent
+ * command (secret, storage) shares, including the standard "not deployed"
+ * 404 hint.
+ *
+ * Its own module (rather than living beside `getServerInfo` in `_agent.ts`)
+ * so tests can mock `_agent.ts`/`_api-client.ts` while this composition
+ * stays real — an intra-module call would bypass those mocks.
+ */
+export declare function slugRequest<T = unknown>(cwd: string, resourcePath: string, init: Pick<ApiRequestOptions, "method" | "body" | "action">, server?: string): Promise<{
+    data: T;
+    slug: string;
+}>;

package/dist/_templates.d.ts

@@ -0,0 +1,21 @@
+export declare const REPO_URL = "https://github.com/alexkroman/agent";
+/**
+ * Templates as shipped inside the published tarball, copied into `dist/` by
+ * `bundle-templates.mjs` at build time — so this resolves to `dist/` for a
+ * published CLI and to the (template-less) package root when running source
+ * in the monorepo, where the branch above wins.
+ *
+ * They used to be fetched at `init` time with giget from
+ * `github:alexkroman/agent/packages/aai-templates#main`. That required a
+ * network for every `init`, and pinned templates to `main` regardless of the
+ * CLI version the user had installed, so a template written against a newer
+ * SDK could land in a project resolving an older one. Bundling pins the two
+ * together by construction. It also puts the templates inside the studio's
+ * guest sandbox, which has the CLI in its baked toolchain but no way to fetch
+ * anything from GitHub.
+ */
+export declare function bundledTemplatesDir(): string;
+/**
+ * Copy a template into targetDir, merging scaffold files underneath.
+ */
+export declare function downloadAndMergeTemplate(template: string, targetDir: string): Promise<void>;

package/dist/{_typecheck-gate-B1GcKZX-.mjs → _typecheck-gate-9IHWDnl1.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as log, o as CliError } from "./_ui-DXZ9prrM.mjs";
+import { n as log, o as CliError } from "./_ui-8kOEB-JH.mjs";
 import { typecheckProject } from "./typecheck.mjs";
 //#region _typecheck-gate.ts
 /**
@@ -14,4 +14,4 @@ async function assertTypechecks(cwd) {
 	if (!result.ok) throw new CliError("typecheck_failed", result.output, "Fix the type errors, or pass --skipTypecheck to build anyway");
 }
 //#endregion
-export { assertTypechecks };
+export { assertTypechecks as t };

package/dist/_typecheck-gate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export declare function assertTypechecks(cwd: string): Promise<void>;

package/dist/{_ui-DXZ9prrM.mjs → _ui-8kOEB-JH.mjs}

@@ -83,10 +83,13 @@ const log = new Proxy(p.log, { get(target, prop, receiver) {
 function silenceOutput() {
 	silenced = true;
 }
-/** Unwrap a clack prompt result, exiting cleanly if the user cancelled. */
-function unwrapCancel(result) {
+/**
+* Unwrap a clack prompt result, exiting cleanly if the user cancelled.
+* `message` lets the caller name what was cancelled (e.g. "Setup cancelled").
+*/
+function unwrapCancel(result, message = "Cancelled") {
 	if (p.isCancel(result)) {
-		p.cancel("Setup cancelled");
+		p.cancel(message);
 		process.exit(0);
 	}
 	return result;

package/dist/_ui.d.ts

@@ -0,0 +1,22 @@
+import * as p from "@clack/prompts";
+type Log = typeof p.log;
+/** Log instance that delegates to clack (human mode) or no-ops (JSON mode). */
+export declare const log: Log;
+/** Replace all log methods with no-ops. Call once in JSON mode. */
+export declare function silenceOutput(): void;
+/**
+ * Unwrap a clack prompt result, exiting cleanly if the user cancelled.
+ * `message` lets the caller name what was cancelled (e.g. "Setup cancelled").
+ */
+export declare function unwrapCancel<T>(result: T | symbol, message?: string): T;
+/** Format a URL for display. */
+export declare function fmtUrl(url: string): string;
+/**
+ * Parse and validate a port string. Returns the numeric port or throws.
+ *
+ * Deliberately zod-free: this module loads on every CLI invocation
+ * (including `aai --help`), and keeping zod off that path is the same
+ * startup-cost invariant `_utils.ts` documents for its error helpers.
+ */
+export declare function parsePort(raw: string): number;
+export {};

package/dist/{_utils-C502jKo8.mjs → _utils-Ch0J4s6a.mjs}

@@ -1,8 +1,14 @@
 #!/usr/bin/env node
+import { readFileSync } from "node:fs";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { errorDetail, errorMessage, errorMessage as errorMessage$1 } from "@alexkroman1/aai/utils";
 //#region _utils.ts
+/**
+* The file that marks a directory as an agent project — the single source
+* for the entry filename every command checks or scaffolds.
+*/
+const AGENT_ENTRY = "agent.ts";
 /** Resolve the working directory from INIT_CWD or process.cwd(). */
 function resolveCwd() {
 	return process.env.INIT_CWD || process.cwd();
@@ -19,6 +25,16 @@ function isEexist(err) {
 function validateAgentExport(mod) {
 	if (!mod?.name || typeof mod.name !== "string") throw new Error("agent.ts must export default agent({ name: ... })");
 }
+/**
+* Absolute path of `binName`'s script declared by the package.json at
+* `pkgJsonPath`, or undefined when the package declares no such bin.
+* Handles both `"bin": "script.js"` and `"bin": { name: "script.js" }`.
+*/
+function binFromPackageJson(pkgJsonPath, binName) {
+	const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+	const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.[binName];
+	return bin ? path.join(path.dirname(pkgJsonPath), bin) : void 0;
+}
 async function fileExists(p) {
 	try {
 		await fs.access(p);
@@ -79,4 +95,4 @@ async function writeJson(filePath, data, opts = {}) {
 	}
 }
 //#endregion
-export { isEexist as a, validateAgentExport as c, fileExists as i, writeJson as l, errorDetail as n, readJson as o, errorMessage$1 as r, resolveCwd as s, errorCode as t };
+export { errorMessage$1 as a, readJson as c, writeJson as d, errorDetail as i, resolveCwd as l, binFromPackageJson as n, fileExists as o, errorCode as r, isEexist as s, AGENT_ENTRY as t, validateAgentExport as u };

package/dist/_utils.d.ts

@@ -0,0 +1,48 @@
+export { errorDetail, errorMessage } from "@alexkroman1/aai/utils";
+/**
+ * The file that marks a directory as an agent project — the single source
+ * for the entry filename every command checks or scaffolds.
+ */
+export declare const AGENT_ENTRY = "agent.ts";
+/** Resolve the working directory from INIT_CWD or process.cwd(). */
+export declare function resolveCwd(): string;
+/** The `code` of a Node errno-style error (`"ENOENT"`, `"EPIPE"`, …), or undefined. */
+export declare function errorCode(err: unknown): string | undefined;
+/** True when `err` is a filesystem EEXIST error (target already exists). */
+export declare function isEexist(err: unknown): boolean;
+/** Validate that a module's default export is a valid agent definition. Throws if invalid. */
+export declare function validateAgentExport(mod: any): void;
+/**
+ * Absolute path of `binName`'s script declared by the package.json at
+ * `pkgJsonPath`, or undefined when the package declares no such bin.
+ * Handles both `"bin": "script.js"` and `"bin": { name: "script.js" }`.
+ */
+export declare function binFromPackageJson(pkgJsonPath: string, binName: string): string | undefined;
+export declare function fileExists(p: string): Promise<boolean>;
+/**
+ * Read and parse a JSON file. Returns null only when the file does not exist
+ * (ENOENT — the "optional file" case). A file that exists but cannot be read
+ * (EACCES, …) or parsed throws instead: treating a corrupted file as absent
+ * hides real problems — e.g. a corrupted `.aai/project.json` would silently
+ * deploy under a NEW slug, orphaning the live deployment.
+ */
+export declare function readJson(filePath: string): Promise<unknown>;
+/**
+ * Write `data` as pretty-printed JSON (+ trailing newline), creating parent dirs.
+ *
+ * Writes to a temp file in the same directory, then renames it into place.
+ * A plain `writeFile` can be observed (or left, on crash) half-written; a
+ * torn config.json fails `JSON.parse`, reads back as `{}`, and the next
+ * read-modify-write silently wipes fields like `approvedServers`. Rename on
+ * the same filesystem is atomic, so readers only ever see a complete file.
+ * Two concurrent CLI processes can still lose each other's *updates*
+ * (last rename wins) — acceptable for these small user-config files.
+ *
+ * `mode` restricts the file's permissions (the rename carries the temp
+ * file's mode to the destination, so an existing world-readable file is
+ * tightened on the next write). The parent directory is created 0o700 in
+ * that case so a fresh config dir never goes through a readable window.
+ */
+export declare function writeJson(filePath: string, data: unknown, opts?: {
+    mode?: number;
+}): Promise<void>;

package/dist/_vite-env.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `env` is injectable for tests ONLY, so specs can exercise the
+ * snapshot/refcount logic on a plain object instead of mutating (and
+ * repeatedly deleting) the real `process.env.NODE_ENV` mid-suite.
+ */
+export declare function withPreservedNodeEnv<T>(fn: () => Promise<T>, env?: {
+    NODE_ENV?: string;
+}): Promise<T>;

package/dist/build-Xq1xxoSg.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { n as log, o as CliError, u as ok } from "./_ui-8kOEB-JH.mjs";
+import { r as evalWorkerBundle, t as buildAgentBundle } from "./_bundler-DFS4xxqE.mjs";
+import { t as assertTypechecks } from "./_typecheck-gate-9IHWDnl1.mjs";
+import { classifyVitestError, runVitest } from "./test-3Gq4pqH_.mjs";
+//#region build.ts
+/**
+* `aai build` — bundle the agent without deploying, behind the same gates
+* deploy runs (tests, then typecheck), so the command previews the deploy
+* artifact and its failures alike.
+*/
+/**
+* Map a {@link runVitest} failure to a CliError — distinguishing a real test
+* failure (test_failed) from the runner not spawning (spawn_failed) instead
+* of a generic command_failed.
+*/
+function testGateError(err) {
+	const { code, message } = classifyVitestError(err);
+	return new CliError(code, message, "Re-run with --skipTests to build without tests", { cause: err });
+}
+async function executeBuild(opts) {
+	const { cwd } = opts;
+	if (!opts.skipTests) try {
+		runVitest(cwd);
+	} catch (err) {
+		throw testGateError(err);
+	}
+	if (!opts.skipTypecheck) await assertTypechecks(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 { executeBuild };

package/dist/build.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `aai build` — bundle the agent without deploying, behind the same gates
+ * deploy runs (tests, then typecheck), so the command previews the deploy
+ * artifact and its failures alike.
+ */
+import { type CommandResult } from "./_output.ts";
+type BuildData = {
+    name: string;
+    workerBytes: number;
+};
+export declare function executeBuild(opts: {
+    cwd: string;
+    skipTests?: boolean | undefined;
+    skipTypecheck?: boolean | undefined;
+}): Promise<CommandResult<BuildData>>;
+export {};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare const mainCommand: import("citty").CommandDef<import("citty").ArgsDef>;

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/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-DXZ9prrM.mjs";
-import { i as fileExists, r as errorMessage, s as resolveCwd } from "./_utils-C502jKo8.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-8kOEB-JH.mjs";
+import { a as errorMessage, l as resolveCwd, o as fileExists, t as AGENT_ENTRY } from "./_utils-Ch0J4s6a.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -8,12 +8,6 @@ import { defineCommand, runMain } from "citty";
 //#region cli.ts
 /** Shared arg definitions for citty commands. */
 const sharedArgs = {
-	port: {
-		type: "string",
-		alias: "p",
-		description: "Port to listen on",
-		default: "3000"
-	},
 	server: {
 		type: "string",
 		alias: "s",
@@ -48,7 +42,7 @@ const VERSION = readCliVersion(cliDir);
 async function setup(opts) {
 	const cwd = resolveCwd();
 	if (opts?.agent) {
-		if (!await fileExists(path.join(cwd, "agent.ts"))) throw new Error("No agent.ts found in the current directory. Run `aai init` first.");
+		if (!await fileExists(path.join(cwd, "agent.ts"))) throw new Error(`No ${AGENT_ENTRY} found in the current directory. Run \`aai init\` first.`);
 	}
 	return cwd;
 }
@@ -56,7 +50,6 @@ async function setup(opts) {
 * Run a command body with standard output-mode resolution, error handling,
 * and result emission.
 *
-* - `setYes`: json mode sets `args.yes = true` (only meaningful for commands with a `yes` arg).
 * - API key acquisition is owned by `resolveDeployTarget`/`getServerInfo`
 *   inside the commands that talk to the platform — after the server-trust
 *   check, so an untrusted `serverUrl` is refused without prompting for a
@@ -66,12 +59,9 @@ async function setup(opts) {
 * human mode logs the message, JSON mode writes exactly one result line,
 * and both exit 1.
 */
-async function runCommand(args, fn, opts = {}) {
+async function runCommand(args, fn) {
 	const mode = getOutputMode(args);
-	if (mode === "json") {
-		silenceOutput();
-		if (opts.setYes) args.yes = true;
-	}
+	if (mode === "json") silenceOutput();
 	let result;
 	try {
 		result = await fn(mode);
@@ -115,16 +105,16 @@ const init = defineCommand({
 	},
 	async run({ args }) {
 		await runCommand(args, async (mode) => {
-			const { executeInit } = await import("./init-B53rR3yD.mjs");
+			const { executeInit } = await import("./init-BjeK8crW.mjs");
 			return executeInit({
 				dir: args.dir,
 				force: args.force,
 				template: args.template,
-				yes: args.yes,
+				yes: mode === "json" ? true : args.yes,
 				skipDeploy: args.skipDeploy,
 				server: args.server
 			}, mode === "json" ? { silent: true } : void 0);
-		}, { setYes: true });
+		});
 	}
 });
 const dev = defineCommand({
@@ -133,13 +123,18 @@ const dev = defineCommand({
 		description: "Start a local development server"
 	},
 	args: {
-		port: sharedArgs.port,
+		port: {
+			type: "string",
+			alias: "p",
+			description: "Port to listen on",
+			default: "3000"
+		},
 		json: sharedArgs.json
 	},
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDev } = await import("./dev-C8o-p13B.mjs");
+			const { executeDev } = await import("./dev-g7sGt8qX.mjs");
 			return executeDev({
 				cwd,
 				port: args.port
@@ -156,7 +151,7 @@ const test = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup();
-			const { executeTest } = await import("./test-CgWhus_Z.mjs");
+			const { executeTest } = await import("./test-3Gq4pqH_.mjs");
 			return executeTest(cwd);
 		});
 	}
@@ -180,24 +175,12 @@ const build = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			if (!args.skipTests) {
-				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 });
-				};
-				try {
-					runVitest(cwd);
-				} catch (err) {
-					throw toCliError(err);
-				}
-			}
-			if (!args.skipTypecheck) {
-				const { assertTypechecks } = await import("./_typecheck-gate-B1GcKZX-.mjs");
-				await assertTypechecks(cwd);
-			}
-			const { executeBuild } = await import("./_bundler-DdmuZzeR.mjs");
-			return executeBuild(cwd);
+			const { executeBuild } = await import("./build-Xq1xxoSg.mjs");
+			return executeBuild({
+				cwd,
+				skipTests: args.skipTests,
+				skipTypecheck: args.skipTypecheck
+			});
 		});
 	}
 });
@@ -221,12 +204,12 @@ const deploy = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDeploy } = await import("./deploy-D-dnt9L8.mjs");
+			const { executeDeploy } = await import("./deploy-Ci0X1gp2.mjs");
 			return executeDeploy({
 				cwd,
-				...args.server ? { server: args.server } : {},
-				...args.allowMissingSecrets ? { allowMissingSecrets: true } : {},
-				...args.skipTypecheck ? { skipTypecheck: true } : {}
+				server: args.server,
+				allowMissingSecrets: args.allowMissingSecrets,
+				skipTypecheck: args.skipTypecheck
 			});
 		});
 	}
@@ -243,10 +226,10 @@ const del = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup();
-			const { executeDelete } = await import("./delete-K24hW1ab.mjs");
+			const { executeDelete } = await import("./delete-kSXFLxek.mjs");
 			return executeDelete({
 				cwd,
-				...args.server ? { server: args.server } : {}
+				server: args.server
 			});
 		});
 	}
@@ -274,9 +257,9 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async (mode) => {
 					const cwd = await setup();
-					const { executeSecretPut, readStdin } = await import("./secret-C4unwCEw.mjs");
+					const { executeSecretPut, NO_INPUT, readStdin } = await import("./secret-DOva9OGk.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");
+					if (mode === "json" && !value) throw new CliError(...NO_INPUT);
 					return executeSecretPut(cwd, args.name, value, args.server);
 				});
 			}
@@ -298,7 +281,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretDelete } = await import("./secret-C4unwCEw.mjs");
+					const { executeSecretDelete } = await import("./secret-DOva9OGk.mjs");
 					return executeSecretDelete(cwd, args.name, args.server);
 				});
 			}
@@ -315,7 +298,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretList } = await import("./secret-C4unwCEw.mjs");
+					const { executeSecretList } = await import("./secret-DOva9OGk.mjs");
 					return executeSecretList(cwd, args.server);
 				});
 			}
@@ -350,7 +333,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageStatus } = await import("./storage-tZM1J8qj.mjs");
+					const { executeStorageStatus } = await import("./storage-vM6HjDZZ.mjs");
 					return executeStorageStatus(resolveStorageCwd(args.dir), args.server);
 				});
 			}
@@ -367,7 +350,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageEnable } = await import("./storage-tZM1J8qj.mjs");
+					const { executeStorageEnable } = await import("./storage-vM6HjDZZ.mjs");
 					return executeStorageEnable(resolveStorageCwd(args.dir), args.server);
 				});
 			}
@@ -389,7 +372,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageDisable } = await import("./storage-tZM1J8qj.mjs");
+					const { executeStorageDisable } = await import("./storage-vM6HjDZZ.mjs");
 					return executeStorageDisable(resolveStorageCwd(args.dir), {
 						server: args.server,
 						force: args.force

package/dist/{client-bundler-DO3GgO6p.mjs → client-bundler-BWDkUeEP.mjs}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { i as fileExists, r as errorMessage } from "./_utils-C502jKo8.mjs";
+import { a as errorMessage$1, o as fileExists } from "./_utils-Ch0J4s6a.mjs";
 import { t as withPreservedNodeEnv } from "./_vite-env-Dg_QlVv0.mjs";
 import { existsSync, unlinkSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import fs from "node:fs/promises";
-import { isTextAssetPath } from "@alexkroman1/aai";
+import { isTextAssetPath } from "@alexkroman1/aai/utils";
 import { build } from "vite";
 //#region _default-html.ts
 /**
@@ -65,7 +65,7 @@ function writeTempHtml(root) {
 		writeFileSync(htmlPath, DEFAULT_HTML);
 	} catch (err) {
 		cleanup();
-		throw new Error(`Failed to write a temporary index.html at ${htmlPath} for the client build — is the project directory writable? (${errorMessage(err)})`, { cause: err });
+		throw new Error(`Failed to write a temporary index.html at ${htmlPath} for the client build — is the project directory writable? (${errorMessage$1(err)})`, { cause: err });
 	}
 	return cleanup;
 }
@@ -88,8 +88,7 @@ const DEFAULT_OUT_DIR = ".aai/client";
 *
 * Deduping states the peer contract in terms the bundler enforces, and it is
 * what a React app wants anyway: two copies of React in one bundle break
-* hooks. Guarded by `client-bundler.test.ts` and, for the half that has to
-* hold in the image, `aai-server/dockerfile-packaging.test.ts`.
+* hooks. Guarded by `client-bundler.test.ts`.
 */
 const DEDUPED_PEERS = ["react", "react-dom"];
 /**
@@ -131,7 +130,7 @@ async function readClientDir(clientDir) {
 			withFileTypes: true
 		});
 	} catch (err) {
-		throw new Error(`Client build produced no output at ${clientDir}: ${errorMessage(err)}`, { cause: err });
+		throw new Error(`Client build produced no output at ${clientDir}: ${errorMessage$1(err)}`, { cause: err });
 	}
 	await Promise.all(entries.filter((entry) => entry.isFile()).map(async (entry) => {
 		const abs = path.join(entry.parentPath, entry.name);

package/dist/client-bundler.d.ts

@@ -0,0 +1,21 @@
+import { type PluginOption } from "vite";
+export type BuildClientOptions = {
+    /**
+     * Plugins to inject instead of relying on the project's `vite.config.ts`
+     * (React + Tailwind for the studio, whose workspace has neither).
+     */
+    plugins?: PluginOption[];
+    /**
+     * `false` ignores any `vite.config.ts` under `cwd`. The studio passes this:
+     * a Vite config is executable code, and workspace files are untrusted.
+     */
+    configFile?: false;
+    /** Build output directory, relative to `cwd`. */
+    outDir?: string;
+};
+/**
+ * Build the client SPA with Vite if `client.tsx` exists.
+ * Returns a map of relative file paths to string contents for deploy,
+ * or `{}` when the project has no `client.tsx`.
+ */
+export declare function buildClient(cwd: string, opts?: BuildClientOptions): Promise<Record<string, string>>;

package/dist/client-bundler.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { t as buildClient } from "./client-bundler-DO3GgO6p.mjs";
+import { t as buildClient } from "./client-bundler-BWDkUeEP.mjs";
 export { buildClient };