@alexkroman1/aai-cli 5.10.1 → 5.12.0

package/dist/scaffold/CLAUDE.md

@@ -54,6 +54,29 @@ The scaffold's `package.json` exposes `dev`, `build`, `test`, and `deploy`
 as `pnpm <name>` shortcuts. Other commands (`init`, `templates`, `delete`, `secret`)
 are CLI-only.
 
+## Running it yourself (`npm start`)
+
+`server.mjs` serves this agent from a plain Node process — no CLI, no
+bundler, no platform account. It is the deployment counterpart of `aai dev`:
+
+```sh
+npm start                          # http://127.0.0.1:3000
+PORT=8080 HOST=0.0.0.0 npm start   # bind every interface, e.g. in a container
+```
+
+Secrets work the same as everywhere else: `ctx.env` holds the keys declared
+in `.env` (or `.env.example`), and a real environment variable of that name
+wins — so `docker run -e MY_API_KEY=…` needs no `.env` in the image.
+
+Two things to know. It binds **loopback by default**, because this server has
+no request authentication of its own; set `HOST=0.0.0.0` only behind your own
+proxy or auth. And with a custom `client.tsx`, run `npm run build` first —
+otherwise it serves the default UI and says so at startup.
+
+Deleting `server.mjs` costs nothing: `aai dev`, `aai publish` and the managed
+platform never read it. `run_code` is the one feature that does not follow —
+it needs the platform's sandbox and refuses outside one.
+
 ## Project structure
 
 ```text

package/dist/scaffold/package.json

@@ -6,20 +6,21 @@
   },
   "scripts": {
     "dev": "aai dev",
+    "start": "node server.mjs",
     "build": "aai build",
     "test": "aai test",
     "publish:agent": "aai publish"
   },
   "dependencies": {
-    "@alexkroman1/aai": "^5.10.1",
-    "@alexkroman1/aai-ui": "^5.10.1",
+    "@alexkroman1/aai": "^5.12.0",
+    "@alexkroman1/aai-ui": "^5.12.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "tailwindcss": "^4.0.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@alexkroman1/aai-cli": "^5.10.1",
+    "@alexkroman1/aai-cli": "^5.12.0",
     "@tailwindcss/vite": "^4.3.3",
     "@types/node": "^26.1.1",
     "@types/react": "^19.2.17",

package/dist/scaffold/server.mjs

@@ -0,0 +1,156 @@
+// Self-hosted entrypoint — this is what `npm start` runs.
+//
+// It serves the agent over HTTP + WebSocket from your own Node process: no
+// platform account, no CLI at run time, no bundler. `aai dev` is the
+// development counterpart (file watching, Vite, a browser that opens itself);
+// this file is the deployment.
+//
+//   npm start                          # http://127.0.0.1:3000
+//   PORT=8080 HOST=0.0.0.0 npm start   # bind every interface, e.g. in a container
+//
+// Anything that can run Node can host it: copy the project, install
+// dependencies, provide the secrets, run this file. Deleting it costs nothing
+// — `aai dev`, `aai publish` and the managed platform never read it.
+
+import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { registerHooks } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseEnv } from "node:util";
+import { createAgentServer, withHostCredentialFallback } from "@alexkroman1/aai/runtime";
+import { defaultClientDir } from "@alexkroman1/aai-ui/client-dir";
+
+const root = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Teach Node the two non-JavaScript import shapes the `aai` bundler supports,
+ * so one `agent.ts` runs unchanged under `aai dev`, `aai publish`, and here.
+ *
+ * - `import prompt from "./system-prompt.md?raw"` — a Vite convention; Node
+ *   would look for a file literally named `system-prompt.md?raw`.
+ * - `import data from "./data.json"` with no import attribute — TypeScript's
+ *   `resolveJsonModule` allows it; Node requires `with { type: "json" }` and
+ *   otherwise fails with ERR_IMPORT_ATTRIBUTE_MISSING. An import that DOES
+ *   carry the attribute is left to Node, whose own handling is correct.
+ *
+ * Nothing is transformed beyond that: `.ts` itself needs no help, because Node
+ * strips the types natively (this project needs Node 24+). That is why there
+ * is no build step here, and no second copy of the agent in JavaScript that
+ * could drift from the one you deploy.
+ */
+registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (specifier.startsWith(".") && specifier.endsWith("?raw")) {
+      // Resolved by hand rather than through nextResolve: the default
+      // resolver has no format for `.md` and the query would be lost anyway.
+      return {
+        url: new URL(specifier, context.parentURL).href,
+        format: "module",
+        shortCircuit: true,
+      };
+    }
+    return nextResolve(specifier, context);
+  },
+  load(url, context, nextLoad) {
+    const asRaw = url.endsWith("?raw");
+    const asBareJson = url.endsWith(".json") && context.importAttributes?.type !== "json";
+    if (!(asRaw || asBareJson)) return nextLoad(url, context);
+    const text = readFileSync(fileURLToPath(asRaw ? url.slice(0, -"?raw".length) : url), "utf-8");
+    return {
+      format: "module",
+      // `export default <literal>` for both: a JSON document is already a
+      // valid JS expression, and JSON.stringify makes any file safe to embed
+      // as a string. Emitting `format: "json"` instead would put the import
+      // back under the attribute check this exists to satisfy.
+      source: `export default ${asRaw ? JSON.stringify(text) : text};`,
+      shortCircuit: true,
+    };
+  },
+});
+
+// Imported dynamically, and this is load-bearing: static `import` statements
+// are hoisted and evaluated BEFORE any statement in this file, so an
+// `import agent from "./agent.ts"` at the top would load the agent — and every
+// `?raw` import inside it — before the hooks above were ever registered.
+const { default: agent } = await import("./agent.ts");
+
+/** Parse a dotenv-syntax file into a record; `{}` when it does not exist. */
+async function readEnvFile(file) {
+  try {
+    return parseEnv(await readFile(path.join(root, file), "utf-8"));
+  } catch (err) {
+    // Absent is normal — `.env` is gitignored, and a container usually has
+    // neither file. Unreadable is not: the agent would boot with no
+    // credentials and fail later as an opaque provider auth error.
+    if (err.code !== "ENOENT") throw err;
+    return {};
+  }
+}
+
+/**
+ * Build `ctx.env` — what this agent's own tool code reads.
+ *
+ * The rule is the one `aai dev` follows: only DECLARED keys are exposed, and a
+ * real environment variable wins over the file's value. Nothing else from
+ * process.env comes along, so the agent cannot come to depend on a variable
+ * (PATH, HOME, …) that will not exist wherever you deploy it.
+ *
+ * `.env.example` counts as a declaration too, which is what lets a container
+ * run with no `.env` at all: the committed file names the secrets the agent
+ * needs, and `docker run -e MY_API_KEY=…` supplies the values. Declare
+ * `DATABASE_URL` the same way to give your tools `ctx.db`.
+ */
+async function resolveAgentEnv() {
+  const declared = { ...(await readEnvFile(".env.example")), ...(await readEnvFile(".env")) };
+  const env = {};
+  for (const [key, fileValue] of Object.entries(declared)) {
+    const value = process.env[key] ?? fileValue;
+    // An empty value is worse than a missing one: a provider would try to
+    // authenticate with "" rather than report the credential as absent. The
+    // example file is full of them by design (`BRAVE_API_KEY=`).
+    if (value !== "") env[key] = value;
+  }
+  return env;
+}
+
+/**
+ * Static assets served at `/`: this project's own UI once `client.tsx` has been
+ * built (`npm run build` leaves it in `.aai/client`), otherwise the prebuilt
+ * default client that ships inside @alexkroman1/aai-ui.
+ */
+function resolveClientDir() {
+  const built = path.join(root, ".aai", "client");
+  if (existsSync(path.join(built, "index.html"))) return built;
+  if (existsSync(path.join(root, "client.tsx"))) {
+    console.warn("client.tsx is not built — serving the default UI. Run `npm run build` first.");
+  }
+  return defaultClientDir();
+}
+
+const env = await resolveAgentEnv();
+
+const server = createAgentServer({
+  agent,
+  env,
+  // Provider credentials may ALSO arrive straight from the environment without
+  // being declared, and without becoming ctx.env — the ordinary way to hand
+  // ASSEMBLYAI_API_KEY to a container. Anything in `env` still wins.
+  providerEnv: withHostCredentialFallback(env),
+  clientDir: resolveClientDir(),
+});
+
+// Loopback by default: this server has no request authentication of its own,
+// so exposing it is a deliberate act. Set HOST=0.0.0.0 to bind every interface
+// behind your own proxy or auth. An empty HOST means unset, not "everything".
+const host = process.env.HOST?.trim() || undefined;
+await server.listen(Number(process.env.PORT ?? 3000), host);
+console.log(`${agent.name} listening on http://${host ?? "127.0.0.1"}:${server.port}`);
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.once(signal, async () => {
+    // close() shuts the runtime down too — no separate runtime.shutdown().
+    await server.close();
+    process.exit(0);
+  });
+}

