@alexkroman1/aai-cli 13.1.0 → 13.3.0

package/dist/test-guenJUxi.mjs

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import { a as ok, n as fail } from "./_output-DbJt9gsl.mjs";
+import { n as log, r as notify } from "./_ui-DCt4qZrk.mjs";
+import { i as errorCode, o as errorMessage$1, r as binFromPackageJson } from "./_utils-Dhd058D9.mjs";
+import { createRequire } from "node:module";
+import { existsSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { omitUndefined } from "@alexkroman1/aai/utils";
+import { execaSync } from "execa";
+//#region src/test.ts
+/**
+* `aai test` — run agent tests via vitest.
+*/
+/**
+* Resolve the agent project's own vitest binary so tests run without the
+* npx resolution overhead (and its potential network fetch of vitest).
+*
+* Resolves `vitest/package.json` from the agent directory, derives the bin
+* script, and runs it with the current Node executable. Falls back to
+* `npx vitest` only when no local install is resolvable.
+*/
+function resolveVitestCommand(cwd, resolve = createRequire(path.join(cwd, "package.json")).resolve) {
+	try {
+		const bin = binFromPackageJson(resolve("vitest/package.json"), "vitest");
+		if (bin) return {
+			cmd: process.execPath,
+			args: [bin]
+		};
+	} catch {}
+	return {
+		cmd: "npx",
+		args: ["vitest"]
+	};
+}
+/** The files `aai test` runs, in preference order. */
+const TEST_FILES = ["agent.test.ts", "agent.test.js"];
+/**
+* Run vitest over `candidates` (or, with `all`, the whole project) in the given
+* project directory.
+*
+* Returns the FILES it ran, or `false` if there was nothing to run. Throws on
+* failure.
+*
+* A vitest FILTER, not an include glob: each argument is matched as a substring
+* against the paths vitest's own include globs already found, which is why the
+* candidates are named `*.test.ts` — `agent.test.ts` cannot match
+* `agent.eval.test.ts` and vice versa, so the two commands stay disjoint
+* without either one having to exclude the other's file. That holds for the
+* `all` list too: it is built from {@link projectSpecFiles}, which drops the
+* eval tier by infix.
+*/
+function runVitest(cwd, opts = { candidates: TEST_FILES }) {
+	const files = resolveRunFiles(cwd, opts);
+	if (files.length === 0) return false;
+	const { cmd, args } = resolveVitestCommand(cwd);
+	execaSync(cmd, [
+		...args,
+		"run",
+		"--root",
+		".",
+		...opts.extraArgs ?? [],
+		...files
+	], {
+		cwd,
+		stdio: "inherit",
+		...omitUndefined({ env: opts.env ? {
+			...process.env,
+			...opts.env
+		} : void 0 })
+	});
+	if (opts.announceUnrun !== false) warnUnrunSpecs(cwd, files);
+	return files;
+}
+/** The spec files one {@link runVitest} call points vitest at. */
+function resolveRunFiles(cwd, opts) {
+	if (opts.all) return projectSpecFiles(cwd);
+	const candidate = opts.candidates.find((name) => existsSync(path.join(cwd, name)));
+	return candidate ? [candidate] : [];
+}
+/**
+* Classify a {@link runVitest} failure. execaSync throws an ENOENT-coded
+* error when the binary itself couldn't be spawned (infrastructure problem)
+* and an exit-code error when vitest ran and the tests failed.
+*/
+function classifyVitestError(err, label = "Tests") {
+	if (errorCode(err) === "ENOENT") return {
+		code: "spawn_failed",
+		message: `Could not launch the test runner: ${errorMessage$1(err)} — is the binary on your PATH?`
+	};
+	return {
+		code: "test_failed",
+		message: `${label} failed: ${errorMessage$1(err)}`
+	};
+}
+/** Directories a project's own specs never live in. */
+const UNSCANNED_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".aai",
+	".git",
+	"dist",
+	".workflow-data"
+]);
+/** What counts as a spec file. */
+const SPEC_FILE_RE = /\.test\.(ts|js|tsx|mts|cts)$/;
+/**
+* Every spec file in the project that belongs to the TEST tier.
+*
+* Eval files are excluded by the `.eval.` INFIX — the tier convention — rather
+* than by a filename list, which is what keeps this module from importing
+* `eval.ts`, which imports this one.
+*/
+function projectSpecFiles(cwd) {
+	const found = [];
+	collectSpecs(cwd, "", found);
+	return found.sort(compareCodeUnits);
+}
+/**
+* Spec files in the project that a run over `ran` did NOT cover.
+*
+* `runVitest` passes the candidate filename as a vitest FILTER, which is what
+* keeps `test` and `eval` disjoint without either excluding the other's file —
+* see its doc. The cost is that every other `*.test.ts` in the project is
+* skipped, and the skip was SILENT: the shipped `retail` template carries seven
+* of them, so `aai test` there ran 1 file / 67 tests, printed "Tests passed",
+* and left 211 of the project's 278 tests unrun with nothing saying so.
+*
+* The narrow default STANDS — which files `aai test` runs is a documented
+* contract (the scaffold guide says "Run agent.test.ts via vitest"), and running
+* a project's other specs by default could reach ones that are slow or want
+* credentials. What does not stand is a GREEN VERDICT over the difference: this
+* set is what {@link executeTest} refuses to call a pass, what it puts in its
+* result for a script to read, and what `--all` opts into running.
+*/
+function unrunSpecFiles(cwd, ran) {
+	const covered = new Set(coveredList(ran));
+	return projectSpecFiles(cwd).filter((rel) => !covered.has(rel));
+}
+/** {@link RanSpecs} as a list, so nothing downstream re-derives the three cases. */
+function coveredList(ran) {
+	if (ran === false) return [];
+	return typeof ran === "string" ? [ran] : ran;
+}
+/** Code-unit comparison — see {@link projectSpecFiles} for why not `localeCompare`. */
+function compareCodeUnits(a, b) {
+	if (a < b) return -1;
+	return a > b ? 1 : 0;
+}
+/** One directory of {@link projectSpecFiles}, recursing into the ones that count. */
+function collectSpecs(dir, prefix, out) {
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const e of entries) {
+		const rel = prefix ? `${prefix}/${e.name}` : e.name;
+		if (e.isDirectory()) {
+			if (!(UNSCANNED_DIRS.has(e.name) || e.name.startsWith("."))) collectSpecs(path.join(dir, e.name), rel, out);
+		} else if (SPEC_FILE_RE.test(e.name) && !e.name.includes(".eval.test.")) out.push(rel);
+	}
+}
+/** How many unrun spec names a message prints before it starts counting. */
+const MAX_NAMED_SPECS = 10;
+/** The unrun set as one phrase — capped, because a project may hold hundreds. */
+function formatSpecList(files) {
+	const named = files.slice(0, MAX_NAMED_SPECS).join(", ");
+	const rest = files.length - MAX_NAMED_SPECS;
+	return rest > 0 ? `${named}, and ${rest} more` : named;
+}
+/**
+* The remedy, named the same way wherever the narrowing is reported.
+*
+* The project's own `npm test` comes FIRST because it is the command a
+* scaffolded project already ships (`scaffold/package.json`), so it is the one
+* answer that needs nothing installed or remembered; `--all` is the same thing
+* without leaving the CLI.
+*/
+const WIDEN_HINT = "Run the whole suite with this project's `npm test` (`vitest run --exclude \"**/*.eval.test.*\"`) or `aai test --all`; behaviour evals have their own command (`aai eval`).";
+/**
+* Warn, once, naming the spec files this run did not cover.
+*
+* This is the notice for a caller whose own result says nothing about the
+* narrowing — today that is `aai build`'s pre-build gate, which ran one file
+* out of eight and printed "Build complete". `aai test` does not use it: an
+* incomplete run is a FAILURE there, and the failure's own message is the
+* report.
+*/
+function warnUnrunSpecs(cwd, ran) {
+	const skipped = unrunSpecFiles(cwd, ran);
+	if (skipped.length === 0) return;
+	const ranList = coveredList(ran);
+	const preamble = ranList.length === 0 ? `No agent.test.ts, so vitest ran nothing. ${skipped.length} spec file(s) exist and were NOT run:` : `vitest ran ${ranList.join(", ")} only. ${skipped.length} other spec file(s) were NOT run:`;
+	notify("warn", `${preamble} ${formatSpecList(skipped)}. ${WIDEN_HINT}`);
+}
+/**
+* Execute agent tests and return structured result.
+*
+* **An incomplete run is not a pass.** For as long as this command answered
+* `{"ok":true,"data":{"passed":true}}` with exit 0 over specs it had not run,
+* the scaffold's `"test": "aai test"` was what users wired into CI — so a suite
+* of 25 tests could go red in the editor and green in the pipeline, and adding
+* one tool could break `registry.test.ts` in 17 assertions with `pnpm test` and
+* `pnpm build` both staying green throughout. It is the same defect
+* `defineExec`'s `cwd` policy exists for (a green result for a project that is
+* not there), one directory over, and it gets the same answer: the command
+* fails, names the files, and names the flag that runs them.
+*/
+async function executeTest(cwd, opts = {}) {
+	log.step(opts.all ? "Running project tests" : "Running agent tests");
+	try {
+		const ran = runVitest(cwd, {
+			candidates: TEST_FILES,
+			announceUnrun: false,
+			...omitUndefined({ all: opts.all })
+		});
+		const unrun = unrunSpecFiles(cwd, ran);
+		if (unrun.length > 0) return incomplete(ran, unrun);
+		if (ran === false) {
+			log.info("No test file found. Create agent.test.ts to add tests.");
+			return ok({
+				passed: true,
+				skipped: true,
+				ran: [],
+				unrun: [],
+				complete: true
+			});
+		}
+		log.success(`Tests passed (${ran.length} spec file(s))`);
+		return ok({
+			passed: true,
+			ran,
+			unrun: [],
+			complete: true
+		});
+	} catch (err) {
+		const { code, message } = classifyVitestError(err);
+		return fail(code, message);
+	}
+}
+/**
+* The verdict for a run that left specs uncovered.
+*
+* Both arms fail, and the `ran === false` arm is the one that had misled
+* longest: `aai test` printed "No test file found" while the project's specs sat
+* right there unrun, which reads as "this project has no tests". Measured on a
+* project whose only spec was `tools/echo_back.test.ts` — `{"passed":true,
+* "skipped":true}`, exit 0, and not a word about it.
+*/
+function incomplete(ran, unrun) {
+	const preamble = ran === false ? `\`aai test\` found no agent.test.ts, so it ran nothing, but ${unrun.length} spec file(s) exist` : `\`aai test\` ran ${ran.join(", ")} only — ${unrun.length} other spec file(s) in this project were not run`;
+	return fail("incomplete_run", `${preamble}: ${formatSpecList(unrun)}. An unrun spec is not a passing one, so this is not a green result.`, WIDEN_HINT);
+}
+//#endregion
+export { TEST_FILES, classifyVitestError, executeTest, runVitest };

