@alexkroman1/aai-cli 5.14.0 → 6.1.0

package/dist/{_templates-B1kt3BGt.mjs → _templates-iDGjGiPf.mjs}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { a as errorMessage } from "./_utils-0DHbcqUb.mjs";
-import { t as getMonorepoRoot } from "./_agent-C8Jk-ZcP.mjs";
+import { o as errorMessage$1 } from "./_utils-B8QmtFhK.mjs";
+import { t as getMonorepoRoot } from "./_agent-vGW5SBnX.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
+import { isRecord } from "@alexkroman1/aai/utils";
 import fs from "node:fs/promises";
 const REPO_URL = `https://github.com/alexkroman/agent`;
 /**
@@ -42,7 +43,7 @@ async function listTemplates(root = resolveTemplatesDir()) {
 	try {
 		available = await fs.readdir(templatesDir, { withFileTypes: true });
 	} catch (err) {
-		throw new Error(`Templates directory is missing or unreadable at ${templatesDir} (incomplete @alexkroman1/aai-cli install?): ${errorMessage(err)}`, { cause: err });
+		throw new Error(`Templates directory is missing or unreadable at ${templatesDir} (incomplete @alexkroman1/aai-cli install?): ${errorMessage$1(err)}`, { cause: err });
 	}
 	return available.filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
@@ -52,9 +53,6 @@ const MERGED_MANIFEST_FIELDS = [
 	"devDependencies",
 	"scripts"
 ];
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 /**
 * Fill a manifest's gaps from the scaffold's, `existing` always winning.
 *

package/dist/{_typecheck-gate-4v9UBZHh.mjs → _typecheck-gate-BXvUNnfs.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as CliError } from "./_output-CC300DzW.mjs";
+import { t as CliError } from "./_output-CKkmWs7i.mjs";
 import { n as log } from "./_ui-u7T4YooX.mjs";
 import { typecheckProject } from "./typecheck.mjs";
 //#region _typecheck-gate.ts

package/dist/{_utils-0DHbcqUb.mjs → _utils-B8QmtFhK.mjs}

@@ -1,8 +1,8 @@
 #!/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, omitUndefined } from "@alexkroman1/aai/utils";
+import fs from "node:fs/promises";
 //#region _utils.ts
 /**
 * The file that marks a directory as an agent project — the single source
@@ -26,15 +26,29 @@ 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.
+* Read and parse a package.json SYNCHRONOUSLY.
+*
+* Separate from {@link binFromPackageJson} so a caller that needs two fields
+* pays for one read and one parse. `resolveTsc` needed exactly that: it read
+* the TypeScript manifest for the bin and then again for the version, on a
+* path that runs after every settled write burst in the studio.
+*/
+function readPackageJson(pkgJsonPath) {
+	return JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+}
+/**
+* Absolute path of `binName`'s script declared by `manifest`, which was read
+* from `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];
+function binFromManifest(pkgJsonPath, manifest, binName) {
+	const bin = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[binName];
 	return bin ? path.join(path.dirname(pkgJsonPath), bin) : void 0;
 }
+/** {@link binFromManifest} for a caller that needs nothing else from the file. */
+function binFromPackageJson(pkgJsonPath, binName) {
+	return binFromManifest(pkgJsonPath, readPackageJson(pkgJsonPath), binName);
+}
 async function fileExists(p) {
 	try {
 		await fs.access(p);
@@ -102,4 +116,4 @@ async function writeJson(filePath, data, opts = {}) {
 	}
 }
 //#endregion
-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 };
+export { errorDetail as a, isEexist as c, resolveCwd as d, validateAgentExport as f, errorCode as i, readJson as l, binFromManifest as n, errorMessage$1 as o, writeJson as p, binFromPackageJson as r, fileExists as s, AGENT_ENTRY as t, readPackageJson as u };

package/dist/_utils.d.ts

@@ -12,11 +12,27 @@ export declare function errorCode(err: unknown): string | undefined;
 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;
+/** The fields of an installed package's manifest that this CLI reads. */
+export type PackageManifest = {
+    bin?: string | Record<string, string>;
+    version?: string;
+};
 /**
- * Absolute path of `binName`'s script declared by the package.json at
- * `pkgJsonPath`, or undefined when the package declares no such bin.
+ * Read and parse a package.json SYNCHRONOUSLY.
+ *
+ * Separate from {@link binFromPackageJson} so a caller that needs two fields
+ * pays for one read and one parse. `resolveTsc` needed exactly that: it read
+ * the TypeScript manifest for the bin and then again for the version, on a
+ * path that runs after every settled write burst in the studio.
+ */
+export declare function readPackageJson(pkgJsonPath: string): PackageManifest;
+/**
+ * Absolute path of `binName`'s script declared by `manifest`, which was read
+ * from `pkgJsonPath` — or undefined when the package declares no such bin.
  * Handles both `"bin": "script.js"` and `"bin": { name: "script.js" }`.
  */
