@alexkroman1/aai-cli 9.1.0 → 10.0.0

package/dist/templates/transcription-workflow/workflows/wav.ts

@@ -3,9 +3,9 @@
  * The pure half of the transcription desk: reading a WAV header, deciding where
  * to cut, and writing a header back over each cut.
  *
- * No directive in this file, and that is legal — the Workflow DevKit's builder
- * scans `workflows/` and transforms only what carries a `"use workflow"` /
- * `"use step"` body, so an ordinary module can sit beside them. It is a separate
+ * Nothing in this file is a step or a body, and that is legal — a body is
+ * whatever is handed a `ctx`, so an ordinary module can sit beside one. It is a
+ * separate
  * file because everything here is a pure function of a journaled value, which is
  * what makes it testable without a run at all: `transcribe.ts`'s spec drives
  * these directly.
@@ -43,7 +43,18 @@
  *   so they keep naming the `ffmpeg` line that fixes the file.
  */
 
-/** What the sync endpoint will accept in one request. */
+/**
+ * What the sync endpoint will accept in one request.
+ *
+ * **Measured against the live endpoint, the binding limit is a 30-second WALL
+ * CLOCK budget rather than this**, and that budget covers the upload as well as
+ * the transcription: a 92-second segment that is 17.66 MB comes back
+ * `504 — request exceeded 30.0s` well inside the documented cap. The constant is
+ * left alone because it is what the service DOCUMENTS and the discrepancy is
+ * unconfirmed; what closes the gap today is `downsample.ts`, which makes each
+ * request six times lighter so the deadline stops binding. Revisit both together
+ * once the real cap is settled — this number is what `planSegments` cuts to.
+ */
 export const MAX_SEGMENT_SECONDS = 120;
 
 /**

package/dist/worker-bundler.d.ts

@@ -1,5 +1,4 @@
 import { type PluginOption } from "vite";
-import { type WorkflowBundleOutput } from "./workflow-bundler.ts";
 /**
  * Options for worker bundling.
  *
@@ -25,19 +24,6 @@ export type BuildWorkerOptions = {
      * rebuild would turn the watch loop from sub-second into multi-second.
      */
     runtime?: boolean;