package/dist/test.d.ts

@@ -2,9 +2,23 @@
  * `aai test` — run agent tests via vitest.
  */
 import { type CommandResult } from "./_output.ts";
+/**
+ * What `aai test` measured, not merely whether it exited 0.
+ *
+ * `passed` alone is what made a narrowed run indistinguishable from a complete
+ * one in a script (`jq -e .data.passed` was true either way), so the set it
+ * covered rides the result: `ran` is what vitest was pointed at, `unrun` is what
+ * it was not, and `complete` is the one field a CI job needs to read.
+ */
 type TestData = {
     passed: boolean;
     skipped?: boolean;
+    /** Spec files this run covered, project-relative, code-unit sorted. */
+    ran: string[];
+    /** Spec files in the project this run did NOT cover — empty when complete. */
+    unrun: string[];
+    /** Whether the run covered every non-eval spec file in the project. */
+    complete: boolean;
 };
 /**
  * Resolve the agent project's own vitest binary so tests run without the
@@ -24,7 +38,7 @@ export declare const TEST_FILES: readonly ["agent.test.ts", "agent.test.js"];
 export type VitestRunOptions = {
     /** File names to look for in the project root, in preference order. */
     readonly candidates: readonly string[];
-    /** Extra vitest CLI arguments, inserted before the file name. */
+    /** Extra vitest CLI arguments, inserted before the file names. */
     readonly extraArgs?: readonly string[];
     /**
      * Variables to add to the child's environment. Absent leaves the child with
@@ -33,20 +47,45 @@ export type VitestRunOptions = {
      * way a session under `aai dev` does.
      */
     readonly env?: Record<string, string>;