+export declare function binFromManifest(pkgJsonPath: string, manifest: PackageManifest, binName: string): string | undefined;
+/** {@link binFromManifest} for a caller that needs nothing else from the file. */
 export declare function binFromPackageJson(pkgJsonPath: string, binName: string): string | undefined;
 export declare function fileExists(p: string): Promise<boolean>;
 /**

package/dist/{_vite-env-Dg_QlVv0.mjs → _vite-env-BNveawd1.mjs}

@@ -1,6 +1,36 @@
 #!/usr/bin/env node
 //#region _vite-env.ts
 /**
+* Packages resolved from the project root rather than from whichever
+* `node_modules` happens to sit above the importing file.
+*
+* `@alexkroman1/aai-ui` declares React as a **peer** dependency — "my consumer
+* supplies it" — but a bundler resolves the bare `react/jsx-runtime` import
+* inside `aai-ui/dist/**` from that file's own real path, not from the
+* consumer's. Deduping states the peer contract in terms the bundler enforces.
+*
+* Both Vite entry points need it, for failures that look nothing alike:
+*
+* - `buildClient` (`client-bundler.ts`): the studio's build root is nowhere
+*   above `packages/aai-ui/dist`, and the production image installs prod deps
+*   only, so aai-ui's own devDependency copy of React is pruned there. Publish
+*   died with *"Rolldown failed to resolve import react/jsx-runtime"* while
+*   every local build passed.
+* - `viteDevConfig` (`_dev-server.ts`): a project whose SDK is LINKED rather
+*   than installed — `aai init` run inside this monorepo, which is how a
+*   template gets tested by hand — resolves aai-ui's React through the
+*   workspace's own store, so the page loads two physically distinct copies of
+*   the same version. Two Reacts break hooks: `useSession`/`useWorkflowRun`
+*   throw *"Invalid hook call"*, `<ThemeProvider>` unmounts, and the agent
+*   renders a BLANK PAGE whose console never names a package.
+*
+* An npm-installed project is unaffected either way, which is precisely why
+* this stayed invisible: the resolution is correct until the SDK is linked or
+* the tree is pruned. Guarded by `client-bundler.test.ts` (asserted against
+* aai-ui's own manifest, so a peer added there without being added here fails).
+*/
+const DEDUPED_PEERS = ["react", "react-dom"];
+/**
 * Run a Vite build without letting it mutate the calling process's env.
 *
 * Vite's `build()` sets `process.env.NODE_ENV = "production"` when NODE_ENV is
@@ -44,4 +74,4 @@ async function withPreservedNodeEnv(fn, env = process.env) {
 	}
 }
 //#endregion
-export { withPreservedNodeEnv as t };
+export { withPreservedNodeEnv as n, DEDUPED_PEERS as t };

package/dist/_vite-env.d.ts

@@ -1,3 +1,33 @@
+/**
+ * Packages resolved from the project root rather than from whichever
+ * `node_modules` happens to sit above the importing file.
+ *
+ * `@alexkroman1/aai-ui` declares React as a **peer** dependency — "my consumer
+ * supplies it" — but a bundler resolves the bare `react/jsx-runtime` import
+ * inside `aai-ui/dist/**` from that file's own real path, not from the
+ * consumer's. Deduping states the peer contract in terms the bundler enforces.
+ *
+ * Both Vite entry points need it, for failures that look nothing alike:
+ *
+ * - `buildClient` (`client-bundler.ts`): the studio's build root is nowhere
+ *   above `packages/aai-ui/dist`, and the production image installs prod deps
+ *   only, so aai-ui's own devDependency copy of React is pruned there. Publish
+ *   died with *"Rolldown failed to resolve import react/jsx-runtime"* while
+ *   every local build passed.
+ * - `viteDevConfig` (`_dev-server.ts`): a project whose SDK is LINKED rather
+ *   than installed — `aai init` run inside this monorepo, which is how a
+ *   template gets tested by hand — resolves aai-ui's React through the
+ *   workspace's own store, so the page loads two physically distinct copies of
+ *   the same version. Two Reacts break hooks: `useSession`/`useWorkflowRun`
+ *   throw *"Invalid hook call"*, `<ThemeProvider>` unmounts, and the agent
+ *   renders a BLANK PAGE whose console never names a package.
+ *
+ * An npm-installed project is unaffected either way, which is precisely why
+ * this stayed invisible: the resolution is correct until the SDK is linked or
+ * the tree is pruned. Guarded by `client-bundler.test.ts` (asserted against
+ * aai-ui's own manifest, so a peer added there without being added here fails).
+ */
+export declare const DEDUPED_PEERS: string[];
 /**
  * `env` is injectable for tests ONLY, so specs can exercise the
  * snapshot/refcount logic on a plain object instead of mutating (and

package/dist/build-BO1Ni6oJ.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { a as ok, t as CliError } from "./_output-CKkmWs7i.mjs";
+import { n as log } from "./_ui-u7T4YooX.mjs";
+import { r as evalWorkerBundle, t as buildAgentBundle } from "./_bundler-BapCUUJN.mjs";
+import { assertTypechecks } from "./_typecheck-gate-BXvUNnfs.mjs";
+import { classifyVitestError, runVitest } from "./test-B6ZBxSpk.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#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.
+*
+* It also LEAVES that artifact on disk, at {@link WORKER_ARTIFACT_REL}, which is
+* what makes self-hosting work: `server.mjs` loads the built worker rather than
+* `agent.ts`, because a tool is discovered by the bundler enumerating `tools/`
+* and no un-bundled loader can see that directory. See the scaffold's own
+* `server.mjs` and "Self-hosting runs the built worker" in
+* `packages/aai-templates/CLAUDE.md`.
+*/
+/**
+* Where the built worker lands, relative to the project root — under `.aai/`,
+* beside the built client, so one gitignore rule covers every build output.
+*
+* `server.mjs` hardcodes this path: it is a plain `.mjs` file in a user's
+* project and may not import from the CLI (which a deployed project does not
+* install at all). The pair is covered end-to-end by the `npm start` leg of
+* `e2e.test.ts` — the only tier that runs both halves as a user does.
+*/
+const WORKER_ARTIFACT_REL = path.join(".aai", "worker.mjs");
+/**
+* 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);
+	const worker = path.join(cwd, WORKER_ARTIFACT_REL);
+	await fs.mkdir(path.dirname(worker), { recursive: true });
+	await fs.writeFile(worker, bundle.worker, "utf-8");
+	log.success("Build complete");
+	return ok({
+		name: agentDef.name,
+		workerBytes: bundle.worker.length,
+		worker
+	});
+}
+//#endregion
+export { executeBuild };

package/dist/build.d.ts

@@ -2,11 +2,30 @@
  * `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.
+ *
+ * It also LEAVES that artifact on disk, at {@link WORKER_ARTIFACT_REL}, which is
+ * what makes self-hosting work: `server.mjs` loads the built worker rather than
+ * `agent.ts`, because a tool is discovered by the bundler enumerating `tools/`
+ * and no un-bundled loader can see that directory. See the scaffold's own
+ * `server.mjs` and "Self-hosting runs the built worker" in
+ * `packages/aai-templates/CLAUDE.md`.
  */
 import { type CommandResult } from "./_output.ts";