-    /**
-     * The project's compiled workflows, when it declares any.
-     *
-     * Embedded in the worker as two string exports rather than shipped as extra
-     * files, because the guest's `bundle/load` contract is ONE ESM string. See
-     * `wrapperEntrySource`.
-     *
-     * It also switches on the client transform (`workflowClientPlugin`), which is
-     * what puts a `workflowId` on the agent's own copy of each body. Passing the
-     * strings without it produces a bundle that serves every workflow route and
-     * cannot start a run.
-     */
-    workflows?: WorkflowBundleOutput | undefined;
 };
 /**
  * Bundle agent.ts into a single ESM string for the sandbox worker.

package/dist/worker-bundler.mjs

@@ -1,3 +1,151 @@
 #!/usr/bin/env node
-import { t as buildWorker } from "./worker-bundler-CCVEDjm1.mjs";
+import { i as errorCode } from "./_utils-B8QmtFhK.mjs";
+import { n as withPreservedNodeEnv } from "./_vite-env-BNveawd1.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
+/**
+* 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
+* watcher, and the studio's workspace materialization never writes there).
+*/
+const WRAPPER_ENTRY_REL = path.join(".aai", "worker-entry.ts");
+/** Extensions a tool module may be authored in (mirrors the SDK's registry). */
+const TOOL_MODULE_EXT_RE = /\.(?:m?ts|tsx)$/;
+/** A co-located spec is not a tool. */
+const TOOL_SPEC_RE = /\.(?:test|spec)\.[^.]+$/;
+/**
+* The project's `tools/` directory, as file names relative to it.
+*
+* **This is the whole of "discovery", and it happens HERE because the guest has
+* no filesystem.** A sandbox is handed one ESM string, so the only place a
+* directory can be turned into modules is where the bundle is assembled — the
+* same lowering eve does (`readdir` → static import list, which the bundler then
+* follows). The names are validated by `toolRegistry` at bundle-evaluation time
+* rather than here, so one implementation owns the rules.
+*
+* Sorted, so the emitted entry is byte-stable for a given directory: an entry
+* that reordered per readdir would change the bundle hash for no reason.
+*/
+async function discoverToolFiles(cwd) {
+	const root = path.join(cwd, "tools");
+	let entries;
+	try {
+		entries = await fs.readdir(root, {
+			withFileTypes: true,
+			recursive: true
+		});
+	} catch (err) {
+		if (errorCode(err) === "ENOENT") return [];
+		throw err;
+	}
+	return entries.filter((e) => e.isFile() && TOOL_MODULE_EXT_RE.test(e.name) && !TOOL_SPEC_RE.test(e.name)).map((e) => path.relative(root, path.join(e.parentPath, e.name)).split(path.sep).join("/")).sort();
+}
+/** The prose slot: one file, beside `agent.ts`, named by convention. */
+const SYSTEM_PROMPT_FILE = "system-prompt.md";
+/**
+* Whether the project keeps its system prompt in a file.
+*
+* The other half of "a file beside `agent.ts` can BE the thing", and it happens
+* here for the same reason `discoverToolFiles` does — the guest has no
+* filesystem, so the read belongs where the bundle is assembled. What the file
+* MEANS is `withSystemPrompt`'s to decide (the author may have imported and
+* composed it, in which case discovery must not apply it twice); this only
+* answers whether there is one.
+*/
+async function hasSystemPromptFile(cwd) {
+	const nested = path.join(cwd, "system-prompt");
+	if ((await fs.stat(nested).catch(() => void 0))?.isDirectory() === true) throw new Error(`${nested} is a directory. A system prompt is ONE file — rename it to ${SYSTEM_PROMPT_FILE}, or import the pieces yourself and compose them into \`systemPrompt\`. There is deliberately no concatenation order for a directory.`);
+	try {
+		return (await fs.stat(path.join(cwd, SYSTEM_PROMPT_FILE))).isFile();
+	} catch (err) {
+		if (errorCode(err) === "ENOENT") return false;
+		throw err;
+	}
+}
+function wrapperEntrySource(runtime, toolFiles, systemPromptFile) {
+	const toolImports = toolFiles.map((file, i) => `import * as __aaiTool${i} from "../tools/${file}";`).join("\n");
+	const toolEntries = toolFiles.map((file, i) => `  ${JSON.stringify(`tools/${file}`)}: __aaiTool${i},`).join("\n");
+	return `import def from "../agent.ts";
+import { agentToolsToSchemas, toAgentConfig, toolRegistry, withSystemPrompt, withTools } from "@alexkroman1/aai/manifest";
+${runtime ? `import { createRuntime } from "@alexkroman1/aai-runtime";` : ""}
+${systemPromptFile ? `import __aaiSystemPrompt from "../${SYSTEM_PROMPT_FILE}?raw";` : ""}
+${toolImports}
+// A tool's name is its file name. The map is built here rather than written in
+// agent.ts, so a file that exists is a tool the model can call — there is no
+// registration step to forget.
+//
+// \`system-prompt.md\` arrives the same way, and the \`?raw\` lives HERE rather
+// than in the author's own \`agent.ts\`: it is a Vite convention, and the whole
+// point of generating this entry is that a bundler feature never has to appear
+// in user-authored space.
+const __aaiAgent = ${systemPromptFile ? "withSystemPrompt(" : ""}withTools(
+  def,
+  toolRegistry({
+${toolEntries}
+  }),
+)${systemPromptFile ? ", __aaiSystemPrompt)" : ""};
+export default __aaiAgent;
+export const __aaiConfig = {
+  ...toAgentConfig(__aaiAgent),
+  toolSchemas: agentToolsToSchemas(__aaiAgent.tools ?? {}),
+};
+${runtime ? `export const __aaiCreateRuntime = (opts: Record<string, unknown>) =>
+  createRuntime({ ...opts, agent: __aaiAgent });
+` : ""}`;
+}
+/**
+* Bundle agent.ts into a single ESM string for the sandbox worker.
+*
+* Zod is bundled in — zod 4's `Function()` usage is wrapped in try/catch
+* and gracefully degrades in restricted environments like Deno.
+*
+* @internal — build hook for aai-server/the studio; not a supported public
+* API and not covered by semver.
+*/
+async function buildWorker(cwd, opts = {}) {
+	const wrapperPath = path.join(cwd, WRAPPER_ENTRY_REL);
+	const [, toolFiles, systemPromptFile] = await Promise.all([
+		fs.mkdir(path.dirname(wrapperPath), { recursive: true }),
+		discoverToolFiles(cwd),
+		hasSystemPromptFile(cwd)
+	]);
+	await fs.writeFile(wrapperPath, wrapperEntrySource(opts.runtime !== false, toolFiles, systemPromptFile), "utf-8");
+	const plugins = opts.plugins ?? [];
+	let result;
+	try {
+		result = await withPreservedNodeEnv(() => build({
+			root: cwd,
+			logLevel: "silent",
+			...opts.configFile === false && { configFile: false },
+			...plugins.length > 0 && { plugins },
+			ssr: { noExternal: true },
+			build: {
+				ssr: true,
+				lib: {
+					entry: wrapperPath,
+					formats: ["es"],
+					fileName: "worker"
+				},
+				target: "node20",
+				minify: opts.minify ? "oxc" : false,
+				write: false,
+				rollupOptions: { output: {
+					entryFileNames: "[name].js",
+					codeSplitting: false
+				} }
+			}
+		}));
+	} finally {
+		await fs.rm(wrapperPath, { force: true }).catch(() => void 0);
+	}
+	const output = Array.isArray(result) ? result[0] : result;
+	invariant(output !== void 0, "bundle.worker.output");
+	const chunk = output.output.find((o) => o.type === "chunk" && o.isEntry);
+	invariant(chunk !== void 0, "bundle.worker.entry-chunk", () => ({ kinds: output.output.map((o) => o.type) }));
+	return chunk.code;
+}
+//#endregion
 export { buildWorker };

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

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { a as ok, n as fail } from "./_output-CKkmWs7i.mjs";
+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 { errorMessage, omitUndefined } from "@alexkroman1/aai/utils";
 import { createWorkflowApiClient } from "@alexkroman1/aai/workflow-api";