+    /**
+     * Run EVERY non-eval spec in the project rather than the first candidate.
+     *
+     * The opt-in half of the narrowing documented on {@link unrunSpecFiles}: the
+     * default stays one file, and this is how a caller says "I want the whole
+     * suite" without the command having to guess. Still a filter list rather than
+     * an include glob, so the eval tier stays disjoint by construction.
+     */
+    readonly all?: boolean;
+    /**
+     * Whether THIS function announces the specs it did not run.
+     *
+     * Default TRUE, and the default is the point: the caller most in need of the
+     * notice is the one that does not know it is narrowing. `aai build` runs this
+     * as its pre-build gate and reports nothing of its own, so a build gated on
+     * one file out of eight said so nowhere. `aai test` and `aai eval` pass
+     * `false` — the first because it reports the same set itself, in its result
+     * as well as its output, and the second because "did not run" is a claim
+     * about the TEST tier and every unit spec in the project would be named
+     * falsely by an eval run.
+     */
+    readonly announceUnrun?: boolean;
 };
 /**
- * Run vitest over one of `candidates` in the given project directory.
+ * Run vitest over `candidates` (or, with `all`, the whole project) in the given
+ * project directory.
  *
- * Returns the FILE it ran, or `false` if none of the candidate files exists.
- * Throws on failure.
+ * Returns the FILES it ran, or `false` if there was nothing to run. Throws on
+ * failure.
  *
- * A vitest FILTER, not an include glob: the argument is matched as a substring
+ * A vitest FILTER, not an include glob: each argument is matched as a substring
  * against the paths vitest's own include globs already found, which is why the
  * candidates are named `*.test.ts` — `agent.test.ts` cannot match
  * `agent.eval.test.ts` and vice versa, so the two commands stay disjoint
- * without either one having to exclude the other's file.
+ * without either one having to exclude the other's file. That holds for the
+ * `all` list too: it is built from {@link projectSpecFiles}, which drops the
+ * eval tier by infix.
  */