package/dist/{secret-4_dYyrpA.mjs → secret-LnFdg8SB.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { a as ok, n as fail } from "./_output-CC300DzW.mjs";
-import { n as log, o as unwrapCancel } from "./_ui-DfwfDbT-.mjs";
-import { t as slugRequest } from "./_slug-api-fRNNR8tz.mjs";
+import { n as log, s as unwrapCancel } from "./_ui-u7T4YooX.mjs";
+import { t as secretRequest } from "./_slug-api-DXm7s9X5.mjs";
 import * as p from "@clack/prompts";
 import { text } from "node:stream/consumers";
 //#region secret.ts
@@ -29,24 +29,24 @@ async function executeSecretPut(cwd, name, value, server) {
 		if (!result) return fail(...NO_INPUT);
 		secretValue = result;
 	}
-	const { slug } = await slugRequest(cwd, "/secret", {
+	const { target } = await secretRequest(cwd, "", {
 		method: "PUT",
 		body: { [name]: secretValue },
 		action: "secret"
 	}, server);
-	log.success(`Set ${name} for ${slug}`);
+	log.success(`Set ${name} for ${target}`);
 	return ok({ name });
 }
 async function executeSecretDelete(cwd, name, server) {
-	const { slug } = await slugRequest(cwd, `/secret/${encodeURIComponent(name)}`, {
+	const { target } = await secretRequest(cwd, `/${encodeURIComponent(name)}`, {
 		method: "DELETE",
 		action: "secret"
 	}, server);
-	log.success(`Deleted ${name} from ${slug}`);
+	log.success(`Deleted ${name} from ${target}`);
 	return ok({ name });
 }
 async function executeSecretList(cwd, server) {
-	const { data: { vars } } = await slugRequest(cwd, "/secret", { action: "secret" }, server);
+	const { data: { vars } } = await secretRequest(cwd, "", { action: "secret" }, server);
 	if (vars.length === 0) log.info("No secrets set. Use `aai secret put <name>` to add one.");
 	else {
 		log.message(`${vars.length} secret${vars.length === 1 ? "" : "s"}:`);

package/dist/{storage-BTfErOOW.mjs → storage-Cjj3Pv6i.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { a as ok, n as fail } from "./_output-CC300DzW.mjs";
-import { n as log } from "./_ui-DfwfDbT-.mjs";
-import { t as slugRequest } from "./_slug-api-fRNNR8tz.mjs";
+import { n as log } from "./_ui-u7T4YooX.mjs";
+import { n as slugRequest } from "./_slug-api-DXm7s9X5.mjs";
 import * as p from "@clack/prompts";
 //#region storage.ts
 async function storageRequest(cwd, init, server) {

package/dist/{studio-LNvXtWak.mjs → studio-Rl5Po2M6.mjs}

@@ -1,170 +1,14 @@
 #!/usr/bin/env node
 import { a as ok, t as CliError } from "./_output-CC300DzW.mjs";
-import { n as log, t as fmtUrl } from "./_ui-DfwfDbT-.mjs";
-import { s as updateProjectConfig } from "./_config-DMyolIk9.mjs";
+import { n as log, t as fmtUrl } from "./_ui-u7T4YooX.mjs";
+import { s as updateProjectConfig } from "./_config-riTmrwxX.mjs";
 import { t as resolveServerEnv } from "./_server-common-DX8Bfrf5.mjs";
-import { i as resolveDeployTarget } from "./_agent-DS2PUJcl.mjs";
-import { layerScaffold } from "./_templates-BWJOiWOO.mjs";
+import { i as resolveDeployTarget } from "./_agent-JGaAJ5j6.mjs";
+import { layerScaffold } from "./_templates-CKYDgGyY.mjs";
 import { n as apiRequest } from "./_api-client-B-upMGkc.mjs";
+import { a as publishStudioProject, i as projectNameFromDir, n as fetchStudioProject, o as pushStudioSource, r as listStudioProjects, s as studioProjectUrl, t as collectSourceFiles } from "./_studio-CXoY_Hsg.mjs";
 import path from "node:path";
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { PREVIEW_SLUG_SUFFIX, VALID_SLUG_RE } from "@alexkroman1/aai/utils";
-//#region _studio.ts
-/**
-* Internals of the studio-workspace commands (`aai list/pull/push/publish`):
-* the local source-file walk and the thin clients for the platform's
-* `/studio/projects` routes. The workspace is the single source of truth —
-* these helpers only move files between a local directory and the project's
-* workspace row; production deploys happen exclusively through the studio's
-* Publish route (which runs the deploy machinery in the project's sandbox).
-*/
-/**
-* Mirrors of the studio workspace caps (`aai-studio-server/studio-limits.ts`)
-* — by value, like `aai-guest/limits.ts`, since the CLI cannot depend on the
-* private server package. The server re-validates every push; these exist so
-* an oversized file is a named warning locally instead of a rejected upload.
-*/
-const MAX_STUDIO_FILE_BYTES = 256e3;
-/**
-* What never syncs to a workspace — the same set the guest's snapshot skips
-* (`aai-guest/studio-workspace-fs.ts`), plus what only exists locally:
-* secrets (`.env` rides the secret routes, never a workspace row) and
-* lockfiles (regenerated by install, noise in the studio editor).
-*/
-const IGNORED_DIRS = /* @__PURE__ */ new Set([
-	"node_modules",
-	".git",
-	"dist",
-	".aai"
-]);
-const IGNORED_FILES = [
-	/^\.env(\..+)?$/,
-	/^pnpm-lock\.yaml$/,
-	/^package-lock\.json$/,
-	/^yarn\.lock$/,
-	/^\.DS_Store$/
-];
-function isIgnoredFile(name) {
-	return IGNORED_FILES.some((re) => re.test(name));
-}
-/** Project-relative paths of every syncable file under `dir`, sorted. */
-async function walkProject(dir, current = dir) {
-	const out = [];
-	const entries = await readdir(current, { withFileTypes: true });
-	for (const entry of entries) {
-		if (entry.isSymbolicLink()) continue;
-		const abs = path.join(current, entry.name);
-		if (entry.isDirectory()) {
-			if (!IGNORED_DIRS.has(entry.name)) out.push(...await walkProject(dir, abs));
-		} else if (entry.isFile() && !isIgnoredFile(entry.name)) out.push(path.relative(dir, abs));
-	}
-	return out.sort((a, b) => a.localeCompare(b));
-}
-/**
-* Decode `buf` as UTF-8, or null when it isn't valid UTF-8.
-*
-* `fatal` makes an invalid sequence throw instead of becoming U+FFFD, which
-* is the whole point: a workspace is a JSON path→string map and cannot carry
-* arbitrary bytes, so a lossy read turned a pushed PNG into replacement
-* characters while reporting success — and a later `aai pull` wrote the
-* mangled version back over the local original. `ignoreBOM` keeps a leading
-* U+FEFF in the string; without it the decoder strips the BOM and the check
-* meant to stop corruption would quietly perform some of its own.
-*/
-const UTF8_STRICT = new TextDecoder("utf-8", {
-	fatal: true,
-	ignoreBOM: true
-});
-function decodeUtf8(buf) {
-	try {
-		return UTF8_STRICT.decode(buf);
-	} catch {
-		return null;
-	}
-}
-/**
-* Walk a local project into the path→content record a workspace stores —
-* the CLI-side twin of the guest's `snapshotWorkspace`: same ignored
-* directories, same caps, oversized and non-text files skipped with a
-* warning rather than failing the whole push.
-*/
-async function collectSourceFiles(dir) {
-	const paths = await walkProject(dir);
-	const files = {};
-	const warnings = [];
-	if (paths.length > 100) warnings.push(`Project has ${paths.length} files; only the first 100 sync to the studio.`);
-	for (const rel of paths.slice(0, 100)) {
-		const abs = path.join(dir, rel);
-		const st = await stat(abs);
-		if (st.size > 256e3) {
-			warnings.push(`${rel} is ${st.size} bytes (max ${MAX_STUDIO_FILE_BYTES}) — not synced.`);
-			continue;
-		}
-		const content = decodeUtf8(await readFile(abs));
-		if (content === null) {
-			warnings.push(`${rel} is not valid UTF-8 (binary file?) — not synced.`);
-			continue;
-		}
-		files[rel.split(path.sep).join("/")] = content;
-	}
-	return {
-		files,
-		warnings
-	};
-}
-/**
-* A studio project name derived from a directory name, or null if unusable.
-*
-* A `-preview` suffix is deliberately unusable. Publishing a project deploys
-* it under the project's own name, so a `*-preview` project would claim a
-* slug the studio's orphan-preview sweep reaps hourly — deleting the agent,
-* its app-database schema, and its secrets on a schedule the user never
-* asked for. Refusing the name is recoverable (rename the directory); losing
-* a published agent to the reaper is not.
-*/
-function projectNameFromDir(dir) {
-	const name = path.basename(dir).toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/-{2,}/g, "-").replace(/^[-_]+|[-_]+$/g, "").slice(0, 64);
-	if (name.endsWith(PREVIEW_SLUG_SUFFIX)) return null;
-	return VALID_SLUG_RE.test(name) ? name : null;
-}
-/** The shareable studio URL for a project — what every command prints. */
-function studioProjectUrl(serverUrl, project) {
-	return `${serverUrl}/studio/chat/${project}`;
-}
-function listStudioProjects(serverUrl, apiKey) {
-	return apiRequest(`${serverUrl}/studio/projects`, {
-		apiKey,
-		action: "list"
-	}).then((res) => res.projects);
-}
-/** Fetch a project, or null when it doesn't exist (the push existence probe). */
-function fetchStudioProject(serverUrl, apiKey, project) {
-	return apiRequest(`${serverUrl}/studio/projects/${encodeURIComponent(project)}`, {
-		apiKey,
-		action: "pull",
-		allow404: true
-	});
-}
-/** `PUT /studio/projects/:project/source` — the atomic whole-tree push. */
-function pushStudioSource(serverUrl, apiKey, project, body) {
-	return apiRequest(`${serverUrl}/studio/projects/${encodeURIComponent(project)}/source`, {
-		apiKey,
-		action: "push",
-		method: "PUT",
-		body,
-		hints: { 409: "The studio has newer changes. Run `aai pull` to fetch them, or `aai push --force` to overwrite." }
-	});
-}
-/** `POST /studio/projects/:project/deploy` — Publish, in the project's sandbox. */
-function publishStudioProject(serverUrl, apiKey, project) {
-	return apiRequest(`${serverUrl}/studio/projects/${encodeURIComponent(project)}/deploy`, {
-		apiKey,
-		action: "publish",
-		method: "POST",
-		retry: 0
-	});
-}
-//#endregion
+import { mkdir, readdir, writeFile } from "node:fs/promises";
 //#region studio.ts
 /**
 * The studio-workspace commands: `aai list`, `aai pull`, `aai push`,
@@ -188,17 +32,40 @@ async function executeList(opts) {
 }
 /** Write a pulled file map under `dir`, refusing paths that escape it. */
 async function materializeFiles(dir, files) {
-	for (const [rel, content] of Object.entries(files)) {
+	const targets = Object.entries(files).map(([rel, content]) => {
 		const abs = path.resolve(dir, rel);
 		if (abs !== dir && !abs.startsWith(dir + path.sep)) throw new Error(`Pulled file path escapes the project directory: ${rel}`);
+		return {
+			abs,
+			content
+		};
+	});
+	await Promise.all(targets.map(async ({ abs, content }) => {
 		await mkdir(path.dirname(abs), { recursive: true });
 		await writeFile(abs, content, "utf-8");
-	}
+	}));
+}
+/**
+* The hint for a pull that found nothing, which is where the two causes have
+* to be told apart — and only the project LIST can do it. A typo has other
+* projects beside it; an empty list means this login sees no projects at all,
+* i.e. the CLI is authenticated as a different account than the browser the
+* project was created in (the account's key is what decides studio scope —
+* see `resolveBearer` server-side). Naming the visible projects is also the
+* answer to a typo, so the round trip pays for itself either way. Best
+* effort: the list is a second request on an already-failing path, and its
+* own failure must not replace the 404 the user needs to see.
+*/
+async function notFoundHint(serverUrl, apiKey) {
+	const projects = await listStudioProjects(serverUrl, apiKey).catch(() => null);
+	if (projects === null) return "Run `aai list` to see your projects.";
+	if (projects.length === 0) return "This login has no studio projects at all. If yours are in the studio, the CLI is linked to a different account — run `aai login` again, approve it in a browser signed in to the account that owns the project, then `aai list`.";
+	return `Your projects: ${projects.slice(0, 10).join(", ")}${projects.length > 10 ? `, and ${projects.length - 10} more` : ""}.`;
 }
 async function executePull(opts) {
 	const { serverUrl, apiKey } = await resolveDeployTarget(opts.cwd, opts.server);
 	const remote = await fetchStudioProject(serverUrl, apiKey, opts.project);
-	if (!remote) throw new CliError("not_found", `No studio project named "${opts.project}".`, "Run `aai list` to see your projects.");
+	if (!remote) throw new CliError("not_found", `No studio project named "${opts.project}".`, await notFoundHint(serverUrl, apiKey));
 	const target = path.resolve(opts.cwd, opts.dir ?? opts.project);
 	if ((await readdir(target).catch(() => [])).length > 0 && !opts.force) throw new CliError("dir_not_empty", `${target} is not empty.`, "Pull into a fresh directory, or pass --force to overwrite files in place.");
 	await materializeFiles(target, remote.files);
@@ -276,11 +143,11 @@ async function executePush(opts) {
 * deploy time, which is why publish syncs them BEFORE deploying when the
 * slug is already known.
 */
-async function syncEnvSecrets(cwd, serverUrl, apiKey, slug) {
+async function syncEnvSecrets(cwd, serverUrl, apiKey, project) {
 	const env = await resolveServerEnv(cwd);
 	const names = Object.keys(env);
 	if (names.length === 0) return [];
-	await apiRequest(`${serverUrl}/${slug}/secret`, {
+	await apiRequest(`${serverUrl}/studio/projects/${encodeURIComponent(project)}/secret`, {
 		apiKey,
 		action: "secret",
 		method: "PUT",
@@ -291,13 +158,13 @@ async function syncEnvSecrets(cwd, serverUrl, apiKey, slug) {
 }
 async function executePublish(opts) {
 	if (!opts.skipTypecheck) {
-		const { assertTypechecks } = await import("./_typecheck-gate-DB-PY0A3.mjs");
+		const { assertTypechecks } = await import("./_typecheck-gate-4v9UBZHh.mjs");
 		await assertTypechecks(opts.cwd);
 	}
 	const pushed = await pushProject(opts);
 	const { project, serverUrl, apiKey } = pushed;
 	const hadSlug = pushed.slug !== void 0;
-	if (pushed.slug) await syncEnvSecrets(opts.cwd, serverUrl, apiKey, pushed.slug);
+	if (pushed.slug) await syncEnvSecrets(opts.cwd, serverUrl, apiKey, project);
 	log.step(`Publishing ${project} (builds in the project's sandbox)…`);
 	const result = await publishStudioProject(serverUrl, apiKey, project);
 	if (typeof result?.slug !== "string" || typeof result?.output !== "string") throw new CliError("bad_publish_response", `Unexpected response from the publish route at ${serverUrl}.`, "Check that --server points at an aai platform server, then try again.");

package/dist/{test-C-V98oC-.mjs → test-BtOzTcXE.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { a as ok, n as fail } from "./_output-CC300DzW.mjs";
-import { n as log } from "./_ui-DfwfDbT-.mjs";
+import { n as log } from "./_ui-u7T4YooX.mjs";
 import { a as errorMessage, n as binFromPackageJson, r as errorCode } from "./_utils-8KKw-bzi.mjs";
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-cli",
-  "version": "5.10.1",
+  "version": "5.12.0",
   "type": "module",
   "bin": {
     "aai": "bin.mjs"
@@ -20,6 +20,11 @@
       "@dev/source": "./typecheck.ts",
       "types": "./dist/typecheck.d.ts",
       "import": "./dist/typecheck.mjs"
+    },
+    "./project-config": {
+      "@dev/source": "./project-config.ts",
+      "types": "./dist/project-config.d.ts",
+      "import": "./dist/project-config.mjs"
     }
   },
   "files": [
@@ -38,8 +43,8 @@
     "p-timeout": "^7.0.1",
     "vite": "^8.1.5",
     "zod": "^4.4.3",
-    "@alexkroman1/aai": "5.10.1",
-    "@alexkroman1/aai-ui": "5.10.1"
+    "@alexkroman1/aai": "5.12.0",
+    "@alexkroman1/aai-ui": "5.12.0"
   },
   "devDependencies": {
     "playwright": "^1.61.1",

package/dist/_slug-api-fRNNR8tz.mjs

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-import { n as getServerInfo } from "./_agent-DS2PUJcl.mjs";
-import { n as apiRequest, t as HINT_NOT_DEPLOYED } from "./_api-client-B-upMGkc.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 };