acrylblends 1.0.3 → 1.0.5

package/plugins/agent-panel/index.ts

@@ -18,6 +18,7 @@ import { streamSSE } from '../acryl-router/src/helpers/index.ts'
 import { Acryl } from '../acryl-router/src/index.ts'
 import type {} from '../agent/index.ts'
 import type {} from '../extensions/index.ts'
+import type { ChatDriver } from './drivers.ts'
 import { agentDriver, availableHeadless, type HeadlessName, headlessDriver } from './headless.ts'
 import { provideDrivers } from './registry.ts'
 
@@ -70,21 +71,32 @@ export function apply(ctx: Context, config: PanelConfig = {}): void {
   ctx.effect(() => registry.register(agentDriver(ctx)))
   for (const program of availableHeadless(config.drivers))
     ctx.effect(() => registry.register(headlessDriver(program, root)))
-  let running = false
 
   const tag = `<script type="module" src="${PREFIX}/panel.js"></script>`
+  const addScript = async (c: { res: Response }, next: () => Promise<void>): Promise<void> => {
+    await next()
+    if (!(c.res.headers.get('content-type') ?? '').includes('text/html')) return
+    const html = await c.res.text()
+    if (html.includes(`${PREFIX}/panel.js`)) {
+      c.res = new Response(html, c.res)
+      return
+    }
+    const headers = new Headers(c.res.headers)
+    headers.delete('content-length')
+    c.res = new Response(
+      html.includes('</body>') ? html.replace('</body>', `${tag}</body>`) : html + tag,
+      { status: c.res.status, headers },
+    )
+  }
+  // The script tag on every HTML page the app answers, whenever the plugin that serves the page was mounted (a plugin an agent built loads at boot, before this one, after a restart).
+  // An app whose router copy is older has no `wrap`: the tag is then added to the pages of the routes mounted after this plugin only.
+  const router = ctx.router as unknown as { wrap?: (middleware: typeof addScript) => unknown }
+  const wrapped = typeof router.wrap === 'function'
+  if (wrapped) router.wrap?.(addScript)
   const app = new Acryl()
-    // The script tag, on every HTML page the routes mounted after this plugin answer.
     .use('*', async (c, next) => {
-      await next()
-      if (!(c.res.headers.get('content-type') ?? '').includes('text/html')) return
-      const html = await c.res.text()
-      const headers = new Headers(c.res.headers)
-      headers.delete('content-length')
-      c.res = new Response(
-        html.includes('</body>') ? html.replace('</body>', `${tag}</body>`) : html + tag,
-        { status: c.res.status, headers },
-      )
+      if (wrapped) return next()
+      await addScript(c, next)
     })
     .get(`${PREFIX}/panel.js`, (c) =>
       c.body(`import '${PREFIX}/client/main.ts'\n`, 200, {
@@ -121,32 +133,122 @@ export function apply(ctx: Context, config: PanelConfig = {}): void {
           },
           400,
         )
-      if (running) return c.json({ error: 'a run is already going; wait for it to end' }, 409)
-      running = true
-      return streamSSE(c, async (stream) => {
-        const send = (event: string, data: unknown): Promise<void> =>
-          stream.writeSSE({ event, data: JSON.stringify(data) })
-        let changed = false
-        const off = ctx.on('extensions/changed', (extension: string, action: string) => {
-          changed = true
-          void send('change', { extension, action })
+      if (current !== undefined && !current.ended)
+        return c.json({ error: 'a run is already going; wait for it to end' }, 409)
+      const run = startRun(driverName, message, driver)
+      return follow(c, run, false)
+    })
+    // Stop: the only thing that cancels a run. A page that goes away (a reload, a move to another page, a closed tab) does not: the agent goes on, and the page picks it up again.
+    .post(`${PREFIX}/stop`, (c) => {
+      if (!fromOwnPage(c.req.raw.headers) || c.req.header('x-agent-panel-token') !== token)
+        return c.json({ error: "only the app's own page may stop a run" }, 403)
+      current?.cancel.abort()
+      return c.json({ ok: true })
+    })
+    // The latest run, for a page that just loaded: what was asked, then every event so far, then the rest as it happens (until the run ends).
+    .get(`${PREFIX}/run`, (c) => {
+      if (!fromOwnPage(c.req.raw.headers) || c.req.header('x-agent-panel-token') !== token)
+        return c.json({ error: "only the app's own page may read the run" }, 403)
+      return current === undefined ? c.json({ run: null }) : follow(c, current, true)
+    })
+  /** One run of an agent: its events as they came, and who is following. It lives in the app, not in a page. */
+  interface Run {
+    readonly id: number
+    readonly driver: string
+    readonly message: string
+    readonly events: Array<{ event: string; data: unknown }>
+    readonly followers: Set<(item: { event: string; data: unknown }) => void>
+    readonly cancel: AbortController
+    ended: boolean
+    endedAt?: number
+  }
+  let current: Run | undefined
+  let runs = 0
+  const startRun = (driverName: string, message: string, driver: ChatDriver): Run => {
+    runs += 1
+    const run: Run = {
+      id: runs,
+      driver: driverName,
+      message,
+      events: [],
+      followers: new Set(),
+      cancel: new AbortController(),
+      ended: false,
+    }
+    current = run
+    const emit = (event: string, data: unknown): void => {
+      const item = { event, data }
+      run.events.push(item)
+      for (const follower of [...run.followers]) follower(item)
+    }
+    let changed = false
+    const off = ctx.on('extensions/changed', (extension: string, action: string) => {
+      changed = true
+      emit('change', { extension, action })
+    })
+    ctx.effect(() => () => run.cancel.abort(), `agent-panel: run ${runs}`)
+    audit({ ask: 'start', driver: driverName, characters: message.length })
+    void (async () => {
+      try {
+        for await (const { event, data } of driver.start({ message, signal: run.cancel.signal }))
+          emit(event, data)
+        emit('done', { changed })
+      } catch (error) {
+        emit('error', { message: error instanceof Error ? error.message : String(error) })
+      } finally {
+        off()
+        run.ended = true
+        run.endedAt = Date.now()
+        audit({ ask: 'end', driver: driverName, changed })
+        for (const follower of [...run.followers]) follower({ event: 'end', data: {} })
+      }
+    })()
+    return run
+  }
+  /** Follow a run as server-sent events: a `run` event (what it is, whether it already ended), the events so far, then the new ones until it ends. Following does not keep it alive. */
+  const follow = (c: Parameters<typeof streamSSE>[0], run: Run, announce: boolean): Response =>
+    streamSSE(c, async (stream) => {
+      if (announce)
+        await stream.writeSSE({
+          event: 'run',
+          data: JSON.stringify({
+            id: run.id,
+            driver: run.driver,
+            message: run.message,
+            ended: run.ended,
+            endedAt: run.endedAt ?? null,
+          }),
         })
-        audit({ ask: 'start', driver: driverName, characters: message.length })
-        // Stop in the page closes the stream; that cancels the run (the model call, the tool or the program in flight is dropped).
-        const cancel = new AbortController()
-        stream.onAbort(() => cancel.abort())
-        try {
-          for await (const { event, data } of driver.start({ message, signal: cancel.signal }))
-            await send(event, data)
-          await send('done', { changed })
-        } catch (error) {
-          await send('error', { message: error instanceof Error ? error.message : String(error) })
-        } finally {
-          off()
-          running = false
-          audit({ ask: 'end', driver: driverName, changed })
-        }
+      const queue: Array<{ event: string; data: unknown }> = [...run.events]
+      let wake: (() => void) | undefined
+      const follower = (item: { event: string; data: unknown }): void => {
+        queue.push(item)
+        wake?.()
+      }
+      if (!run.ended) run.followers.add(follower)
+      let open = true
+      stream.onAbort(() => {
+        open = false
+        run.followers.delete(follower)
+        wake?.()
       })
+      try {
+        while (open) {
+          const item = queue.shift()
+          if (item === undefined) {
+            if (run.ended) break
+            await new Promise<void>((resolve) => {
+              wake = resolve
+            })
+            wake = undefined
+            continue
+          }
+          if (item.event === 'end') break
+          await stream.writeSSE({ event: item.event, data: JSON.stringify(item.data) })
+        }
+      } finally {
+        run.followers.delete(follower)
+      }
     })
   ctx.router.route('/', app)
 }

package/plugins/desktop/attach.ts

@@ -0,0 +1,72 @@
+/**
+ * `npm run desktop` while `npm run dev` runs: the door allows one process per app folder, so a second server cannot start. Instead of failing, the window attaches to the dev server
+ * that is running, and its door (the same pages, the same agent, the same data); closing the window then leaves that server running.
+ *
+ * The running server is found where the door says it is: `.acryl/door.json` (its loopback address and pid). Only a live process on a loopback address that answers is attached to.
+ */
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+export interface RunningApp {
+  readonly url: string
+  readonly pid: number
+}
+
+export interface AttachDeps {
+  readonly read?: (file: string) => string
+  /** True when a process with this pid is alive. */
+  readonly alive?: (pid: number) => boolean
+  /** Whether something answers HTTP at the address. */
+  readonly answers?: (url: string) => Promise<boolean>
+}
+
+const LOOPBACK = new Set(['127.0.0.1', 'localhost', '[::1]'])
+
+const processAlive = (pid: number): boolean => {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === 'EPERM'
+  }
+}
+
+const httpAnswers = async (url: string): Promise<boolean> => {
+  try {
+    await fetch(url, { signal: AbortSignal.timeout(1500), redirect: 'manual' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** @returns the dev server running from `root`, or `undefined` when there is none (no door file, a dead process, a stranger's address, nothing answering). */
+export async function runningApp(
+  root: string,
+  deps: AttachDeps = {},
+): Promise<RunningApp | undefined> {
+  const read = deps.read ?? ((file: string) => readFileSync(file, 'utf8'))
+  let found: { url?: unknown; pid?: unknown }
+  try {
+    found = JSON.parse(read(join(root, '.acryl', 'door.json'))) as { url?: unknown; pid?: unknown }
+  } catch {
+    return undefined
+  }
+  if (
+    typeof found.url !== 'string' ||
+    typeof found.pid !== 'number' ||
+    !Number.isInteger(found.pid) ||
+    found.pid <= 0
+  )
+    return undefined
+  let parsed: URL
+  try {
+    parsed = new URL(found.url)
+  } catch {
+    return undefined
+  }
+  if (parsed.protocol !== 'http:' || !LOOPBACK.has(parsed.hostname)) return undefined
+  if (!(deps.alive ?? processAlive)(found.pid)) return undefined
+  if (!(await (deps.answers ?? httpAnswers)(parsed.origin))) return undefined
+  return { url: parsed.origin, pid: found.pid }
+}

package/plugins/desktop/main.ts

@@ -13,6 +13,7 @@ import { app, BrowserWindow, shell } from 'electron'
 import type { App } from '../../src/app.ts'
 import '../acryl-node-server/src/register.ts'
 import { selectInstance } from '../instance/index.ts'
+import { runningApp } from './attach.ts'
 import { createDesktopShutdown, installShutdownRequests } from './shutdown.ts'
 import { resolveDesktopUserDataOverride } from './user-data.ts'
 import { windowOptions } from './window.ts'
@@ -65,9 +66,21 @@ if (!app.requestSingleInstanceLock()) {
 
   void app.whenReady().then(async () => {
     // The hook above is registered before the app's modules are loaded, so the app may have .tsx pages: they are loaded here, not as a static import.
-    const { createApp } = await import('../../src/app.ts')
-    running = await createApp(chosen)
-    const origin = new URL(running.url).origin
+    // A dev server is already running from this folder (`npm run dev`): the door allows one process per folder, so the window opens on that server instead of starting a second one,
+    // and closing the window leaves it running.
+    const attached = await runningApp(projectRoot)
+    let url: string
+    if (attached !== undefined) {
+      console.log(
+        `desktop: attached to the app already running from this folder at ${attached.url} (its server keeps running when the window closes)`,
+      )
+      url = attached.url
+    } else {
+      const { createApp } = await import('../../src/app.ts')
+      running = await createApp(chosen)
+      url = running.url
+    }
+    const origin = new URL(url).origin
     window = new BrowserWindow(windowOptions({ title: chosen.name }))
     window.once('ready-to-show', () => window?.show())
     // Navigation stays on the app's own server; any other address opens in the system browser.
@@ -80,6 +93,6 @@ if (!app.requestSingleInstanceLock()) {
       event.preventDefault()
       void shell.openExternal(url)
     })
-    await window.loadURL(new URL(startPath(), running.url).href)
+    await window.loadURL(new URL(startPath(), url).href)
   })
 }

package/plugins/extensions/index.ts

@@ -21,7 +21,6 @@ import {
   readdirSync,
   readFileSync,
   renameSync,
-  rmSync,
   statSync,
   writeFileSync,
 } from 'node:fs'
@@ -33,7 +32,7 @@ import type {} from '../instance/index.ts'
 import type { Sandbox } from '../sandbox/index.ts'
 import { appendLedger, type LedgerEntry, readLedger } from './ledger.ts'
 import { resolveFromApp, routerAliases } from './resolve.ts'
-import { hashFolder, prune, stage } from './stage.ts'
+import { discard, hashFolder, prune, stage } from './stage.ts'
 
 /** A fiber's lifecycle state, by name (Cordis's own enum is a `const enum`, which does not exist at run time). */
 export type ExtensionState = 'pending' | 'loading' | 'active' | 'failed' | 'disposed' | 'unloading'
@@ -611,7 +610,7 @@ export class Extensions extends Service {
     try {
       module = await this.load(staged.dir, name)
     } catch (error) {
-      rmSync(staged.dir, { recursive: true, force: true })
+      discard(staged.dir)
       this.record({ kind: 'refused', name, version: staged.version, error: message(error) })
       return {
         ok: false,
@@ -638,7 +637,7 @@ export class Extensions extends Service {
           : undefined
     if (failure) {
       await mounted.fiber.dispose().catch(() => undefined)
-      rmSync(staged.dir, { recursive: true, force: true })
+      discard(staged.dir)
       const error = failure.error
       this.record({ kind: 'refused', name, version: staged.version, error })
       let restored = false

package/plugins/extensions/stage.ts

@@ -5,32 +5,60 @@
  * code; a copy at a new path has fresh URLs for the entry and everything it imports, so it is evaluated anew. The author's source folder
  * is never modified. The hash makes an unchanged source recognisable; the stamp makes "newest" well defined.
  */
-import { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from 'node:fs'
+import { cpSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from 'node:fs'
 import { basename, join } from 'node:path'
 import { digestFolder, FOLDER_DIGEST_SKIPPED } from '@webboxes/blends-core'
 
 /** A short content digest of a folder, so an unchanged source keeps its version. */
 export const hashFolder = (dir: string, length = 12): string => digestFolder(dir, length)
 
-/** Copy `source` into a new version folder under `stageRoot/<name>/` and return its path and version. */
+/**
+ * Whether `node --watch` runs this process. It watches every module the process has imported, and keeps watching the paths of the runs before; a staged copy that is deleted
+ * while it is watched restarts the app, and the restart stages and prunes again: a loop. So under the watcher a staged copy is never deleted (a later start without it prunes).
+ */
+export const watched = (): boolean => process.env.WATCH_REPORT_DEPENDENCIES === '1'
+
+/** Delete a staged folder, unless the watcher would take the deletion for a change of the app. */
+export function discard(dir: string): void {
+  if (!watched()) rmSync(dir, { recursive: true, force: true })
+}
+
+/** The newest complete staged copy of `version` (copies are finished under a temporary name and renamed, so a folder with the final name is whole). */
+function staged(stageRoot: string, name: string, version: string): string | undefined {
+  const folder = join(stageRoot, name)
+  if (!existsSync(folder)) return undefined
+  const found = readdirSync(folder)
+    .filter((entry) => !entry.startsWith('.') && entry.endsWith(`-${version}`))
+    .sort()
+    .pop()
+  return found === undefined ? undefined : join(folder, found)
+}
+
+/** Copy `source` into a version folder under `stageRoot/<name>/` and return its path and version. An unchanged source reuses its copy: a restart stages nothing new. */
 export function stage(
   source: string,
   stageRoot: string,
   name: string,
 ): { dir: string; version: string } {
   const version = hashFolder(source)
+  const existing = staged(stageRoot, name, version)
+  if (existing !== undefined) return { dir: existing, version }
   const stamp = String(Date.now()).padStart(15, '0')
   const dir = join(stageRoot, name, `${stamp}-${version}`)
-  mkdirSync(dir, { recursive: true })
-  cpSync(source, dir, {
+  const partial = join(stageRoot, name, `.${stamp}-${version}.partial`)
+  rmSync(partial, { recursive: true, force: true })
+  mkdirSync(partial, { recursive: true })
+  cpSync(source, partial, {
     recursive: true,
     filter: (path) => !FOLDER_DIGEST_SKIPPED.has(basename(path)),
   })
+  renameSync(partial, dir)
   return { dir, version }
 }
 
-/** Delete staged versions of `name` except the ones to keep (best effort). Modules already loaded stay in memory until the app restarts. */
+/** Delete staged versions of `name` except the ones to keep (best effort; none under the watcher, see `watched`). Modules already loaded stay in memory until the app restarts. */
 export function prune(stageRoot: string, name: string, keep: readonly string[]): void {
+  if (watched()) return
   const folder = join(stageRoot, name)
   if (!existsSync(folder)) return
   if (keep.length === 0) {

package/plugins/openai/index.ts

@@ -102,7 +102,7 @@ export async function complete(
         function: {
           name: tool.name,
           description: tool.description,
-          parameters: { type: 'object', additionalProperties: true },
+          parameters: tool.parameters ?? { type: 'object', additionalProperties: true },
         },
       })),
     }),

package/shared/DEFAULTS.md

@@ -34,11 +34,15 @@ The door is a command in this folder, `.acryl/bin/acryl`, that lets you look at
 .acryl/bin/acryl act press --key <Enter|Escape|...>
 .acryl/bin/acryl act scroll [--ref <r>] --direction up|down [--amount <n>]
 .acryl/bin/acryl act wait (--text <t> | --role <role> [--name <n>]) [--gone] [--timeout-ms <ms>]
+.acryl/bin/acryl act reload                 reload the page; answers once the new page is back
+.acryl/bin/acryl act navigate --path <path> go to another path of the app, e.g. /settings (never another site)
 .acryl/bin/acryl plugin list | add <folder> | remove <name> | reload
 .acryl/bin/acryl tool list | call --tool <name> --args '<json>'
 .acryl/bin/acryl verbs                      the verb list
 ```
 
+- **Check your own UI work with `look` and `act`.** After you build or change something people see, open the page and use it the way a person would: look, click through the new feature, look again, and say what you saw. A plugin you add, remove or reload with `plugin add|remove|reload` reloads the open pages by itself and the verb answers once they are back; after you change any other file (`src/`, a page) run `act reload`, then `look`. A page is a path of the app: `act navigate --path /demo`.
+- The door's page script is added to every HTML page in development, so a page you write needs no tag for `look` and `act` to see it.
 - `look` and `act` need the app's page open in a browser (`brief` says `Page: not open` when it is not). Look again before each `act`: refs belong to the latest `look`.
 - A password field is not shown and cannot be typed into through the door; sign in by hand, or test the sign-in with a test.
 - Every verb takes `--json`. The exit code is 0 for done, 1 when the verb failed, 2 for a usage error and 3 when no app is running in this folder.

package/templates/agent/AGENTS.md

@@ -5,4 +5,6 @@ Besides `src/routes.ts`, the app runs an agent (`POST /ask`) that can write plug
 rollback; `GET /extensions` and `GET /tasks` show what it did. A plugin there is a folder with an `index.ts` exporting `name`, `inject`, `apply(ctx)`
 and an optional `check(ctx)` that receives the plugin's own context (so `ctx.router` reads as in `apply`). It may import `acryl-router`.
 
+**Write an extension, not a row.** A feature you build while the app runs is a folder `plugins/<name>/` installed with `.acryl/bin/acryl plugin add plugins/<name>` (the `extensions` plugin loads it again at every start). Add a row to `blend.yaml` and an entry to the `registry` of `src/app.ts` only when the person asks for a plugin that is part of the app itself. Both kinds may import the framework by name (`acrylblends`, `acrylblends/body-limit`, `acryl-router`); a row's relative imports of its sibling plugins also work.
+
 **Production.** The agent, the builder and the extensions are development tools: `POST /ask` spends the model key and runs tools, a plugin installed live runs in this process, and none of it is behind a login. With `NODE_ENV=production` `src/app.ts` leaves those three rows out, so `/ask`, `/extensions*` and `/tasks*` are not mounted; the page and `GET /health` stay. `ACRYL_PRODUCTION_KEEP=agent,builder,extensions` keeps the named rows, and each one kept prints a `WARNING` line at start.

package/templates/agent/blend.yaml

@@ -14,7 +14,7 @@ spec:
     # The address the server listens on.
     hostname: { type: string, default: 127.0.0.1 }
     # Steps an agent run may take.
-    steps: { type: number, default: 6 }
+    steps: { type: number, default: 12 }
     # Where task records are kept: jsonl (a text file) or sqlite.
     taskStore: { type: string, default: jsonl }
     # When true, a plugin the agent installs waits for POST /extensions/approve.
@@ -48,6 +48,9 @@ spec:
       name: builder
     - id: save
       name: save
+    # The panel: a chat button on every page in development (the app's own agent, or Codex, Claude or pi started in this folder). It starts nothing in production.
+    - id: agent-panel
+      name: agent-panel
     - id: routes
       name: routes
     - id: server

package/templates/agent/src/app.ts

@@ -7,6 +7,7 @@ import * as nodeServer from '../plugins/acryl-node-server/src/index.ts'
 import * as router from '../plugins/acryl-router/src/index.ts'
 import * as state from '../plugins/acryl-state/src/index.ts'
 import { agent, memory, model, tools } from '../plugins/agent/index.ts'
+import * as panel from '../plugins/agent-panel/index.ts'
 import { builder } from '../plugins/builder/index.ts'
 import { extensions } from '../plugins/extensions/index.ts'
 import { type AppInstance, instance } from '../plugins/instance/index.ts'
@@ -37,6 +38,7 @@ export const registry = {
   sandbox: sandboxPlugin,
   routes,
   'acryl-node-server': nodeServer,
+  'agent-panel': panel,
   'acryl-door': door,
 }
 

package/templates/agent/src/routes.ts

@@ -37,7 +37,7 @@ export const routes = {
       .get('/', (c) =>
         (c.req.header('accept') ?? '').includes('text/html')
           ? c.html(
-              `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${APP_NAME}</title></head><body><h1>${APP_NAME}</h1><p>This app runs an agent unless it is switched off (production switches it off, see ACRYL_PRODUCTION_KEEP in AGENTS.md). Ask it for a feature (<code>POST /ask</code>), or add the chat panel with <code>npx acrylblends add agent-panel</code>.</p>${DOOR_TAG}</body></html>`,
+              `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${APP_NAME}</title></head><body><h1>${APP_NAME}</h1><p>This app runs an agent unless it is switched off (production switches it off, see ACRYL_PRODUCTION_KEEP in AGENTS.md). Ask it for a feature in the agent panel on this page (or with <code>POST /ask</code>).</p>${DOOR_TAG}</body></html>`,
             )
           : c.json({ app: APP_NAME, ok: true }),
       )

package/templates/agent/template.json

@@ -10,6 +10,7 @@
     "sandbox",
     "extensions",
     "builder",
+    "agent-panel",
     "manifest",
     "save",
     "acryl-door"

package/templates/agent/test/builder.test.ts

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict'
+import { randomBytes } from 'node:crypto'
 import { mkdirSync } from 'node:fs'
 import { mkdtemp, rm } from 'node:fs/promises'
 import { join } from 'node:path'
@@ -7,6 +8,9 @@ import { fileURLToPath } from 'node:url'
 import { pinnedInstance, withPort } from '../plugins/instance/index.ts'
 import { createApp } from '../src/app.ts'
 
+/** The plugin this test has the agent build: a name of its own, so a route the app has (a person's /hello) can never shadow it and fail the template's tests. */
+const NAME = `builder-probe-${randomBytes(3).toString('hex')}`
+
 /** Throwaway homes live inside the project (`.acrylblends/` is ignored by git): a sandboxed agent may not write to the system temp folder. */
 const scratch = join(fileURLToPath(new URL('..', import.meta.url)), '.acrylblends', 'test')
 mkdirSync(scratch, { recursive: true })
@@ -24,28 +28,28 @@ test('the agent builds, updates, protects and removes a plugin in the running ap
     })
     return ((await response.json()) as { output: string }).output
   }
-  const hello = async () => {
-    const response = await app.root.router.request(`/hello`)
+  const served = async () => {
+    const response = await app.root.router.request(`/${NAME}`)
     return response.status === 200
       ? ((await response.json()) as { text: string }).text
       : response.status
   }
   try {
-    assert.equal(await ask('create route hello /hello Hello'), 'hello: installed, active.')
-    assert.equal(await hello(), 'Hello')
-    assert.equal(await ask('update route hello /hello Bonjour'), 'hello: updated, active.')
-    assert.equal(await hello(), 'Bonjour')
-    assert.match(await ask('break plugin hello'), /Previous version restored: true/)
-    assert.equal(await hello(), 'Bonjour')
+    assert.equal(await ask(`create route ${NAME} /${NAME} Hello`), `${NAME}: installed, active.`)
+    assert.equal(await served(), 'Hello')
+    assert.equal(await ask(`update route ${NAME} /${NAME} Bonjour`), `${NAME}: updated, active.`)
+    assert.equal(await served(), 'Bonjour')
+    assert.match(await ask(`break plugin ${NAME}`), /Previous version restored: true/)
+    assert.equal(await served(), 'Bonjour')
 
     // The broken version stays on disk, so put the working one back before restarting.
-    await ask('update route hello /hello Bonjour')
+    await ask(`update route ${NAME} /${NAME} Bonjour`)
     await app.stop()
     app = await createApp(chosen, { listen: false })
-    assert.equal(await hello(), 'Bonjour')
+    assert.equal(await served(), 'Bonjour')
 
-    assert.equal(await ask('remove plugin hello'), 'hello: done.')
-    assert.equal(await hello(), 404)
+    assert.equal(await ask(`remove plugin ${NAME}`), `${NAME}: done.`)
+    assert.equal(await served(), 404)
 
     // Every run is a durable task that owns its tool calls, and the records survived the restart.
     const records = (await (await app.root.router.request(`/tasks`)).json()) as Array<{
@@ -81,22 +85,22 @@ test('with approval on, an install waits for the owner; approving it makes it li
     ).json()) as Record<string, unknown>
   try {
     assert.equal(
-      (await post('/ask', { question: 'create route hello /hello Hello' })).output,
-      "hello: waiting for the owner's approval.",
+      (await post('/ask', { question: `create route ${NAME} /${NAME} Hello` })).output,
+      `${NAME}: waiting for the owner's approval.`,
     )
-    assert.equal((await app.root.router.request(`/hello`)).status, 404)
+    assert.equal((await app.root.router.request(`/${NAME}`)).status, 404)
     const listed = (await (await app.root.router.request(`/extensions`)).json()) as {
       waitingForApproval: Array<{ name: string }>
     }
     assert.deepEqual(
       listed.waitingForApproval.map((request) => request.name),
-      ['hello'],
+      [NAME],
     )
     assert.equal(
-      ((await post('/extensions/approve', { name: 'hello' })) as { state?: string }).state,
+      ((await post('/extensions/approve', { name: NAME })) as { state?: string }).state,
       'active',
     )
-    assert.deepEqual(await (await app.root.router.request(`/hello`)).json(), { text: 'Hello' })
+    assert.deepEqual(await (await app.root.router.request(`/${NAME}`)).json(), { text: 'Hello' })
     const tasks = (await (await app.root.router.request(`/tasks`)).json()) as Array<{
       manifest?: string
     }>
@@ -168,12 +172,13 @@ test('what happens is streamed from the state cells: the run as a task, and the
     await app.root.router.request(`/ask`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ question: 'create route hello /hello Hello' }),
+      body: JSON.stringify({ question: `create route ${NAME} /${NAME} Hello` }),
     })
     const arrived = (stream: { text: string }, what: RegExp) => what.test(stream.text)
     for (
       let waited = 0;
-      waited < 3000 && !arrived(extensionsStream.seen, /"name":"hello"[^\n]*"state":"active"/);
+      waited < 3000 &&
+      !arrived(extensionsStream.seen, new RegExp(`"name":"${NAME}"[^\\n]*"state":"active"`));
       waited += 25
     ) {
       await new Promise((done) => setTimeout(done, 25))
@@ -189,7 +194,7 @@ test('what happens is streamed from the state cells: the run as a task, and the
     )
     assert.ok(arrived(tasksStream.seen, /"kind":"tool:install_plugin"/), 'the install is a task')
     assert.ok(
-      arrived(extensionsStream.seen, /"name":"hello"[^\n]*"state":"active"/),
+      arrived(extensionsStream.seen, new RegExp(`"name":"${NAME}"[^\\n]*"state":"active"`)),
       'the extension is reported',
     )
     // In process there is no socket to close: the readers are cancelled, which ends the streams and lets the pumps finish.

package/lib/helpers-CvTauQT5.js

@@ -1,5 +0,0 @@
-import "./factory.js";
-import "./ssg-BwjcA-Ge.js";
-import "./css.js";
-import "./connection-C7xgP1hP.js";
-export {};

package/lib/middleware-CPQ8himN.js

@@ -1,12 +0,0 @@
-import "./basic-auth.js";
-import "./combine.js";
-import "./context-storage.js";
-import "./ip-restriction.js";
-import "./jsx-renderer.js";
-import "./jwk-LkzeoaU8.js";
-import "./jwt-CskdhEW9.js";
-import "./method-not-allowed.js";
-import "./serve-static-Cp5adzGo.js";
-import "./timeout.js";
-import "./loopback-only.js";
-export {};