-export declare function runVitest(cwd: string, opts?: VitestRunOptions): string | false;
+export declare function runVitest(cwd: string, opts?: VitestRunOptions): string[] | false;
 /**
  * Classify a {@link runVitest} failure. execaSync throws an ENOENT-coded
  * error when the binary itself couldn't be spawned (infrastructure problem)
@@ -59,36 +98,63 @@ label?: string): {
     message: string;
 };
 /**
- * Spec files in the project that `aai test` did NOT run.
+ * Every spec file in the project that belongs to the TEST tier.
  *
- * `runVitest` passes ONE filename as a vitest FILTER, which is what keeps `test`
- * and `eval` disjoint without either excluding the other's file — see its doc.
- * The cost is that every other `*.test.ts` in the project is skipped, and the
- * skip was SILENT: the shipped `retail` template carries seven of them, so
- * `aai test` there ran 1 file / 67 tests, printed "Tests passed", and left
- * 211 of the project's 278 tests unrun with nothing saying so.
+ * Eval files are excluded by the `.eval.` INFIX — the tier convention — rather
+ * than by a filename list, which is what keeps this module from importing
+ * `eval.ts`, which imports this one.
+ */
+export declare function projectSpecFiles(cwd: string): string[];
+/**
+ * Spec files in the project that a run over `ran` did NOT cover.
  *
- * A silent skip is the worst outcome available, so the skip is announced rather
- * than the filter widened: which files `aai test` runs is a documented contract
- * (the scaffold guide says "Run agent.test.ts via vitest"), and running a
- * project's other specs by default could reach ones that are slow or want
- * credentials. Naming them costs nothing and is what a reader needs.
+ * `runVitest` passes the candidate filename as a vitest FILTER, which is what
+ * keeps `test` and `eval` disjoint without either excluding the other's file —
+ * see its doc. The cost is that every other `*.test.ts` in the project is
+ * skipped, and the skip was SILENT: the shipped `retail` template carries seven
+ * of them, so `aai test` there ran 1 file / 67 tests, printed "Tests passed",
+ * and left 211 of the project's 278 tests unrun with nothing saying so.
  *
- * Eval files are excluded because they have their OWN command, named in the
- * message.
+ * The narrow default STANDS — which files `aai test` runs is a documented
+ * contract (the scaffold guide says "Run agent.test.ts via vitest"), and running
+ * a project's other specs by default could reach ones that are slow or want
+ * credentials. What does not stand is a GREEN VERDICT over the difference: this
+ * set is what {@link executeTest} refuses to call a pass, what it puts in its
+ * result for a script to read, and what `--all` opts into running.
+ */
+export declare function unrunSpecFiles(cwd: string, ran: RanSpecs): string[];
+/**
+ * What a caller reports as covered: one filename, a list of them, or `false`
+ * for a run that found nothing to point vitest at.
  */