@@ -35,32 +36,105 @@ import { createWorkflowApiClient } from "@alexkroman1/aai/workflow-api";
 /** Runs listed when the caller names no limit — a terminal is not a dashboard. */
 const DEFAULT_RUN_LIMIT = 20;
 /**
+* The base URL {@link createWorkflowApiClient} is given for `--agent`.
+*
+* A dev server has no slug: `createServer` mounts the workflow API at
+* `WORKFLOW_API_PREFIX` on the ORIGIN, where the platform serves it under
+* `/:slug`. So targeting one is not a matter of a different origin — it is the
+* absence of the path segment, which nothing in this command could express.
+*
+* Validated rather than interpolated. This value is joined into a request path,
+* and the CLI's standing rule is that anything reaching a URL is checked at the
+* one point it becomes a target (`resolveDeployTarget`'s slug guard is the same
+* rule). It is also the only origin here that `resolveServerUrl` does not
+* produce, so stripping the trailing slash is this function's job — the join
+* site deliberately carries no copy of that.
+*
+* No trust check, deliberately, and the asymmetry with `--server` is the point:
+* `--server` pairs an origin with the user's PLATFORM API KEY, which is why a
+* repo-supplied loopback URL is refused there. Nothing credentialed goes to
+* `--agent` — the workflow API takes the agent's own bearer or none — so there
+* is nothing for a hostile origin to collect, and requiring `aai login` to read
+* runs off a server on your own laptop is the defect this flag exists for.
+*/
+function agentBaseUrl(raw) {
+	const url = URL.parse(raw);
+	if (url === null) throw new CliError("bad_agent_url", `--agent is not a URL: ${JSON.stringify(raw)}`, HINT_URL);
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new CliError("bad_agent_url", `--agent must be http or https, not ${url.protocol.replace(":", "")}`, HINT_URL);
+	return raw.replace(/\/+$/, "");
+}
+/**
 * A client for the agent's workflow API, plus the bearer when one was given.
 *
-* `getServerInfo` is what turns "this directory" into an origin and a published
-* slug, and it already refuses a project that has never been deployed with the
-* sentence naming `aai publish`. The client is handed the AGENT's base URL and
-* appends the route prefix itself, so the `/workflows` literal is not spelled
-* here — it is the same constant the server matches on.
+* Two ways in. `--agent <url>` names a server the caller is running themselves
+* — `aai dev`, or the scaffold's `npm start` — and takes that URL as the base:
+* no project config, no published slug, and no `ensureApiKey`, none of which
+* such a server has or wants. Otherwise `getServerInfo` turns "this directory"
+* into a platform origin and a published slug.
+*
+* The client is handed the AGENT's base URL and appends the route prefix itself,
+* so the `/workflows` literal is not spelled here — it is the same constant the
+* server matches on.
 *
 * `serverUrl` is joined as-is: `resolveServerUrl` is the single producer of
-* every origin that reaches here and strips trailing slashes once, at
+* every origin that reaches THAT branch and strips trailing slashes once, at
 * resolution time, precisely so join sites do not each carry a copy. The copy
 * this used to hold also DISAGREED with it — `/\/$/` takes one slash where the
 * upstream `/\/+$/` takes all — so the two would have differed on the only
 * input either was written for.
+*
+* **The no-deployment failure is raised HERE rather than by
+* `requireDeployedSlug`, and the ordering is why.** `getServerInfo` resolves the
+* API key BEFORE it looks for a slug, so in an undeployed project the first
+* thing a developer running `aai dev` saw was `not_logged_in` — pointing at
+* `aai login` for a command that never sends the key it was asking for, with
+* the real cause two errors away. Reading the project config first puts the
+* cause first and lets the sentence name every way out: publish it, or point at
+* the server already running.
 */
 async function target(cwd, opts) {
+	if (opts.agent !== void 0) {
+		const baseUrl = agentBaseUrl(opts.agent);
+		return {
+			api: createWorkflowApiClient({
+				baseUrl,
+				...omitUndefined({ token: opts.token })
+			}),
+			name: baseUrl
+		};
+	}
+	if (!(await readProjectConfig(cwd))?.slug) throw new CliError("no_deployment", NO_DEPLOYMENT, HINT_AGENT);
 	const { serverUrl, slug } = await getServerInfo(cwd, opts.server);
 	return {
 		api: createWorkflowApiClient({
 			baseUrl: `${serverUrl}/${slug}`,
 			...omitUndefined({ token: opts.token })
 		}),
-		slug
+		name: slug
 	};
 }
 /**
+* What a project with no deployment is told, and why it names two ways out.
+*
+* `requireDeployedSlug`'s sentence — "run `aai publish` first" — is right for
+* `aai secret` and `aai delete`, which have nothing to talk to until the agent
+* is on the platform. It is wrong here often enough to be a defect: a workflow
+* API is the one agent surface that is fully live under `aai dev`, so the
+* developer being told to publish frequently has the thing they asked about
+* answering on localhost already.
+*/
+const NO_DEPLOYMENT = "This project has no deployed agent, and no --agent URL was given — so there is nothing for `aai workflow` to ask.";
+/**
+* What a malformed `--agent` is told.
+*
+* Its own hint rather than {@link HINT_AGENT}: the caller already knows about
+* the flag — they typed it — so repeating "run `aai publish`" answers a
+* question they did not ask.
+*/
+const HINT_URL = "Pass a full origin, e.g. --agent http://localhost:3000";
+/** How to reach a server you are running yourself. Paired with {@link NO_DEPLOYMENT}. */
+const HINT_AGENT = "Run `aai publish` to deploy it, or pass --agent <url> to target a server you are already running — `--agent http://localhost:3000` for `aai dev`, which needs no login and no slug.";
+/**
 * Run one call, turning a rejection into this command's failure result.
 *
 * The client throws with the AGENT'S own sentence — an unknown workflow names
@@ -93,11 +167,11 @@ async function attempt(code, call) {
 }
 /** `aai workflow list` — what this agent declares. */
 async function executeWorkflowList(cwd, opts) {
-	const { api, slug } = await target(cwd, opts);
+	const { api, name } = await target(cwd, opts);
 	const res = await attempt("workflow_list_failed", () => api.list());
 	if (!res.ok) return res;
 	const workflows = res.value;
-	if (workflows.length === 0) log.info(`${slug} declares no workflows`);
+	if (workflows.length === 0) log.info(`${name} declares no workflows`);
 	else for (const w of workflows) log.info(`${w.name}${w.description ? ` — ${w.description}` : ""}`);
 	return ok({ workflows });
 }

