@flue/sdk 0.2.0 → 0.3.1

package/dist/index.mjs

@@ -1,57 +1,98 @@
-import { a as parseFrontmatterFile, n as createTools, t as BUILTIN_TOOL_NAMES } from "./agent-BYG0nVbQ.mjs";
+import { a as parseFrontmatterFile, n as createTools, t as BUILTIN_TOOL_NAMES } from "./agent-BB4lwAd5.mjs";
 import * as esbuild from "esbuild";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { packageUpSync } from "package-up";
-import { parse } from "jsonc-parser";
+import { spawn } from "node:child_process";
 
 //#region src/cloudflare-wrangler-merge.ts
 /**
 * Merge Flue's Cloudflare additions into the user's wrangler config.
 *
-* Philosophy: the user's wrangler.jsonc is the source of truth. Flue contributes
+* Philosophy: the user's wrangler config is the source of truth. Flue contributes
 * the pieces it owns (the Worker entrypoint, its per-agent Durable Object
 * bindings, the Sandbox DO, the migration tag) and leaves everything else
 * untouched. The merged result is written to `dist/wrangler.jsonc` so the
 * deployed Worker sees both.
 *
-* We use `jsonc-parser` (the same library wrangler uses internally) for
-* reading. TOML is intentionally unsupported — Cloudflare itself recommends
-* wrangler.jsonc for new projects, and supporting both formats here would
-* double the surface area for no real benefit. Users with wrangler.toml get a
-* clear error directing them to convert.
+* We delegate parsing and normalization to wrangler's own `unstable_readConfig`
+* (lazy-imported so Node-only Flue users don't pay for it). This gets us:
+*   - Both jsonc and TOML support for free.
+*   - Wrangler's own validation diagnostics (clearer errors than ours).
+*   - Path normalization: relative paths in fields like `containers[].image`
+*     are resolved to absolute paths against the user's config dir before
+*     we merge. This is critical because we write the merged config to
+*     `dist/wrangler.jsonc` — wrangler resolves relative paths against the
+*     config file's own directory, so without normalization a user's
+*     `containers[].image: "./Dockerfile"` would resolve to `dist/Dockerfile`
+*     after the move and fail to deploy.
+*
+* Flue still owns merge semantics (DO binding de-dup by `name`, migration
+* append-if-tag-absent) and Flue-specific validation (compat date floor,
+* required compat flags) — wrangler doesn't know about those.
 */
 /** Minimum compatibility_date Flue supports. */
-const MIN_COMPATIBILITY_DATE = "2024-04-03";
+const MIN_COMPATIBILITY_DATE = "2026-04-01";
 /** compatibility_flag Flue requires for pi-ai's process.env-based API key lookup. */
 const REQUIRED_COMPAT_FLAG = "nodejs_compat";
 /**
-* Read the user's wrangler config from `outputDir` if present.
+* Read and normalize the user's wrangler config from `outputDir`.
+*
+* Looks for `wrangler.jsonc`, `wrangler.json`, then `wrangler.toml` (jsonc is
+* Cloudflare's recommended format for new projects, but all three work).
+* Returns an empty config if no file is present.
+*
+* Delegates parsing + normalization to wrangler via `unstable_readConfig`. This
+* is async only because wrangler is a lazy import (it's a peer dep — Flue users
+* who only target Node should not pay for resolving it). The wrangler call
+* itself is synchronous under the hood.
+*
+* The returned config has been through wrangler's `normalizeAndValidateConfig`,
+* which:
+*   - Resolves relative paths to absolute (notably `containers[].image`).
+*   - Fills in defaults (`compatibility_date` if absent, etc.).
+*   - Merges `env.*` per-environment overrides.
+*   - Throws on validation errors via wrangler's own `UserError`.
 *
-* Looks for `wrangler.jsonc` then `wrangler.json` (in that order — jsonc is the
-* recommended format). If a `wrangler.toml` is present instead, throws with a
-* clear conversion hint. Returns an empty config if no file is present.
+* The verbose / defaulted output is intentional — the cost is a slightly bigger
+* `dist/wrangler.jsonc` and the benefit is correctness without us reimplementing
+* wrangler's path-resolution logic.
 */