-export declare function unrunSpecFiles(cwd: string, ran: string): string[];
+export type RanSpecs = string | readonly string[] | false;
 /**
  * Warn, once, naming the spec files this run did not cover.
  *
- * `ran` is `false` when there was no `agent.test.ts` to run, and that case
- * needs the warning MORE rather than less: `aai test` then prints "No test file
- * found" while the project's spec files sit right there unrun, which reads as
- * "this project has no tests". Measured on a project whose only spec was
- * `tools/echo_back.test.ts` — `{"passed":true,"skipped":true}` and not a word
- * about it. It stays silent when there is nothing to name, in both arms.
+ * This is the notice for a caller whose own result says nothing about the
+ * narrowing — today that is `aai build`'s pre-build gate, which ran one file
+ * out of eight and printed "Build complete". `aai test` does not use it: an
+ * incomplete run is a FAILURE there, and the failure's own message is the
+ * report.
+ */
+export declare function warnUnrunSpecs(cwd: string, ran: RanSpecs): void;
+/** What `aai test` was asked to cover. */
+export type TestOptions = {
+    /** Run every non-eval spec in the project rather than `agent.test.ts` alone. */
+    readonly all?: boolean | undefined;
+};
+/**
+ * Execute agent tests and return structured result.
+ *
+ * **An incomplete run is not a pass.** For as long as this command answered
+ * `{"ok":true,"data":{"passed":true}}` with exit 0 over specs it had not run,
+ * the scaffold's `"test": "aai test"` was what users wired into CI — so a suite
+ * of 25 tests could go red in the editor and green in the pipeline, and adding
+ * one tool could break `registry.test.ts` in 17 assertions with `pnpm test` and
+ * `pnpm build` both staying green throughout. It is the same defect
+ * `defineExec`'s `cwd` policy exists for (a green result for a project that is
+ * not there), one directory over, and it gets the same answer: the command
+ * fails, names the files, and names the flag that runs them.
  */