+/**
+ * Where the built worker lands, relative to the project root — under `.aai/`,
+ * beside the built client, so one gitignore rule covers every build output.
+ *
+ * `server.mjs` hardcodes this path: it is a plain `.mjs` file in a user's
+ * project and may not import from the CLI (which a deployed project does not
+ * install at all). The pair is covered end-to-end by the `npm start` leg of
+ * `e2e.test.ts` — the only tier that runs both halves as a user does.
+ */
+export declare const WORKER_ARTIFACT_REL: string;
 type BuildData = {
     name: string;
     workerBytes: number;
+    /** Absolute path of the worker written — what `npm start` boots. */
+    worker: string;
 };
 export declare function executeBuild(opts: {
     cwd: string;

package/dist/cli-workflow.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `aai workflow` subcommand group.
+ *
+ * Its own module because `cli.ts` is near the 500-line cap and this is the
+ * natural seam: four verbs over one surface, none of which shares anything with
+ * the deploy/secret/storage commands beyond `sharedArgs`. The executors are in
+ * `workflow.ts` and are imported lazily, exactly as every other command here
+ * does it — the CLI's startup path must not pay for a group nobody invoked.
+ */
+export declare const workflow: import("citty").CommandDef<import("citty").ArgsDef>;

package/dist/cli.d.ts

@@ -1,2 +1 @@
-import { type ArgsDef, type CommandDef } from "citty";
-export declare const mainCommand: CommandDef<ArgsDef>;
+export declare const mainCommand: import("citty").CommandDef<import("citty").ArgsDef>;