acrylblends 1.0.4 → 1.0.5

package/plugins/agent-panel/client/describe.ts

@@ -0,0 +1,44 @@
+// One line for a tool event of the panel's conversation: what the tool is doing, not only its name. A coding agent started in the folder reports its own log (`{ tool: 'codex', info }`):
+// its bookkeeping is dropped and its command or sentence is kept. The app's own agent reports a call (`{ tool, input, result | error }`): the name and a short form of the arguments.
+
+const MAX = 160
+
+const clip = (text: string): string => (text.length > MAX ? `${text.slice(0, MAX - 1)}…` : text)
+
+/** A shell command as the agent's log writes it: `/bin/zsh -lc 'npm test' in /path/to/app` becomes `npm test`. */
+function commandOf(line: string): string {
+  const withoutCwd = line.replace(/ in \/\S+\s*$/u, '')
+  const wrapped = /^(?:\/\S*\/)?(?:ba|z|da)?sh -l?c (['"])([\s\S]*)\1$/u.exec(withoutCwd.trim())
+  return wrapped?.[2] ?? withoutCwd.trim()
+}
+
+/** @returns the line to show, or `undefined` when the event says nothing worth a line (a hook ran, a token count). */
+export function describeTool(data: Record<string, unknown>): string | undefined {
+  const tool = String(data.tool ?? '')
+  if (typeof data.info === 'string') {
+    const lines = data.info
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(
+        (line) =>
+          line !== '' &&
+          !/^hook:/u.test(line) &&
+          !/^tokens used/u.test(line) &&
+          !/^[\d,]+$/u.test(line),
+      )
+    if (lines.length === 0) return undefined
+    const [first = '', second = ''] = lines
+    if (first === 'exec') return second === '' ? undefined : `${tool}: $ ${clip(commandOf(second))}`
+    // The output of a command that ran: only a failure is worth a line.
+    if (/^succeeded in /u.test(first)) return undefined
+    if (/^exited \d+/u.test(first)) return `${tool}: ${clip(first.replace(/:$/u, ''))}`
+    return `${tool}: ${clip(lines.join(' '))}`
+  }
+  const input =
+    data.input === undefined ||
+    (typeof data.input === 'object' && data.input !== null && Object.keys(data.input).length === 0)
+      ? ''
+      : ` ${clip(JSON.stringify(data.input))}`
+  const failed = data.error ? ` failed: ${clip(String(data.error))}` : ''
+  return `${tool}${input}${failed}`
+}

package/plugins/agent-panel/client/main.ts

@@ -1,5 +1,7 @@
 // The panel in the page: a button at the corner opens a side panel (a shadow root, so the app's CSS cannot touch it and it cannot touch the app's). It asks the app's
 // agent through POST /api/agent-panel/ask, shows the answer as it arrives, and reloads the page after a run that installed or removed a plugin.
+import { describeTool } from './describe.ts'
+
 const PREFIX = '/api/agent-panel'
 
 interface Session {
@@ -181,7 +183,8 @@ async function start(): Promise<void> {
           answer ??= line('')
           answer.textContent += String(data.text ?? '')
         } else if (event === 'tool') {
-          line(`${String(data.tool)}${data.error ? ` failed: ${String(data.error)}` : ''}`, 'tool')
+          const described = describeTool(data)
+          if (described !== undefined) line(described, 'tool')
         } else if (event === 'change') {
           changed = true
           line(`plugin ${String(data.extension)}: ${String(data.action)}`, 'tool')

package/plugins/agent-panel/index.ts

@@ -73,18 +73,30 @@ export function apply(ctx: Context, config: PanelConfig = {}): void {
     ctx.effect(() => registry.register(headlessDriver(program, root)))
 
   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, {

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/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 {};