-export declare function warnUnrunSpecs(cwd: string, ran: string | false): void;
-/** Execute agent tests and return structured result. */
-export declare function executeTest(cwd: string): Promise<CommandResult<TestData>>;
+export declare function executeTest(cwd: string, opts?: TestOptions): Promise<CommandResult<TestData>>;
 export {};

package/dist/typecheck.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { n as binFromManifest, o as errorMessage, u as readPackageJson } from "./_utils-B8QmtFhK.mjs";
+import { n as binFromManifest, o as errorMessage, u as readPackageJson } from "./_utils-Dhd058D9.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
-//#region typecheck.ts
+//#region src/typecheck.ts
 /**
 * Project typechecking — `tsc --noEmit` over the project's own tsconfig.
 *

package/dist/worker-bundler.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { i as errorCode } from "./_utils-B8QmtFhK.mjs";
-import { n as withPreservedNodeEnv } from "./_vite-env-D9Qj6KPX.mjs";
+import { i as errorCode } from "./_utils-Dhd058D9.mjs";
+import { n as withPreservedNodeEnv } from "./_vite-env-kejF0p2L.mjs";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { invariant } from "@alexkroman1/aai/internal";
 import { build } from "vite";
-//#region worker-bundler.ts
+//#region src/worker-bundler.ts
 /**
 * Generated wrapper entry, written under `.aai/` for the duration of the
 * build (the CLI's own scratch dir — dot-paths are ignored by the dev

package/dist/{workflow-BBu5oEDw.mjs → workflow-BZyKLkhV.mjs}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { a as ok, n as fail, t as CliError } from "./_output-CKkmWs7i.mjs";
-import { n as log } from "./_ui-u7T4YooX.mjs";
-import { i as readProjectConfig } from "./_config-CmJOFsAP.mjs";
-import { n as getServerInfo } from "./_agent-BTwZJu4P.mjs";
+import { a as ok, n as fail, t as CliError } from "./_output-DbJt9gsl.mjs";
+import { n as log } from "./_ui-DCt4qZrk.mjs";
+import { i as readProjectConfig } from "./_config-ZY2euhdh.mjs";
+import { n as getServerInfo } from "./_agent-Clbq3a4h.mjs";
 import { errorMessage, omitUndefined } from "@alexkroman1/aai/utils";
 import { createWorkflowApiClient } from "@alexkroman1/aai/workflow-api";
-//#region workflow.ts
+//#region src/workflow.ts
 /**
 * `aai workflow` — reading and steering a deployed agent's durable runs from a
 * terminal.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-cli",
-  "version": "13.1.0",
+  "version": "13.3.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -20,22 +20,22 @@
   },
   "exports": {
     "./client-bundler": {
-      "@dev/source": "./client-bundler.ts",
+      "@dev/source": "./src/client-bundler.ts",
       "types": "./dist/client-bundler.d.ts",
       "import": "./dist/client-bundler.mjs"
     },
     "./worker-bundler": {
-      "@dev/source": "./worker-bundler.ts",
+      "@dev/source": "./src/worker-bundler.ts",
       "types": "./dist/worker-bundler.d.ts",
       "import": "./dist/worker-bundler.mjs"
     },
     "./typecheck": {
-      "@dev/source": "./typecheck.ts",
+      "@dev/source": "./src/typecheck.ts",
       "types": "./dist/typecheck.d.ts",
       "import": "./dist/typecheck.mjs"
     },
     "./project-config": {
-      "@dev/source": "./project-config.ts",
+      "@dev/source": "./src/project-config.ts",
       "types": "./dist/project-config.d.ts",
       "import": "./dist/project-config.mjs"
     }
@@ -52,9 +52,9 @@
     "p-timeout": "^7.0.1",
     "vite": "^8.2.2",
     "zod": "^4.5.4",
-    "@alexkroman1/aai": "13.1.0",
-    "@alexkroman1/aai-runtime": "13.1.0",
-    "@alexkroman1/aai-ui": "13.1.0"
+    "@alexkroman1/aai": "13.3.0",
+    "@alexkroman1/aai-runtime": "13.3.0",
+    "@alexkroman1/aai-ui": "13.3.0"
   },
   "devDependencies": {
     "playwright": "^1.62.1",
@@ -80,8 +80,8 @@
     "lint": "biome check .",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "test:e2e": "VITEST_PROFILE=e2e VITEST_SETUP=./_test-setup.ts VITEST_INCLUDE=e2e*.test.ts vitest run -c ../../vitest.slow.config.ts",
-    "test:scenario": "VITEST_PROFILE=scenario VITEST_SETUP=./_test-setup.ts VITEST_INCLUDE=**/*.scenario.test.ts vitest run -c ../../vitest.slow.config.ts",
+    "test:e2e": "VITEST_PROFILE=e2e VITEST_SETUP=./src/_test-setup.ts VITEST_INCLUDE=src/e2e*.test.ts vitest run -c ../../vitest.slow.config.ts",
+    "test:scenario": "VITEST_PROFILE=scenario VITEST_SETUP=./src/_test-setup.ts VITEST_INCLUDE=**/*.scenario.test.ts vitest run -c ../../vitest.slow.config.ts",
     "typecheck": "tsc --noEmit"
   }
 }