package/dist/workflow.d.ts

@@ -39,6 +39,7 @@ type Run = WorkflowRunSnapshot;
 type WorkflowOptions = {
     server?: string | undefined;
     token?: string | undefined;
+    agent?: string | undefined;
 };
 /** `aai workflow list` — what this agent declares. */
 export declare function executeWorkflowList(cwd: string, opts: WorkflowOptions): Promise<CommandResult<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-cli",
-  "version": "9.1.0",
+  "version": "10.0.0",
   "type": "module",
   "bin": {
     "aai": "bin.mjs"
@@ -33,7 +33,6 @@
   ],
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@workflow/builders": "4.1.7",
     "chokidar": "^5.0.0",
     "citty": "^0.2.2",
     "env-paths": "^4.0.0",
@@ -44,16 +43,15 @@
     "p-timeout": "^7.0.1",
     "vite": "^8.2.1",
     "zod": "^4.4.3",
-    "@alexkroman1/aai": "9.1.0",
-    "@alexkroman1/aai-runtime": "9.1.0",
-    "@alexkroman1/aai-ui": "9.1.0"
+    "@alexkroman1/aai": "10.0.0",
+    "@alexkroman1/aai-runtime": "10.0.0",
+    "@alexkroman1/aai-ui": "10.0.0"
   },
   "devDependencies": {
     "playwright": "^1.62.1",
     "tsdown": "^0.22.14",
     "verdaccio": "^6.9.2",
     "vitest": "^4.1.10",
-    "workflow": "4.8.2",
     "aai-templates": "0.3.8"
   },
   "peerDependencies": {

package/dist/_workflow-scan.d.ts

@@ -1,108 +0,0 @@
-/**
- * What the BUILT flow bundle carries — the two scans that read it, and the
- * checks over them.
- *
- * Split out of `workflow-bundler.ts` when that file crossed the 500-line cap,
- * along the seam the two scans already share: both read the same artifact after
- * the builder has written it, both attribute a line to a module through
- * esbuild's `// <path>` headers, and neither has anything to do with
- * CONFIGURING the build. One of them fails the build (a `require` the workflow
- * VM cannot answer) and the other warns (a call that replays differently), which
- * is the only real difference between them.
- *
- * Internal: `workflow-bundler.ts` is the surface the studio and the CLI's own
- * build call, and it re-exports nothing from here that they need.
- *
- * @module _workflow-scan
- */
-/** One `require` the workflow VM cannot answer, and the module it was written for. */
-export type VmRequireSite = {
-    /** The module specifier — `node:child_process`. */
-    specifier: string;
-    /** The bundled file esbuild attributed it to, or `undefined` when it said none. */
-    module: string | undefined;
-};
-/**
- * Find the Node builtins a flow bundle would `require` at load.
- *
- * The flow bundle is compiled in a `node:vm` `Script` whose context has
- * `module` and `exports` and **no `require`**, so one of these is a run that
- * dies at replay with `ReferenceError: require is not defined` — never a build
- * failure, and never a symptom before the first run. The WDK's own builder
- * bundles everything for exactly this reason and carries
- * `createNodeModuleErrorPlugin` to reject a builtin import at build time.
- *
- * That plugin has two blind spots this scan covers, and both are the DEPLOYED
- * shape rather than an exotic one:
- *
- * - It reports a violation only when it can point at the import LINE in a
- *   first-party file, matched with a single-line regex — so a multi-line
- *   `import {\n  x,\n} from "pkg"` finds nothing and the builtin is marked
- *   external in silence.
- * - It resolves that file against `process.cwd()`, which is not the project
- *   being built when the studio builds a workspace, so the read fails and the
- *   same silent path is taken.
- *
- * Both were reproduced. What reaches the VM either way is
- * `var import_node_child_process = require("node:child_process");` at the top
- * of the bundle, i.e. every run of every workflow in the project fails, and the
- * stack names a line of generated code inside a dependency.
- *
- * Restricted to builtin specifiers deliberately: those are the only ones this
- * builder leaves external (it marks nothing else so, precisely so nothing can
- * need a `require`), and a narrow set is what keeps the scan from reading the
- * text of a prompt as a violation.
- *
- * @internal
- */
-export declare function findVmRequires(workflowCode: string): VmRequireSite[];
-/** One replay-unsafe call the flow bundle carries, and where it came from. */
-export type ReplayUnsafeSite = {
-    /** The call, as written — `Date.now(`. */
-    call: string;
-    /** What it does on a replay, and what to do instead. */
-    fix: string;
-    /** The project file esbuild attributed it to. */
-    module: string;
-};
-/**
- * Replay-unsafe calls the flow bundle carries, attributed to the project's OWN
- * `workflows/` files.
- *
- * Attribution is the whole design. The bundle inlines every non-external
- * dependency a workflow module imports — zod, a markdown parser, whatever — and
- * third-party code is full of `Date.now()` on paths a workflow never reaches, so
- * a scan of the bundle's text reports a library and blocks a correct project.
- * esbuild writes a `// <path>` header per module (the same one
- * {@link findVmRequires} reads), so lines can be charged to the file they were
- * written in, and only the project's own workflow sources are read.
- *
- * Scanning the BUNDLE rather than the sources is what makes a `"use step"` body
- * exempt for free: the workflow-mode transform has already removed them, so
- * what is left is the part that really does replay.
- *
- * @internal
- */
-export declare function findReplayUnsafeCalls(workflowCode: string): ReplayUnsafeSite[];
-/**
- * The warning `aai build` and `aai dev` print for a replay-unsafe call.
- *
- * A WARNING and not a build failure, deliberately. The attribution above makes
- * the scan accurate about which FILE a call is in, and it cannot know whether a
- * plain function in a `workflows/` module is reached from a body (where the
- * rule bites) or only from a step (where it does not) — so the one thing it
- * must not do is refuse a correct project. A silent build was the actual
- * problem; a line naming the file solves it without that risk.
- */
-export declare function replayWarnings(workflowCode: string): string[];
-/**
- * Fail the build when the flow bundle carries a `require` — see
- * {@link findVmRequires} for what that means and why nothing upstream catches it.
- *
- * The message has to name the MODULE as well as the specifier, because the
- * import that caused it is not in the file an author is looking at: only a
- * `"use step"` body is stripped from this bundle, so a value a `workflows/`
- * module holds at module scope — an exported helper, a constant — keeps its
- * import, and that import's whole graph rides into the VM.
- */
-export declare function assertNoVmRequires(workflowCode: string): void;