@alexkroman1/aai-cli 5.1.1 → 5.2.0

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.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

@@ -105,7 +105,7 @@ const init = defineCommand({
 	},
 	async run({ args }) {
 		await runCommand(args, async (mode) => {
-			const { executeInit } = await import("./init-tc3Rbgrf.mjs");
+			const { executeInit } = await import("./init-BjeK8crW.mjs");
 			return executeInit({
 				dir: args.dir,
 				force: args.force,

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/delete.d.ts

@@ -0,0 +1,18 @@
+import { type CommandResult } from "./_output.ts";
+export type DeleteOpts = {
+    url: string;
+    slug: string;
+    apiKey: string;
+    /** Optional fetch implementation for testing. Defaults to globalThis.fetch. */
+    fetch?: typeof globalThis.fetch;
+};
+export declare function runDelete(opts: DeleteOpts): Promise<void>;
+type DeleteData = {
+    slug: string;
+};
+/** Execute delete and return structured result. */
+export declare function executeDelete(opts: {
+    cwd: string;
+    server?: string | undefined;
+}): Promise<CommandResult<DeleteData>>;
+export {};

package/dist/deploy.d.ts

@@ -0,0 +1,15 @@
+import { type CommandResult } from "./_output.ts";
+type DeployData = {
+    slug: string;
+    url: string;
+    warnings?: string[];
+};
+export declare function executeDeploy(opts: {
+    cwd: string;
+    server?: string | undefined;
+    /** See DeployOpts.allowMissingSecrets (`--allow-missing-secrets`). */
+    allowMissingSecrets?: boolean | undefined;
+    /** `--skipTypecheck`: deploy without the tsc gate. */
+    skipTypecheck?: boolean | undefined;
+}): Promise<CommandResult<DeployData>>;
+export {};

package/dist/dev.d.ts

@@ -0,0 +1,13 @@
+import { type CommandResult } from "./_output.ts";
+type DevData = {
+    url: string;
+};
+/**
+ * Start the dev server and return the result.
+ * The process stays alive after this returns — caller handles signals.
+ */
+export declare function executeDev(opts: {
+    cwd: string;
+    port: string;
+}): Promise<CommandResult<DevData>>;
+export {};

package/dist/{init-tc3Rbgrf.mjs → init-BjeK8crW.mjs}

@@ -92,7 +92,7 @@ async function tryDeploy(cwd, server) {
 }
 /** Scaffold the project, optionally showing a spinner. */
 async function scaffoldProject(dir, cwd, template, silent) {
-	const { runInit } = await import("./_init-B-LEVTHx.mjs");
+	const { runInit } = await import("./_init-DU-sXH6S.mjs");
 	const s = silent ? void 0 : p.spinner();
 	s?.start(`Creating ${dir}`);
 	await runInit({

package/dist/init.d.ts

@@ -0,0 +1,24 @@
+import { type CommandResult } from "./_output.ts";
+type InitData = {
+    dir: string;
+    template: string;
+    deployed: boolean;
+    slug?: string;
+    url?: string;
+};
+/** Build the command + args for running pnpm, routing through safe-chain when available. */
+export declare function resolvePnpmCommand(checkSafeChain?: () => Promise<boolean>): Promise<{
+    cmd: string;
+    args: string[];
+}>;
+export declare function executeInit(opts: {
+    dir?: string | undefined;
+    force?: boolean | undefined;
+    template?: string | undefined;
+    yes?: boolean | undefined;
+    skipDeploy?: boolean | undefined;
+    server?: string | undefined;
+}, extra?: {
+    silent?: boolean | undefined;
+}): Promise<CommandResult<InitData>>;
+export {};

package/dist/scaffold/.env.example

@@ -0,0 +1,11 @@
+# Secrets for local development — loaded automatically by `aai dev`.
+# Only variables listed here are available via ctx.env (not all of process.env).
+#
+# For production, use `aai secret put <NAME>` to set the same keys on the server.
+# In both cases, access secrets in agent code via ctx.env.MY_KEY.
+#
+# Add any secrets your agent needs below:
+
+# Required only if your agent enables the `web_search` builtin
+# (free key: https://brave.com/search/api/):
+# BRAVE_API_KEY=