package/dist/bin.d.mts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/secret-B-3T5tvr.mjs

@@ -1,61 +0,0 @@
-#!/usr/bin/env node
-import { a as ok, n as fail } from "./_output-CKkmWs7i.mjs";
-import { n as log, s as unwrapCancel } from "./_ui-u7T4YooX.mjs";
-import { f as checkedResponse, p as isStringArray } from "./_studio-B1waXMuR.mjs";
-import { t as secretRequest } from "./_slug-api-CfGQq1Tt.mjs";
-import { isRecord } from "@alexkroman1/aai/utils";
-import * as p from "@clack/prompts";
-import { text } from "node:stream/consumers";
-//#region secret.ts
-/**
-* The one `no_input` failure for `secret put`, shared by the JSON-mode stdin
-* path (cli.ts) and the TTY prompt path below so the two can't drift.
-*/
-const NO_INPUT = [
-	"no_input",
-	"No value provided",
-	"Pipe secret value to stdin"
-];
-/** Read secret value from stdin (for non-TTY / piped input). */
-async function readStdin() {
-	return (await text(process.stdin)).trim();
-}
-/**
-* Execute secret put. If `value` is provided, use it directly (non-TTY path).
-* If not provided, prompt interactively (TTY path).
-*/
-async function executeSecretPut(cwd, name, value, server) {
-	let secretValue = value;
-	if (!secretValue) {
-		const result = unwrapCancel(await p.password({ message: `Enter value for ${name}` }));
-		if (!result) return fail(...NO_INPUT);
-		secretValue = result;
-	}
-	const { target } = await secretRequest(cwd, "", {
-		method: "PUT",
-		body: { [name]: secretValue },
-		action: "secret"
-	}, server);
-	log.success(`Set ${name} for ${target}`);
-	return ok({ name });
-}
-async function executeSecretDelete(cwd, name, server) {
-	const { target } = await secretRequest(cwd, `/${encodeURIComponent(name)}`, {
-		method: "DELETE",
-		action: "secret"
-	}, server);
-	log.success(`Deleted ${name} from ${target}`);
-	return ok({ name });
-}
-async function executeSecretList(cwd, server) {
-	const { data, target } = await secretRequest(cwd, "", { action: "secret" }, server);
-	const { vars } = checkedResponse(data, (value) => isRecord(value) && isStringArray(value.vars), `the secret list for ${target}`);
-	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"}:`);
-		for (const v of vars) log.message(`  ${v}`);
-	}
-	return ok({ secrets: vars });
-}
-//#endregion
-export { NO_INPUT, executeSecretDelete, executeSecretList, executeSecretPut, readStdin };