-function readUserWranglerConfig(outputDir) {
-	const jsoncPath = path.join(outputDir, "wrangler.jsonc");
-	const jsonPath = path.join(outputDir, "wrangler.json");
-	const tomlPath = path.join(outputDir, "wrangler.toml");
-	const foundPath = fs.existsSync(jsoncPath) ? jsoncPath : fs.existsSync(jsonPath) ? jsonPath : null;
-	if (!foundPath) {
-		if (fs.existsSync(tomlPath)) throw new Error(`[flue] Found wrangler.toml at ${tomlPath}. Flue only supports wrangler.jsonc (the format Cloudflare recommends for new projects). Convert your config to wrangler.jsonc — you can use any online TOML-to-JSON converter, or copy the fields over by hand.`);
-		return {
-			config: {},
-			path: null
-		};
+async function readUserWranglerConfig(outputDir) {
+	const candidates = [
+		"wrangler.jsonc",
+		"wrangler.json",
+		"wrangler.toml"
+	];
+	let foundPath = null;
+	for (const name of candidates) {
+		const candidate = path.join(outputDir, name);
+		if (fs.existsSync(candidate)) {
+			foundPath = candidate;
+			break;
+		}
 	}
-	const source = fs.readFileSync(foundPath, "utf-8");
-	const errors = [];
-	const parsed = parse(source, errors, { allowTrailingComma: true });
-	if (errors.length > 0) {
-		const summary = errors.slice(0, 3).map((e) => `offset ${e.offset}: error code ${e.error}`).join("; ");
-		throw new Error(`[flue] Failed to parse ${foundPath}: ${summary}. Please fix syntax errors in your wrangler config before building.`);
+	if (!foundPath) return {
+		config: {},
+		path: null
+	};
+	let wrangler;
+	try {
+		wrangler = await import("wrangler");
+	} catch (err) {
+		throw new Error(`[flue] Reading the Cloudflare wrangler config requires the "wrangler" package as a peer dependency.
+Install it in your project:
+
+  npm install --save-dev wrangler
+
+Underlying error: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	let parsed;
+	try {
+		parsed = wrangler.unstable_readConfig({ config: foundPath }, { hideWarnings: true });
+	} catch (err) {
+		throw new Error(`[flue] Failed to read ${foundPath}: ${err instanceof Error ? err.message : String(err)}`);
 	}
-	if (parsed === void 0 || parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`[flue] ${foundPath} did not contain a JSON object at the top level. A wrangler config must be an object.`);
 	return {
 		config: parsed,
 		path: foundPath
@@ -65,6 +106,14 @@ function readUserWranglerConfig(outputDir) {
 * the failure modes when these are wrong (missing nodejs_compat, old
 * compat_date) produce confusing runtime errors, and surfacing the problem at
 * build time is much friendlier.
+*
+* Together with `mergeFlueAdditions`, this enforces two invariants on every
+* Flue worker:
+*   1. `nodejs_compat` is in `compatibility_flags` (added if missing).
+*   2. `compatibility_date >= MIN_COMPATIBILITY_DATE` (defaulted if missing).
+*
+* Those invariants are what let `dev.ts` hardcode `nodejsCompatMode: 'v2'`
+* without re-deriving it from the config on every reload.
 */
 function validateUserWranglerConfig(config) {
 	if (Array.isArray(config.compatibility_flags)) {
@@ -73,7 +122,7 @@ function validateUserWranglerConfig(config) {
 	if (typeof config.compatibility_date === "string") {
 		const userDate = config.compatibility_date;
 		if (!/^\d{4}-\d{2}-\d{2}$/.test(userDate)) throw new Error(`[flue] Your wrangler config's "compatibility_date" ("${userDate}") is not in YYYY-MM-DD format.`);
-		if (userDate < MIN_COMPATIBILITY_DATE) throw new Error(`[flue] Your wrangler config's "compatibility_date" is "${userDate}". Flue requires at least "${MIN_COMPATIBILITY_DATE}" for SQLite-backed Durable Object support and nodejs_compat v2. Bump the date (set it to today unless you have a specific reason).`);
+		if (userDate < MIN_COMPATIBILITY_DATE) throw new Error(`[flue] Your wrangler config's "compatibility_date" is "${userDate}". Flue requires at least "${MIN_COMPATIBILITY_DATE}" for SQLite-backed Durable Object support, nodejs_compat v2, and AsyncLocalStorage. Bump the date (set it to today unless you have a specific reason).`);
 	}
 }
 /**
@@ -84,7 +133,7 @@ function mergeFlueAdditions(userConfig, additions) {
 	const merged = { ...userConfig };
 	merged.main = additions.main;
 	if (typeof merged.name !== "string" || merged.name.length === 0) merged.name = additions.defaultName;
-	if (typeof merged.compatibility_date !== "string") merged.compatibility_date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	if (typeof merged.compatibility_date !== "string") merged.compatibility_date = MIN_COMPATIBILITY_DATE;
 	const existingFlags = Array.isArray(merged.compatibility_flags) ? merged.compatibility_flags.filter((f) => typeof f === "string") : [];
 	if (!existingFlags.includes(REQUIRED_COMPAT_FLAG)) existingFlags.push(REQUIRED_COMPAT_FLAG);
 	merged.compatibility_flags = existingFlags;
@@ -187,9 +236,24 @@ function writeDeployRedirectIfMissing(outputDir) {
 
 //#endregion
 //#region src/build-plugin-cloudflare.ts
+/** Cloudflare build plugin. Produces a Worker + DO entry point with SSE/webhook/sync modes. */
 var CloudflarePlugin = class {
 	name = "cloudflare";
-	generateEntryPoint(ctx) {
+	bundle = "none";
+	entryFilename = "_entry.ts";
+	/**
+	* Per-build cache of the user's wrangler config. Both `generateEntryPoint`
+	* and `additionalOutputs` need it (for sandbox detection + the merge), and
+	* a fresh `CloudflarePlugin` instance is constructed for each build (see
+	* `resolvePlugin` in build.ts), so the cache is implicitly scoped to a
+	* single build.
+	*/
+	userConfigCache;
+	async getUserConfig(outputDir) {
+		if (!this.userConfigCache) this.userConfigCache = await readUserWranglerConfig(outputDir);
+		return this.userConfigCache;
+	}
+	async generateEntryPoint(ctx) {
 		const { agents, roles } = ctx;
 		const rolesJson = JSON.stringify(roles);
 		const webhookAgents = agents.filter((a) => a.triggers.webhook);
@@ -207,16 +271,29 @@ var CloudflarePlugin = class {
   async onRequest(request) {
     return handleAgentRequest(request, this, ${JSON.stringify(a.name)}, ${handlerVar});
   }
+
+  async onFiberRecovered(ctx) {
+    if (ctx.name?.startsWith('flue:')) {
+      return handleFlueFiberRecovered(ctx, this, ${JSON.stringify(a.name)});
+    }
+    if (typeof super.onFiberRecovered === 'function') {
+      return super.onFiberRecovered(ctx);
+    }
+  }
 }`;
 		}).join("\n\n");
-		const { config: userConfig } = readUserWranglerConfig(ctx.outputDir);
+		const { config: userConfig } = await this.getUserConfig(ctx.outputDir);
 		return `
 // Auto-generated by @flue/sdk build (cloudflare)
 import { Agent, routeAgentRequest } from 'agents';
 import { Bash, InMemoryFs } from 'just-bash';
-import { getModel } from '@mariozechner/pi-ai';
-import { createFlueContext, InMemorySessionStore, bashToSessionEnv } from '@flue/sdk/internal';
-import { setCloudflareContext, clearCloudflareContext, cfSandboxToSessionEnv } from '@flue/sdk/cloudflare';
+import {
+  createFlueContext,
+  InMemorySessionStore,
+  bashFactoryToSessionEnv,
+  resolveModel,
+} from '@flue/sdk/internal';
+import { runWithCloudflareContext, cfSandboxToSessionEnv } from '@flue/sdk/cloudflare';
 
 ${agentImports}
 
@@ -230,42 +307,21 @@ const manifest = ${manifest};
 // ─── Infrastructure ─────────────────────────────────────────────────────────
 
 // No build-time model default. The user sets model at runtime via
-// \`init({ model: "provider/model-id" })\` for a session default, or via
+// \`init({ model: "provider/model-id" })\` for an agent default, or via
 // \`{ model: "provider/model-id" }\` on any individual prompt/skill/task call.
 const model = undefined;
 
-function resolveModel(modelString) {
-  const slash = modelString.indexOf('/');
-  if (slash === -1) {
-    throw new Error(
-      '[flue] Invalid model "' + modelString + '". ' +
-      'Use the "provider/model-id" format (e.g. "anthropic/claude-haiku-4-5").'
-    );
-  }
-  const provider = modelString.slice(0, slash);
-  const modelId = modelString.slice(slash + 1);
-  const resolved = getModel(provider, modelId);
-  if (!resolved) {
-    throw new Error(
-      '[flue] Unknown model "' + modelString + '". ' +
-      'Provider "' + provider + '" / model id "' + modelId + '" ' +
-      'is not registered with @mariozechner/pi-ai.'
-    );
-  }
-  return resolved;
-}
-
 // ─── Sandbox Environments ───────────────────────────────────────────────────
 
 /**
  * Create an empty in-memory sandbox (default).
  */
 async function createDefaultEnv() {
-  const bash = new Bash({
-    fs: new InMemoryFs(),
+  const fs = new InMemoryFs();
+  return bashFactoryToSessionEnv(() => new Bash({
+    fs,
     network: { dangerouslyAllowFullInternetAccess: true },
-  });
-  return bashToSessionEnv(bash);
+  }));
 }
 
 /**
@@ -274,7 +330,7 @@ async function createDefaultEnv() {
 async function createLocalEnv() {
   throw new Error(
     "[flue] 'local' sandbox is not supported on Cloudflare Workers. " +
-    "Use the default empty sandbox, pass a custom Bash instance, " +
+    "Use the default empty sandbox, pass a BashFactory, " +
     "or pass a sandbox instance (from any SDK — e.g. @cloudflare/sandbox " +
     "or a Flue connector) to init({ sandbox })."
   );
@@ -326,14 +382,14 @@ function createDOStore(sql) {
   };
 }
 
-function createContextForRequest(sessionId, payload, doInstance) {
+function createContextForRequest(id, payload, doInstance) {
   // Use DO SQLite storage by default, fall back to in-memory
   const defaultStore = doInstance?.ctx?.storage?.sql
     ? createDOStore(doInstance.ctx.storage.sql)
     : memoryStore;
 
   return createFlueContext({
-    sessionId,
+    id,
     payload,
     env: doInstance?.env ?? {},
     agentConfig: {
@@ -346,11 +402,66 @@ function createContextForRequest(sessionId, payload, doInstance) {
   });
 }
 
+function runWithInstanceContext(doInstance, fn) {
+  return runWithCloudflareContext(
+    { env: doInstance.env, agentInstance: doInstance, storage: doInstance.ctx.storage },
+    fn,
+  );
+}
+
+function assertAgentsDurabilityApi(doInstance, method) {
+  if (typeof doInstance[method] !== 'function') {
+		throw new Error(
+			'[flue] The installed "agents" package does not provide the required Cloudflare Agents SDK method "' +
+				method +
+				'". Install or upgrade the "agents" package in your project.',
+		);
+	}
+}
+
+function runHandlerWithKeepAlive(doInstance, ctx, handler) {
+  return runWithInstanceContext(doInstance, () => {
+    assertAgentsDurabilityApi(doInstance, 'keepAliveWhile');
+    return doInstance.keepAliveWhile(() => handler(ctx));
+  });
+}
+
+function startWebhookFiber(doInstance, requestId, agentName, id, payload, handler) {
+  const run = async (fiber) => {
+    fiber?.stash?.({
+      version: 1,
+      kind: 'webhook',
+      agentName,
+      id,
+      requestId,
+      phase: 'running',
+      startedAt: Date.now(),
+    });
+
+    const ctx = createContextForRequest(id, payload, doInstance);
+    return runWithInstanceContext(doInstance, async () => {
+      try {
+        return await handler(ctx);
+      } finally {
+        ctx.setEventCallback(undefined);
+      }
+    });
+  };
+
+  assertAgentsDurabilityApi(doInstance, 'runFiber');
+  return doInstance.runFiber('flue:webhook:' + requestId, run);
+}
+
+async function handleFlueFiberRecovered(ctx, _doInstance, agentName) {
+  if (!ctx.name || !ctx.name.startsWith('flue:')) return;
+  console.warn('[flue] Cloudflare fiber interrupted:', agentName, ctx.name, ctx.snapshot ?? null);
+}
+
 // ─── Shared Request Handler ────────────────────────────────────────────────
 
 async function handleAgentRequest(request, doInstance, agentName, handler) {
-  // Session ID is the DO "room name" set by routeAgentRequest
-  const sessionId = doInstance.name;
+  // Agent id is the DO "room name" set by routeAgentRequest
+  const id = doInstance.name;
 
   // Parse payload
   let payload;
@@ -360,9 +471,6 @@ async function handleAgentRequest(request, doInstance, agentName, handler) {
     payload = {};
   }
 
-  // Set up Cloudflare context for runtime primitives
-  setCloudflareContext({ env: doInstance.env, agentInstance: doInstance, storage: doInstance.ctx.storage });
-
   const accept = request.headers.get('accept') || '';
   const isWebhook = request.headers.get('x-webhook') === 'true';
   const isSSE = accept.includes('text/event-stream') && !isWebhook;
@@ -371,17 +479,12 @@ async function handleAgentRequest(request, doInstance, agentName, handler) {
     // Fire-and-forget (webhook mode)
     if (isWebhook) {
       const requestId = crypto.randomUUID();
-      const ctx = createContextForRequest(sessionId, payload, doInstance);
-      handler(ctx).then(
+      startWebhookFiber(doInstance, requestId, agentName, id, payload, handler).then(
         (result) => {
-          ctx.setEventCallback(undefined);
-          clearCloudflareContext();
           console.log('[flue] Webhook handler complete:', agentName,
             result !== undefined ? JSON.stringify(result) : '(no return)');
         },
         (err) => {
-          ctx.setEventCallback(undefined);
-          clearCloudflareContext();
           console.error('[flue] Webhook handler error:', agentName, err);
         },
       );
@@ -397,6 +500,7 @@ async function handleAgentRequest(request, doInstance, agentName, handler) {
       const writer = writable.getWriter();
       const encoder = new TextEncoder();
       let eventId = 0;
+      let isIdle = false;
 
       const writeSSE = async (data, event) => {
         const lines = [];
@@ -407,14 +511,18 @@ async function handleAgentRequest(request, doInstance, agentName, handler) {
         await writer.write(encoder.encode(lines.join('\\n')));
       };
 
-      const ctx = createContextForRequest(sessionId, payload, doInstance);
+      const ctx = createContextForRequest(id, payload, doInstance);
       ctx.setEventCallback((event) => {
+        if (event.type === 'idle') isIdle = true;
         writeSSE(event, event.type).catch(() => {});
       });
 
       (async () => {
         try {
-          const result = await handler(ctx);
+          const result = await runHandlerWithKeepAlive(doInstance, ctx, handler);
+          if (!isIdle) {
+            await writeSSE({ type: 'idle' }, 'idle');
+          }
           await writeSSE(
             { type: 'result', data: result !== undefined ? result : null },
             'result',
@@ -424,9 +532,11 @@ async function handleAgentRequest(request, doInstance, agentName, handler) {
             { type: 'error', error: String(err) },
             'error',
           );
+          if (!isIdle) {
+            await writeSSE({ type: 'idle' }, 'idle');
+          }
         } finally {
           ctx.setEventCallback(undefined);
-          clearCloudflareContext();
           await writer.close();
         }
       })();
@@ -441,16 +551,17 @@ async function handleAgentRequest(request, doInstance, agentName, handler) {
     }
 
     // Sync mode (default)
-    const ctx = createContextForRequest(sessionId, payload, doInstance);
-    const result = await handler(ctx);
-    ctx.setEventCallback(undefined);
-    clearCloudflareContext();
-    return new Response(
-      JSON.stringify({ result: result !== undefined ? result : null }),
-      { headers: { 'content-type': 'application/json' } },
-    );
+    const ctx = createContextForRequest(id, payload, doInstance);
+    try {
+      const result = await runHandlerWithKeepAlive(doInstance, ctx, handler);
+      return new Response(
+        JSON.stringify({ result: result !== undefined ? result : null }),
+        { headers: { 'content-type': 'application/json' } },
+      );
+    } finally {
+      ctx.setEventCallback(undefined);
+    }
   } catch (err) {
-    clearCloudflareContext();
     console.error('[flue] Agent error:', agentName, err);
     return new Response(
       JSON.stringify({ error: String(err) }),
@@ -492,7 +603,7 @@ export default {
     }
 
     // Route to per-agent DOs via the Agents SDK
-    // URL: /agents/<agent-name>/<session-id>
+    // URL: /agents/<agent-name>/<id>
     const response = await routeAgentRequest(request, env);
     if (response) return response;
 
@@ -501,18 +612,7 @@ export default {
 };
 `;
 	}
-	esbuildOptions(_ctx) {
-		return {
-			target: "esnext",
-			external: [
-				"node:*",
-				"cloudflare:*",
-				"node-liblzma",
-				"@mongodb-js/zstd"
-			]
-		};
-	}
-	additionalOutputs(ctx) {
+	async additionalOutputs(ctx) {
 		const outputs = {};
 		const flueBindings = ctx.agents.filter((a) => a.triggers.webhook).map((a) => ({
 			class_name: agentClassName(a.name),
@@ -520,15 +620,15 @@ export default {
 		}));
 		const flueSqliteClasses = flueBindings.map((b) => b.class_name);
 		const additions = {
-			defaultName: ctx.outputDir.split("/").pop() ?? "flue-agents",
-			main: "server.mjs",
+			defaultName: path.basename(ctx.outputDir) || "flue-agents",
+			main: "_entry.ts",
 			doBindings: flueBindings,
 			migration: {
 				tag: "flue-v1",
 				new_sqlite_classes: flueSqliteClasses
 			}
 		};
-		const { config: userConfig, path: userConfigPath } = readUserWranglerConfig(ctx.outputDir);
+		const { config: userConfig, path: userConfigPath } = await this.getUserConfig(ctx.outputDir);
 		if (userConfigPath) console.log(`[flue] Merging with user wrangler config: ${userConfigPath}`);
 		validateUserWranglerConfig(userConfig);
 		const sandboxClassNames = detectSandboxBindings(userConfig);
@@ -561,6 +661,7 @@ function agentClassName(name) {
 //#region src/build-plugin-node.ts
 var NodePlugin = class {
 	name = "node";
+	bundle = "esbuild";
 	generateEntryPoint(ctx) {
 		const { agents, roles } = ctx;
 		const rolesJson = JSON.stringify(roles);
@@ -571,8 +672,12 @@ import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import { serve } from '@hono/node-server';
 import { Bash, InMemoryFs, MountableFs, ReadWriteFs } from 'just-bash';
-import { getModel } from '@mariozechner/pi-ai';
-import { createFlueContext, InMemorySessionStore, bashToSessionEnv } from '@flue/sdk/internal';
+import {
+  createFlueContext,
+  InMemorySessionStore,
+  bashFactoryToSessionEnv,
+  resolveModel,
+} from '@flue/sdk/internal';
 import { randomUUID } from 'node:crypto';
 
 ${agents.map((a) => {
@@ -606,31 +711,10 @@ const manifest = ${JSON.stringify({ agents: agents.map((a) => ({
 // ─── Infrastructure ─────────────────────────────────────────────────────────
 
 // No build-time model default. The user sets model at runtime via
-// \`init({ model: "provider/model-id" })\` for a session default, or via
+// \`init({ model: "provider/model-id" })\` for an agent default, or via
 // \`{ model: "provider/model-id" }\` on any individual prompt/skill/task call.
 const model = undefined;
 
-function resolveModel(modelString) {
-  const slash = modelString.indexOf('/');
-  if (slash === -1) {
-    throw new Error(
-      '[flue] Invalid model "' + modelString + '". ' +
-      'Use the "provider/model-id" format (e.g. "anthropic/claude-haiku-4-5").'
-    );
-  }
-  const provider = modelString.slice(0, slash);
-  const modelId = modelString.slice(slash + 1);
-  const resolved = getModel(provider, modelId);
-  if (!resolved) {
-    throw new Error(
-      '[flue] Unknown model "' + modelString + '". ' +
-      'Provider "' + provider + '" / model id "' + modelId + '" ' +
-      'is not registered with @mariozechner/pi-ai.'
-    );
-  }
-  return resolved;
-}
-
 // ─── Sandbox Environments ───────────────────────────────────────────────────
 
 /**
@@ -639,11 +723,11 @@ function resolveModel(modelString) {
  * cwd = /home/user, /tmp exists, /bin and /usr/bin exist.
  */
 async function createDefaultEnv() {
-  const bash = new Bash({
-    fs: new InMemoryFs(),
+  const fs = new InMemoryFs();
+  return bashFactoryToSessionEnv(() => new Bash({
+    fs,
     network: { dangerouslyAllowFullInternetAccess: true },
-  });
-  return bashToSessionEnv(bash);
+  }));
 }
 
 /**
@@ -654,20 +738,19 @@ async function createLocalEnv() {
   const rwfs = new ReadWriteFs({ root: process.cwd() });
   const fs = new MountableFs({ base: new InMemoryFs() });
   fs.mount('/workspace', rwfs);
-  const bash = new Bash({
+  return bashFactoryToSessionEnv(() => new Bash({
     fs,
     cwd: '/workspace',
     network: { dangerouslyAllowFullInternetAccess: true },
-  });
-  return bashToSessionEnv(bash);
+  }));
 }
 
 // Default persistence store for Node — in-memory, process lifetime.
 const defaultStore = new InMemorySessionStore();
 
-function createContextForRequest(sessionId, payload) {
+function createContextForRequest(id, payload) {
   return createFlueContext({
-    sessionId,
+    id,
     payload,
     env: process.env,
     agentConfig: {
@@ -686,16 +769,16 @@ const app = new Hono();
 app.get('/health', (c) => c.json({ status: 'ok' }));
 app.get('/agents', (c) => c.json(manifest));
 
-// Session ID is required in the URL
+// Agent id is required in the URL
 app.post('/agents/:name', (c) => {
   return c.json({
-    error: 'Session ID is required. Use /agents/:name/:sessionId',
+    error: 'Agent id is required. Use /agents/:name/:id',
   }, 400);
 });
 
-app.post('/agents/:name/:sessionId', async (c) => {
+app.post('/agents/:name/:id', async (c) => {
   const name = c.req.param('name');
-  const sessionId = c.req.param('sessionId');
+  const id = c.req.param('id');
 
   if (!handlers[name]) {
     return c.json({ error: 'Agent not found' }, 404);
@@ -719,7 +802,7 @@ app.post('/agents/:name/:sessionId', async (c) => {
   // Fire-and-forget (webhook mode)
   if (isWebhook) {
     const requestId = randomUUID();
-    const ctx = createContextForRequest(sessionId, payload);
+    const ctx = createContextForRequest(id, payload);
     handler(ctx).then(
       (result) => {
         ctx.setEventCallback(undefined);
@@ -737,13 +820,19 @@ app.post('/agents/:name/:sessionId', async (c) => {
   if (isSSE) {
     return streamSSE(c, async (stream) => {
       let eventId = 0;
-      const ctx = createContextForRequest(sessionId, payload);
+      let isIdle = false;
+      const ctx = createContextForRequest(id, payload);
       ctx.setEventCallback((event) => {
+        if (event.type === 'idle') isIdle = true;
         stream.writeSSE({ data: JSON.stringify(event), event: event.type, id: String(eventId++) }).catch(() => {});
       });
 
       try {
         const result = await handler(ctx);
+        if (!isIdle) {
+          const idle = { type: 'idle' };
+          await stream.writeSSE({ data: JSON.stringify(idle), event: 'idle', id: String(eventId++) });
+        }
         await stream.writeSSE({
           data: JSON.stringify({ type: 'result', data: result !== undefined ? result : null }),
           event: 'result',
@@ -755,6 +844,10 @@ app.post('/agents/:name/:sessionId', async (c) => {
           event: 'error',
           id: String(eventId++),
         });
+        if (!isIdle) {
+          const idle = { type: 'idle' };
+          await stream.writeSSE({ data: JSON.stringify(idle), event: 'idle', id: String(eventId++) });
+        }
       } finally {
         ctx.setEventCallback(undefined);
       }
@@ -763,7 +856,7 @@ app.post('/agents/:name/:sessionId', async (c) => {
 
   // Sync mode (default)
   try {
-    const ctx = createContextForRequest(sessionId, payload);
+    const ctx = createContextForRequest(id, payload);
     const result = await handler(ctx);
     ctx.setEventCallback(undefined);
     return c.json({ result: result !== undefined ? result : null });
@@ -849,46 +942,63 @@ async function build(options) {
 		outputDir,
 		options
 	};
-	const serverCode = plugin.generateEntryPoint(ctx);
-	const entryPath = path.join(distDir, "_entry_server.ts");
-	const outPath = path.join(distDir, "server.mjs");
-	fs.writeFileSync(entryPath, serverCode, "utf-8");
-	try {
-		const nodePathsSet = collectNodePaths(workspaceDir);
-		const { external: pluginExternal = [], ...pluginEsbuildOpts } = plugin.esbuildOptions(ctx);
-		const userExternals = getUserExternals(workspaceDir);
-		await esbuild.build({
-			entryPoints: [entryPath],
-			bundle: true,
-			outfile: outPath,
-			format: "esm",
-			external: [...pluginExternal, ...userExternals],
-			nodePaths: [...nodePathsSet],
-			logLevel: "warning",
-			loader: {
-				".ts": "ts",
-				".node": "empty"
-			},
-			treeShaking: true,
-			sourcemap: true,
-			...pluginEsbuildOpts
-		});
-		console.log(`[flue] Built: ${outPath}`);
-	} finally {
+	const serverCode = await plugin.generateEntryPoint(ctx);
+	const bundleStrategy = plugin.bundle ?? "esbuild";
+	let anyChanged = false;
+	if (bundleStrategy === "esbuild") {
+		const entryPath = path.join(distDir, "_entry_server.ts");
+		const outPath = path.join(distDir, "server.mjs");
+		fs.writeFileSync(entryPath, serverCode, "utf-8");
 		try {
-			fs.unlinkSync(entryPath);
-		} catch {}
-	}
+			const nodePathsSet = collectNodePaths(workspaceDir);
+			const { external: pluginExternal = [], ...pluginEsbuildOpts } = plugin.esbuildOptions ? plugin.esbuildOptions(ctx) : {};
+			const userExternals = getUserExternals(workspaceDir);
+			await esbuild.build({
+				entryPoints: [entryPath],
+				bundle: true,
+				outfile: outPath,
+				format: "esm",
+				external: [...pluginExternal, ...userExternals],
+				nodePaths: [...nodePathsSet],
+				logLevel: "warning",
+				loader: {
+					".ts": "ts",
+					".node": "empty"
+				},
+				treeShaking: true,
+				sourcemap: true,
+				...pluginEsbuildOpts
+			});
+			console.log(`[flue] Built: ${outPath}`);
+			anyChanged = true;
+		} finally {
+			try {
+				fs.unlinkSync(entryPath);
+			} catch {}
+		}
+	} else if (bundleStrategy === "none") {
+		if (!plugin.entryFilename) throw new Error(`[flue] Plugin "${plugin.name}" set bundle: 'none' but did not provide entryFilename.`);
+		const outPath = path.join(distDir, plugin.entryFilename);
+		if (!fs.existsSync(outPath) || fs.readFileSync(outPath, "utf-8") !== serverCode) {
+			fs.writeFileSync(outPath, serverCode, "utf-8");
+			console.log(`[flue] Wrote entry: ${outPath} (no bundle — downstream tool handles it)`);
+			anyChanged = true;
+		} else console.log(`[flue] Entry unchanged: ${outPath}`);
+	} else throw new Error(`[flue] Unknown bundle strategy: ${bundleStrategy}`);
 	if (plugin.additionalOutputs) {
-		const outputs = plugin.additionalOutputs(ctx);
+		const outputs = await plugin.additionalOutputs(ctx);
 		for (const [filename, content] of Object.entries(outputs)) {
 			const filePath = path.join(distDir, filename);
 			fs.mkdirSync(path.dirname(filePath), { recursive: true });
-			fs.writeFileSync(filePath, content, "utf-8");
-			console.log(`[flue] Generated: ${filePath}`);
+			if (!fs.existsSync(filePath) || fs.readFileSync(filePath, "utf-8") !== content) {
+				fs.writeFileSync(filePath, content, "utf-8");
+				console.log(`[flue] Generated: ${filePath}`);
+				anyChanged = true;
+			}
 		}
 	}
 	console.log(`[flue] Build complete. Output: ${distDir}`);
+	return { changed: anyChanged };
 }
 function resolvePlugin(options) {
 	if (options.plugin) return options.plugin;
@@ -998,4 +1108,461 @@ function getSDKDir() {
 }
 
 //#endregion
-export { BUILTIN_TOOL_NAMES, build, createTools, resolveWorkspaceFromCwd };
+//#region src/dev.ts
+/**
+* Flue dev server.
+*
+* Watches the user's workspace, rebuilds on file changes, and reloads the
+* underlying server. Distinct from `flue run`: dev is the long-running,
+* edit-and-iterate command, while `flue run` is the one-shot
+* production-style invoker (build → run → exit).
+*
+* # Two very different reload models
+*
+* Node and Cloudflare use fundamentally different rebuild strategies, because
+* what they each provide downstream is fundamentally different:
+*
+* - **Node** has no host bundler. Our esbuild pass produces the final
+*   `dist/server.mjs`. On any change in the workspace we rebuild and respawn
+*   the child Node process. Sub-second restart is fine.
+*
+* - **Cloudflare** uses Wrangler's bundler (the same one `wrangler dev` and
+*   `wrangler deploy` use). Wrangler watches the entry's transitive import
+*   graph itself and reloads workerd on source edits. So we *don't* need to
+*   rebuild for body edits — wrangler handles it. We only need to act when:
+*     1. The set of agents changes (added / removed / triggers changed) →
+*        regenerate `dist/_entry.ts`. Wrangler picks up the new entry
+*        automatically because it's already watching it.
+*     2. The user's `wrangler.jsonc` changes → re-merge our additions and
+*        restart the worker (config changes don't hot-apply).
+*   Pure body edits to agent files: wrangler reloads workerd; we do nothing.
+*
+* # Watching
+*
+* Watching uses `node:fs.watch` recursive (Node 20+). Debounced 150ms. The
+* Node path treats every non-ignored change as a rebuild trigger; the
+* Cloudflare path filters to "structural" changes only.
+*/
+/** Default port for `flue dev`. F=3, L=5, U=8, E=3 on a phone keypad. */
+const DEFAULT_DEV_PORT = 3583;
+/**
+* Start a Flue dev server. Resolves only when the server is shut down (e.g.
+* via SIGINT). Errors during the initial build/start are thrown synchronously;
+* errors during subsequent rebuilds are logged but do NOT exit the dev server
+* — the user is editing code, after all, and we want to recover when they fix it.
+*/
+async function dev(options) {
+	const workspaceDir = path.resolve(options.workspaceDir);
+	const outputDir = path.resolve(options.outputDir);
+	const port = options.port ?? DEFAULT_DEV_PORT;
+	const buildOptions = {
+		workspaceDir,
+		outputDir,
+		target: options.target
+	};
+	console.error(`[flue] Starting dev server (target: ${options.target})`);
+	console.error(`[flue] Watching: ${workspaceDir}`);
+	console.error(`[flue] Building...`);
+	const initialStart = Date.now();
+	try {
+		await build(buildOptions);
+	} catch (err) {
+		throw new Error(`[flue] Initial build failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	console.error(`[flue] Built in ${Date.now() - initialStart}ms`);
+	const reloader = options.target === "node" ? new NodeReloader({
+		outputDir,
+		port
+	}) : await createCloudflareReloader({
+		outputDir,
+		port
+	});
+	await reloader.start();
+	if (reloader.url) {
+		console.error(`[flue] Server: ${reloader.url}`);
+		const exampleAgent = pickExampleAgentName(outputDir, workspaceDir);
+		if (exampleAgent) {
+			console.error(`[flue] Try: curl -X POST ${reloader.url}/agents/${exampleAgent}/test-1 \\`);
+			console.error(`         -H 'Content-Type: application/json' -d '{}'`);
+		}
+	}
+	console.error(`[flue] Press Ctrl+C to stop\n`);
+	const rebuilder = createRebuilder(buildOptions, reloader);
+	const watcher = createWatcher({
+		workspaceDir,
+		outputDir,
+		target: options.target,
+		onChange: (relPath) => {
+			if (!reloader.shouldRebuildOn(relPath)) return;
+			console.error(`[flue] Change detected: ${relPath}`);
+			rebuilder.schedule();
+		}
+	});
+	let shuttingDown = false;
+	const shutdown = async (signal, exitCode) => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		console.error(`\n[flue] Received ${signal}, shutting down...`);
+		watcher.close();
+		try {
+			await reloader.stop();
+		} catch (err) {
+			console.error(`[flue] Error during shutdown: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		console.error(`[flue] Stopped.`);
+		process.exit(exitCode);
+	};
+	process.on("SIGINT", () => void shutdown("SIGINT", 130));
+	process.on("SIGTERM", () => void shutdown("SIGTERM", 143));
+	process.on("exit", () => {
+		try {
+			reloader.killSync?.();
+		} catch {}
+	});
+	await new Promise(() => {});
+}
+function createRebuilder(buildOptions, reloader) {
+	let running = false;
+	let queued = false;
+	let debounceTimer = null;
+	const runOnce = async () => {
+		running = true;
+		const start = Date.now();
+		console.error(`[flue] Rebuilding...`);
+		try {
+			const { changed } = await build(buildOptions);
+			await reloader.reload(changed);
+			console.error(`[flue] Reloaded in ${Date.now() - start}ms\n`);
+		} catch (err) {
+			console.error(`[flue] Rebuild failed: ${err instanceof Error ? err.message : String(err)}\n`);
+		} finally {
+			running = false;
+			if (queued) {
+				queued = false;
+				runOnce();
+			}
+		}
+	};
+	return { schedule() {
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			debounceTimer = null;
+			if (running) queued = true;
+			else runOnce();
+		}, 150);
+	} };
+}
+/**
+* Watch the workspace for changes. Uses `fs.watch` recursive (Node 20+).
+*
+* Watched roots:
+*   - `<workspaceDir>` — agents/, roles/, AGENTS.md, .agents/skills/.
+*   - For Cloudflare: also `<outputDir>/wrangler.jsonc` (and `.json`),
+*     since changes there require a worker restart.
+*
+* Ignored:
+*   - `dist/`, `node_modules/`, `.git/`, `.turbo/`
+*   - dotfiles other than the ones we explicitly care about (AGENTS.md is
+*     not a dotfile, so it's fine)
+*   - editor backup/swap suffixes
+*/
+function createWatcher(options) {
+	const { workspaceDir, outputDir, target, onChange } = options;
+	const watchers = [];
+	const isIgnoredPath = (relPath) => {
+		const parts = relPath.replace(/\\/g, "/").split("/");
+		for (const part of parts) {
+			if (part === "node_modules") return true;
+			if (part === "dist") return true;
+			if (part === ".git") return true;
+			if (part === ".turbo") return true;
+		}
+		const base = parts[parts.length - 1] ?? "";
+		if (!base) return true;
+		if (base.startsWith(".") && base !== ".flueignore") return true;
+		if (base.endsWith("~") || base.endsWith(".swp") || base.endsWith(".swx")) return true;
+		if (base === ".DS_Store") return true;
+		return false;
+	};
+	try {
+		const w = fs.watch(workspaceDir, { recursive: true }, (_event, filename) => {
+			if (!filename) return;
+			const rel = filename.toString();
+			if (isIgnoredPath(rel)) return;
+			onChange(rel);
+		});
+		watchers.push(w);
+	} catch (err) {
+		console.error(`[flue] Failed to watch ${workspaceDir}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (target === "cloudflare") for (const cfgName of [
+		"wrangler.jsonc",
+		"wrangler.json",
+		"wrangler.toml"
+	]) {
+		const cfgPath = path.join(outputDir, cfgName);
+		if (!fs.existsSync(cfgPath)) continue;
+		try {
+			const w = fs.watch(cfgPath, () => onChange(cfgName));
+			watchers.push(w);
+		} catch {}
+	}
+	return { close() {
+		for (const w of watchers) try {
+			w.close();
+		} catch {}
+	} };
+}
+var NodeReloader = class {
+	child = null;
+	serverPath;
+	outputDir;
+	port;
+	url;
+	constructor(opts) {
+		this.outputDir = opts.outputDir;
+		this.port = opts.port;
+		this.serverPath = path.join(this.outputDir, "dist", "server.mjs");
+		this.url = `http://localhost:${this.port}`;
+	}
+	async start() {
+		await this.spawnAndWait();
+	}
+	shouldRebuildOn(_relPath) {
+		return true;
+	}
+	async reload(_buildChanged) {
+		await this.killChild();
+		await this.spawnAndWait();
+	}
+	async stop() {
+		await this.killChild();
+	}
+	killSync() {
+		const child = this.child;
+		if (!child || child.killed) return;
+		try {
+			child.kill("SIGKILL");
+		} catch {}
+	}
+	async spawnAndWait() {
+		const child = spawn("node", [this.serverPath], {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			cwd: this.outputDir,
+			env: {
+				...process.env,
+				PORT: String(this.port),
+				FLUE_MODE: "local"
+			}
+		});
+		this.child = child;
+		const pipe = (data) => {
+			const text = data.toString().trimEnd();
+			for (const line of text.split("\n")) {
+				if (!line.trim()) continue;
+				if (line.includes("[flue] Server listening") || line.includes("[flue] Available agents:") || line.includes("[flue] Mode: local")) continue;
+				console.error(line);
+			}
+		};
+		child.stdout?.on("data", pipe);
+		child.stderr?.on("data", pipe);
+		child.on("exit", (code, signal) => {
+			if (this.child === child) {
+				this.child = null;
+				if (code !== 0 && code !== null) console.error(`[flue] Node server exited unexpectedly (code=${code}, signal=${signal ?? "none"})`);
+			}
+		});
+		if (!await waitForHealth(this.url, 15e3)) {
+			await this.killChild();
+			throw new Error("Node server did not become ready within 15s");
+		}
+	}
+	async killChild() {
+		const child = this.child;
+		if (!child || child.killed) {
+			this.child = null;
+			return;
+		}
+		this.child = null;
+		await new Promise((resolve) => {
+			let resolved = false;
+			const done = () => {
+				if (!resolved) {
+					resolved = true;
+					resolve();
+				}
+			};
+			child.once("exit", done);
+			try {
+				child.kill("SIGTERM");
+			} catch {
+				done();
+				return;
+			}
+			setTimeout(() => {
+				try {
+					if (!child.killed) child.kill("SIGKILL");
+				} catch {}
+				done();
+			}, 1e3);
+		});
+	}
+};
+/**
+* Lazy-import wrangler so users targeting only Node don't need it installed.
+* If the import fails, surface a friendly message pointing at the peer-dep.
+*/
+async function createCloudflareReloader(opts) {
+	let wrangler;
+	try {
+		wrangler = await import("wrangler");
+	} catch (err) {
+		throw new Error(`[flue] Cloudflare dev requires the "wrangler" package as a peer dependency.
+Install it in your project:
+
+  npm install --save-dev wrangler
+
+Underlying error: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	return new CloudflareReloader(wrangler, opts);
+}
+var CloudflareReloader = class {
+	worker = null;
+	wrangler;
+	outputDir;
+	port;
+	configPath;
+	url;
+	constructor(wrangler, opts) {
+		this.wrangler = wrangler;
+		this.outputDir = opts.outputDir;
+		this.port = opts.port;
+		this.configPath = path.join(this.outputDir, "dist", "wrangler.jsonc");
+	}
+	async start() {
+		await this.startWorker();
+	}
+	/**
+	* On Cloudflare, wrangler watches the entry's transitive imports itself
+	* and hot-reloads workerd when an agent file body changes. We only need
+	* to act when something *structural* changes — i.e. something that
+	* affects what `_entry.ts` or `wrangler.jsonc` look like.
+	*
+	* Concretely, we trigger a Flue-side rebuild for:
+	*   - File adds/removes in `agents/` (the agent set determines DO classes
+	*     and binding declarations).
+	*   - Changes to `agents/*.ts` — these MAY change the exported `triggers`,
+	*     so we have to re-parse them. (Plain body edits redo a tiny amount
+	*     of work but the rebuild is cheap and idempotent.)
+	*   - Changes to `roles/*.md` — roles are baked into the entry as JSON.
+	*   - Changes to the user's `wrangler.jsonc` — affects the merged config.
+	*
+	* Notes we explicitly DO ignore for rebuild purposes (wrangler handles
+	* them): edits to imported source files outside of `agents/`/`roles/`,
+	* AGENTS.md, and `.agents/skills/` (those are runtime-discovered, not
+	* baked into the entry).
+	*/
+	shouldRebuildOn(relPath) {
+		const normalized = relPath.replace(/\\/g, "/");
+		if (normalized === "wrangler.jsonc" || normalized === "wrangler.json" || normalized === "wrangler.toml") return true;
+		if (normalized.startsWith("agents/")) return true;
+		if (normalized.startsWith("roles/")) return true;
+		return false;
+	}
+	async reload(buildChanged) {
+		if (!buildChanged) {
+			console.error(`[flue] No structural change — wrangler will hot-reload\n`);
+			return;
+		}
+		await this.disposeWorker();
+		await this.startWorker();
+	}
+	async stop() {
+		await this.disposeWorker();
+	}
+	killSync() {
+		this.worker = null;
+	}
+	async startWorker() {
+		if (!fs.existsSync(this.configPath)) throw new Error(`[flue] Expected ${this.configPath} after build, but it doesn't exist. Did the Cloudflare build succeed?`);
+		this.worker = await this.wrangler.unstable_startWorker({
+			config: this.configPath,
+			build: { nodejsCompatMode: "v2" },
+			dev: {
+				server: {
+					hostname: "localhost",
+					port: this.port
+				},
+				watch: false,
+				logLevel: "info"
+			}
+		});
+		try {
+			this.url = (await this.worker.url).toString().replace(/\/$/, "");
+		} catch {
+			this.url = `http://127.0.0.1:${this.port}`;
+		}
+	}
+	async disposeWorker() {
+		const worker = this.worker;
+		this.worker = null;
+		if (!worker) return;
+		try {
+			await worker.dispose();
+		} catch (err) {
+			console.error(`[flue] Error disposing Cloudflare worker: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+};
+async function waitForHealth(baseUrl, timeoutMs) {
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) {
+		try {
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), 1e3);
+			const res = await fetch(`${baseUrl}/health`, { signal: controller.signal });
+			clearTimeout(timeout);
+			if (res.ok) return true;
+		} catch {}
+		await new Promise((r) => setTimeout(r, 200));
+	}
+	return false;
+}
+/**
+* Pick a webhook agent name to print in the friendly curl example. Falls back
+* to any agent if none have webhook triggers (the example would 404 on the
+* dev server in that case, but it's still a hint at the URL shape). Reads the
+* manifest written by the build, with a directory-scan fallback in case the
+* manifest is somehow missing.
+*
+* Best-effort — silently returns null if anything goes wrong.
+*/
+function pickExampleAgentName(outputDir, workspaceDir) {
+	try {
+		const manifestPath = path.join(outputDir, "dist", "manifest.json");
+		if (fs.existsSync(manifestPath)) {
+			const agents = JSON.parse(fs.readFileSync(manifestPath, "utf-8")).agents ?? [];
+			const webhook = agents.find((a) => a.triggers?.webhook);
+			if (webhook) return webhook.name;
+			if (agents[0]) return agents[0].name;
+		}
+	} catch {}
+	try {
+		const agentsDir = path.join(workspaceDir, "agents");
+		if (!fs.existsSync(agentsDir)) return null;
+		for (const e of fs.readdirSync(agentsDir)) {
+			const m = e.match(/^([a-zA-Z0-9_-]+)\.(ts|js|mts|mjs)$/);
+			if (m && m[1]) return m[1];
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { BUILTIN_TOOL_NAMES, DEFAULT_DEV_PORT, build, createTools, dev, resolveWorkspaceFromCwd };