acrylblends 0.7.7 → 0.8.0

package/plugins/acryl-router/src/helpers/read-sse.ts

@@ -0,0 +1,111 @@
+/**
+ * `readSSE(response)`: the events of a `text/event-stream` answer from `fetch`, for the browser. `EventSource` reads GET streams only; a chat
+ * or any stream that needs a POST body, a header or an `AbortSignal` is read with `fetch`, and this is the loop every such page otherwise writes by
+ * hand. It follows the parsing rules of the HTML standard (lines end in LF, CRLF or CR; the `data` lines of one event join with LF; a line that
+ * starts with a colon is a comment; an event ends at a blank line; an event with no `data` line is not dispatched; the last event is dispatched
+ * only if its blank line arrived), and it is one module with no imports, so it also runs in a service worker and on a fetch runtime.
+ *
+ * ACRYL's own addition, not part of the upstream port.
+ */
+
+/** One event of the stream. */
+export interface SSEEvent {
+  /** The `event:` name; `message` when the event has none. */
+  readonly event: string
+  /** The `data:` lines of the event, joined with a line feed. */
+  readonly data: string
+  /** The `id:` of the event, when it had one. */
+  readonly id?: string
+  /** The `retry:` of the event in milliseconds, when it had one. */
+  readonly retry?: number
+}
+
+export interface ReadSSEOptions {
+  /** Stops the loop and cancels the response body when it aborts. (Abort the `fetch` itself with the signal you pass to it.) */
+  readonly signal?: AbortSignal
+}
+
+/**
+ * Read the events of a `text/event-stream` response as they arrive. Leaving the loop early (`break`, a thrown error) cancels the body, so the
+ * request to the server ends.
+ * @throws when the response is not `ok` (the status is in the message; the body is cancelled, not parsed), has no body, or fails while it is read.
+ */
+export async function* readSSE(response: Response, options: ReadSSEOptions = {}): AsyncGenerator<SSEEvent, void, undefined> {
+  if (!response.ok) {
+    await response.body?.cancel().catch(() => undefined)
+    throw new Error(`readSSE: the request failed with ${String(response.status)}${response.statusText === '' ? '' : ` ${response.statusText}`}`)
+  }
+  if (response.body === null) throw new Error('readSSE: the response has no body to read')
+  const { signal } = options
+  if (signal?.aborted === true) {
+    await response.body.cancel().catch(() => undefined)
+    return
+  }
+
+  const reader = response.body.getReader()
+  const onAbort = (): void => {
+    void reader.cancel().catch(() => undefined)
+  }
+  signal?.addEventListener('abort', onAbort, { once: true })
+  const decoder = new TextDecoder('utf-8')
+
+  let buffer = ''
+  let skipLineFeed = false
+  let name = ''
+  let data: string[] = []
+  let id: string | undefined
+  let retry: number | undefined
+
+  /** Apply one line; returns the event when this line completes one. */
+  const apply = (line: string): SSEEvent | undefined => {
+    if (line === '') {
+      const event = data.length === 0 ? undefined : { event: name === '' ? 'message' : name, data: data.join('\n'), ...(id === undefined ? {} : { id }), ...(retry === undefined ? {} : { retry }) }
+      name = ''
+      data = []
+      id = undefined
+      retry = undefined
+      return event
+    }
+    if (line.startsWith(':')) return undefined
+    const colon = line.indexOf(':')
+    const field = colon === -1 ? line : line.slice(0, colon)
+    let value = colon === -1 ? '' : line.slice(colon + 1)
+    if (value.startsWith(' ')) value = value.slice(1)
+    if (field === 'event') name = value
+    else if (field === 'data') data.push(value)
+    else if (field === 'id') {
+      if (!value.includes('\u0000')) id = value
+    } else if (field === 'retry' && /^\d+$/u.test(value)) retry = Number(value)
+    return undefined
+  }
+
+  try {
+    for (;;) {
+      const { done, value } = await reader.read()
+      if (done) break
+      let text = decoder.decode(value, { stream: true })
+      // A CR at the end of the last chunk already ended its line; the LF that completes the CRLF may open this one.
+      if (skipLineFeed && text.startsWith('\n')) text = text.slice(1)
+      if (text !== '') skipLineFeed = false
+      buffer += text
+      let start = 0
+      for (let index = 0; index < buffer.length; index += 1) {
+        const code = buffer.charCodeAt(index)
+        if (code !== 10 && code !== 13) continue
+        const line = buffer.slice(start, index)
+        if (code === 13) {
+          if (index + 1 < buffer.length) {
+            if (buffer.charCodeAt(index + 1) === 10) index += 1
+          } else skipLineFeed = true
+        }
+        start = index + 1
+        const event = apply(line)
+        if (event !== undefined) yield event
+      }
+      buffer = buffer.slice(start)
+    }
+  } finally {
+    signal?.removeEventListener('abort', onAbort)
+    await reader.cancel().catch(() => undefined)
+  }
+}

package/plugins/acryl-router/src/service.ts

@@ -198,6 +198,9 @@ export class Router extends Service {
       }
       ;(handler as unknown as Record<string, unknown>)[COMPOSED_HANDLER] = inner
       tagged.on(route.method, route.path, handler)
+      // `on` registers under the base path of `tagged` (`/`), which would hide the prefix of a nested app from `basePath(c)`; keep the route's own.
+      const registered = tagged.routes.at(-1)
+      if (registered !== undefined) registered.basePath = route.basePath
     }
     return mount
   }

package/plugins/acryl-router/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-router",
-    "commit": "f8e385e4389fe2fdc6fd2a4366a7f2a7389faacb"
+    "commit": "20bdc263d6f0f8febbd967007bda4cf4a802efd2"
   },
   "vendored": [
     "src",
@@ -10,7 +10,7 @@
     "LICENSE"
   ],
   "rewrittenSpecifiers": 6,
-  "digest": "sha256:07772b7e7a2cfe416e4566bebdec7e85fb4abc30466bf104e80342b9fc4ab007",
+  "digest": "sha256:f9679acf23d0a647a3f8bf9bb3cb9107eb03d25192ab401506e3a4ee570e305e",
   "testsNotRun": {
     "tests/loader.spec.ts": "loads the built lib/ entry through the real Loader; the library ships source and has no build"
   },

package/plugins/acryl-router-http/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-router-http",
-    "commit": "f8e385e4389fe2fdc6fd2a4366a7f2a7389faacb"
+    "commit": "20bdc263d6f0f8febbd967007bda4cf4a802efd2"
   },
   "vendored": [
     "src",

package/plugins/acryl-state/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-state",
-    "commit": "f8e385e4389fe2fdc6fd2a4366a7f2a7389faacb"
+    "commit": "20bdc263d6f0f8febbd967007bda4cf4a802efd2"
   },
   "vendored": [
     "src",

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

@@ -0,0 +1,159 @@
+// 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.
+const PREFIX = '/api/agent-panel'
+
+interface Session {
+  token: string
+  drivers: string[]
+}
+interface PanelEvent {
+  event: string
+  data: Record<string, unknown>
+}
+
+/** The events of a server-sent stream, as they arrive. */
+async function* events(response: Response): AsyncGenerator<PanelEvent> {
+  const reader = response.body!.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+  for (;;) {
+    const { value, done } = await reader.read()
+    if (done) return
+    buffer += decoder.decode(value, { stream: true }).replace(/\r\n/gu, '\n')
+    for (let end = buffer.indexOf('\n\n'); end !== -1; end = buffer.indexOf('\n\n')) {
+      const block = buffer.slice(0, end)
+      buffer = buffer.slice(end + 2)
+      let event = 'message'
+      let data = ''
+      for (const line of block.split('\n')) {
+        if (line.startsWith('event:')) event = line.slice(6).trim()
+        else if (line.startsWith('data:')) data += line.slice(5).trim()
+      }
+      if (data !== '') yield { event, data: JSON.parse(data) as Record<string, unknown> }
+    }
+  }
+}
+
+const css = `
+:host { all: initial }
+* { box-sizing: border-box; font: 14px system-ui, sans-serif }
+button.open { position: fixed; right: 16px; bottom: 16px; z-index: 2147483000; border: 0; border-radius: 24px; padding: 10px 16px; background: #1f2937; color: #fff; cursor: pointer; box-shadow: 0 2px 8px #0004 }
+section { position: fixed; top: 0; right: 0; bottom: 0; width: min(380px, 100vw); z-index: 2147483001; display: none; flex-direction: column; background: #fff; color: #111827; border-left: 1px solid #d1d5db; box-shadow: -2px 0 12px #0003 }
+section.shown { display: flex }
+header { display: flex; gap: 8px; align-items: center; padding: 8px 12px; border-bottom: 1px solid #e5e7eb }
+header strong { flex: 1 }
+#log { flex: 1; overflow: auto; padding: 12px; display: flex; flex-direction: column; gap: 8px }
+.msg { white-space: pre-wrap; padding: 8px 10px; border-radius: 8px; background: #f3f4f6 }
+.me { background: #dbeafe; align-self: flex-end }
+.tool { font: 12px ui-monospace, monospace; color: #4b5563; background: none; padding: 0 }
+.err { background: #fee2e2 }
+form { display: flex; flex-direction: column; gap: 6px; padding: 10px 12px; border-top: 1px solid #e5e7eb }
+textarea { width: 100%; min-height: 64px; resize: vertical; padding: 8px; border: 1px solid #d1d5db; border-radius: 6px }
+.row { display: flex; gap: 8px; align-items: center }
+.row button, header button { padding: 6px 12px; border: 1px solid #d1d5db; border-radius: 6px; background: #fff; cursor: pointer }
+.row button.send { background: #1f2937; color: #fff; border-color: #1f2937 }
+`
+
+async function start(): Promise<void> {
+  const reply = await fetch(`${PREFIX}/session`)
+  if (!reply.ok) return
+  const session = (await reply.json()) as Session
+
+  const host = document.createElement('div')
+  host.id = 'agent-panel'
+  const shadow = host.attachShadow({ mode: 'open' })
+  shadow.innerHTML = `<style>${css}</style>
+    <button class="open" type="button">Ask the agent</button>
+    <section aria-label="Agent panel">
+      <header><strong>Agent</strong><select aria-label="Agent">${session.drivers.map((d) => `<option>${d}</option>`).join('')}</select><button class="close" type="button" aria-label="Close">×</button></header>
+      <div id="log" role="log"></div>
+      <form><textarea aria-label="Message" placeholder="What should the app do?"></textarea>
+        <div class="row"><button class="send" type="submit">Send</button><button class="stop" type="button" disabled>Stop</button></div></form>
+    </section>`
+  const $ = <T extends Element>(selector: string): T => shadow.querySelector<T>(selector)!
+  const panel = $<HTMLElement>('section')
+  const log = $<HTMLElement>('#log')
+  const input = $<HTMLTextAreaElement>('textarea')
+  const send = $<HTMLButtonElement>('.send')
+  const stop = $<HTMLButtonElement>('.stop')
+  const driver = $<HTMLSelectElement>('select')
+  const show = (open: boolean): void => {
+    panel.classList.toggle('shown', open)
+    if (open) input.focus()
+  }
+  $('button.open').addEventListener('click', () => show(true))
+  $('button.close').addEventListener('click', () => show(false))
+  const line = (text: string, kind = ''): HTMLElement => {
+    const el = document.createElement('div')
+    el.className = `msg ${kind}`
+    el.textContent = text
+    log.append(el)
+    log.scrollTop = log.scrollHeight
+    return el
+  }
+
+  let controller: AbortController | undefined
+  stop.addEventListener('click', () => controller?.abort())
+  shadow.querySelector('form')!.addEventListener('submit', async (submitted) => {
+    submitted.preventDefault()
+    const message = input.value.trim()
+    if (message === '' || controller) return
+    input.value = ''
+    line(message, 'me')
+    controller = new AbortController()
+    send.disabled = true
+    stop.disabled = false
+    let changed = false
+    let answer: HTMLElement | undefined
+    try {
+      const response = await fetch(`${PREFIX}/ask`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', 'x-agent-panel-token': session.token },
+        body: JSON.stringify({ message, driver: driver.value }),
+        signal: controller.signal,
+      })
+      if (!response.ok) {
+        line(
+          ((await response.json().catch(() => ({}))) as { error?: string }).error ??
+            `The panel answered ${response.status}.`,
+          'err',
+        )
+        return
+      }
+      for await (const { event, data } of events(response)) {
+        if (event === 'text') {
+          answer ??= line('')
+          answer.textContent += String(data.text ?? '')
+        } else if (event === 'tool') {
+          line(`${String(data.tool)}${data.error ? ` failed: ${String(data.error)}` : ''}`, 'tool')
+        } else if (event === 'change') {
+          changed = true
+          line(`plugin ${String(data.extension)}: ${String(data.action)}`, 'tool')
+        } else if (event === 'error') {
+          line(String(data.message ?? 'The run failed.'), 'err')
+        } else if (event === 'done') {
+          changed = changed || data.changed === true
+        }
+      }
+    } catch (error) {
+      line(
+        controller?.signal.aborted
+          ? 'Stopped.'
+          : `The request failed: ${error instanceof Error ? error.message : String(error)}`,
+        'err',
+      )
+    } finally {
+      controller = undefined
+      send.disabled = false
+      stop.disabled = true
+    }
+    // A plugin was installed or removed: the new feature is served by the running app, so the page only needs to be loaded again (unless something is being typed).
+    if (changed && input.value.trim() === '') {
+      line('Reloading the page to show it.', 'tool')
+      setTimeout(() => location.reload(), 900)
+    }
+  })
+  document.body.append(host)
+}
+
+void start()

package/plugins/agent-panel/index.ts

@@ -0,0 +1,232 @@
+/**
+ * The built-in agent (spec 049 slice 14): a chat panel inside the running app. The person says what they want; the app's own agent (`driver: 'agent'`) or a coding
+ * agent started in the app folder (`'claude'`, `'codex'`, `'pi'`) builds it through the door, and when a plugin was installed or removed the page reloads, so the new feature
+ * shows with no restart.
+ *
+ * - A middleware appends one script tag (`/api/agent-panel/panel.js`) to every HTML response of the routes mounted after it, so no page is edited.
+ * - `GET /api/agent-panel/session` gives the page the drivers it may use and a token; `POST /api/agent-panel/ask` runs one message and answers server-sent events:
+ *   `text`, `tool`, `change`, `done`, `error`.
+ * - Only the app's own page may ask (a same-origin request carrying the token), one run at a time, and every ask is written to `.acryl/audit/agent-panel.jsonl`.
+ * - Development only: the plugin does nothing with `NODE_ENV=production` or `ACRYL_DOOR=off`.
+ */
+import { spawn, spawnSync } from 'node:child_process'
+import { randomBytes } from 'node:crypto'
+import { appendFileSync, mkdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import type { Context } from '@deepseek-ai/cordis'
+import { clientModules } from '../acryl-node-server/src/client-modules.ts'
+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'
+
+export const name = 'agent-panel'
+export const inject = ['router', 'agent', 'extensions', 'appInstance']
+
+const PREFIX = '/api/agent-panel'
+const CLIENT_DIR = join(import.meta.dirname, 'client')
+
+export type DriverName = 'agent' | 'claude' | 'codex' | 'pi'
+
+export interface PanelConfig {
+  /** Driver programs to offer besides the app's own agent; default: the ones found on the machine. */
+  drivers?: readonly Exclude<DriverName, 'agent'>[]
+}
+
+/** The command line of each coding agent started headless in the app folder (the same ones the product test uses). */
+function command(
+  driver: Exclude<DriverName, 'agent'>,
+  message: string,
+  root: string,
+): { file: string; args: string[] } {
+  switch (driver) {
+    case 'claude':
+      return {
+        file: 'claude',
+        args: [
+          '-p',
+          message,
+          '--permission-mode',
+          'acceptEdits',
+          '--allowedTools',
+          'Read,Edit,Write,Glob,Grep,Bash(npm *),Bash(npx *),Bash(node *),Bash(.acryl/bin/acryl *),Bash(curl *)',
+        ],
+      }
+    case 'codex':
+      return {
+        file: 'codex',
+        args: [
+          'exec',
+          '--skip-git-repo-check',
+          '-s',
+          'workspace-write',
+          '-c',
+          'sandbox_workspace_write.network_access=true',
+          '-C',
+          root,
+          message,
+        ],
+      }
+    case 'pi':
+      return {
+        file: 'pi',
+        args: [
+          '-p',
+          message,
+          '--provider',
+          'deepseek',
+          '--model',
+          'deepseek-v4-pro',
+          '--no-session',
+        ],
+      }
+  }
+}
+
+function onPath(program: string): boolean {
+  const found = spawnSync(process.platform === 'win32' ? 'where' : 'which', [program], {
+    encoding: 'utf8',
+  })
+  return found.status === 0
+}
+
+/** The drivers this machine can offer: the app's own agent always; a program when it is installed (pi also needs its key in the environment). */
+export function availableDrivers(wanted?: readonly Exclude<DriverName, 'agent'>[]): DriverName[] {
+  const found: DriverName[] = ['agent']
+  for (const driver of wanted ?? (['claude', 'codex', 'pi'] as const)) {
+    if (driver === 'pi' && !process.env.DEEPSEEK_API_KEY) continue
+    if (onPath(driver)) found.push(driver)
+  }
+  return found
+}
+
+/** Whether a request comes from the app's own page: a browser says so itself (`Sec-Fetch-Site: same-origin`), or the Origin is the Host. */
+export function fromOwnPage(headers: Headers): boolean {
+  const site = headers.get('sec-fetch-site')
+  if (site !== null) return site === 'same-origin'
+  const origin = headers.get('origin')
+  const host = headers.get('host')
+  return origin !== null && host !== null && new URL(origin).host === host
+}
+
+export function apply(ctx: Context, config: PanelConfig = {}): void {
+  if (process.env.NODE_ENV === 'production' || process.env.ACRYL_DOOR === 'off') return
+  const root = ctx.appInstance.root
+  const token = randomBytes(24).toString('hex')
+  const auditFile = join(root, '.acryl', 'audit', 'agent-panel.jsonl')
+  const audit = (entry: Record<string, unknown>): void => {
+    try {
+      mkdirSync(dirname(auditFile), { recursive: true })
+      appendFileSync(auditFile, `${JSON.stringify({ at: new Date().toISOString(), ...entry })}\n`)
+    } catch {
+      // The audit never stops a run.
+    }
+  }
+  const drivers = availableDrivers(config.drivers)
+  let running = false
+
+  const tag = `<script type="module" src="${PREFIX}/panel.js"></script>`
+  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 },
+      )
+    })
+    .get(`${PREFIX}/panel.js`, (c) =>
+      c.body(`import '${PREFIX}/client/main.ts'\n`, 200, {
+        'content-type': 'text/javascript; charset=utf-8',
+        'cache-control': 'no-cache',
+      }),
+    )
+    .route(`${PREFIX}/client`, clientModules({ root: CLIENT_DIR }))
+    .get(`${PREFIX}/session`, (c) => {
+      if (!fromOwnPage(c.req.raw.headers))
+        return c.json({ error: "only the app's own page may use the panel" }, 403)
+      return c.json({ token, drivers })
+    })
+    .post(`${PREFIX}/ask`, async (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 ask" }, 403)
+      const body = (await c.req.json().catch(() => ({}))) as { message?: unknown; driver?: unknown }
+      const message = typeof body.message === 'string' ? body.message.trim() : ''
+      const driver = (typeof body.driver === 'string' ? body.driver : 'agent') as DriverName
+      if (message === '' || message.length > 8000)
+        return c.json({ error: 'write a message of at most 8000 characters' }, 400)
+      if (!drivers.includes(driver))
+        return c.json(
+          { error: `the driver "${driver}" is not available here (${drivers.join(', ')})` },
+          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 })
+        })
+        audit({ ask: 'start', driver, characters: message.length })
+        try {
+          if (driver === 'agent') {
+            const result = await ctx.agent.run(message)
+            for (const call of result.trace)
+              await send('tool', {
+                tool: call.tool,
+                input: call.input,
+                ...(call.error ? { error: call.error } : { result: call.result }),
+              })
+            await send('text', {
+              text:
+                result.status === 'completed'
+                  ? result.output
+                  : result.status === 'cancelled'
+                    ? 'The run was cancelled.'
+                    : `The run stopped after ${result.steps} steps without an answer.`,
+            })
+          } else {
+            const { file, args } = command(driver, message, root)
+            const child = spawn(file, args, {
+              cwd: root,
+              env: process.env,
+              stdio: ['ignore', 'pipe', 'pipe'],
+            })
+            stream.onAbort(() => {
+              child.kill('SIGTERM')
+            })
+            child.stdout.on(
+              'data',
+              (chunk: Buffer) => void send('text', { text: chunk.toString() }),
+            )
+            child.stderr.on(
+              'data',
+              (chunk: Buffer) =>
+                void send('tool', { tool: driver, info: chunk.toString().slice(0, 500) }),
+            )
+            const code = await new Promise<number>((done) => {
+              child.on('error', () => done(1))
+              child.on('exit', (exit) => done(exit ?? 1))
+            })
+            if (code !== 0)
+              await send('error', { message: `${driver} ended with exit code ${code}` })
+          }
+          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, changed })
+        }
+      })
+    })
+  ctx.router.route('/', app)
+}

package/plugins/agent-panel/plugin.json

@@ -0,0 +1,21 @@
+{
+  "name": "agent-panel",
+  "description": "A chat panel inside the running app: the person writes what they want, the app's own agent (or Claude Code, Codex or pi started in the app folder) builds it through the same door, and the page reloads when a plugin was installed, with no restart. Development only; opt-in with acrylblends add agent-panel.",
+  "requires": [
+    "acryl-router",
+    "acryl-node-server",
+    "agent",
+    "builder",
+    "extensions",
+    "sandbox",
+    "tasks",
+    "instance"
+  ],
+  "inject": ["router", "agent", "extensions", "appInstance"],
+  "provides": [],
+  "dependencies": {
+    "@deepseek-ai/cordis": "4.0.4"
+  },
+  "mount": "add a row `- id: agent-panel` / `name: agent-panel` to blend.yaml BEFORE the `routes` row (its middleware adds one script tag to every HTML page the routes after it answer) and register it in src/app.ts: 'agent-panel': panel; open the app in a browser and use the button at the corner of the page",
+  "gitignore": [".acryl/"]
+}

package/plugins/builder/index.ts

@@ -14,7 +14,7 @@ import type {} from '../instance/index.ts'
 import { builderRules } from './script.ts'
 
 export interface BuilderConfig {
-  /** Where the agent writes extensions. Defaults to `<project>/extensions`. Must be one of the extensions sources. */
+  /** Where the agent writes extensions. Defaults to `<project>/plugins`. Must be one of the extensions sources. */
   dir?: string
   /** Where `package_plugin` writes standalone packages. Defaults to `<project>/plugin-packages`. */
   packagesDir?: string
@@ -64,7 +64,7 @@ export const builder = {
   name: 'builder',
   inject: ['extensions', 'tools', 'appInstance'],
   apply(ctx: Context, config: BuilderConfig) {
-    const dir = resolve(config?.dir ?? join(ctx.appInstance.root, 'extensions'))
+    const dir = resolve(config?.dir ?? join(ctx.appInstance.root, 'plugins'))
     if (!ctx.extensions.sources.some((source) => resolve(source.dir) === dir)) {
       throw new BuilderError(
         `the builder writes into ${dir}, which is not an extensions source; add it to the extensions plugin's sources`,

package/plugins/builder/plugin.json

@@ -7,5 +7,5 @@
   "dependencies": {
     "@deepseek-ai/cordis": "4.0.4"
   },
-  "mount": "mount it after agent and extensions: root.plugin(builder, { dir: join(root, 'extensions') }); dir must be an extensions source"
+  "mount": "mount it after agent and extensions: root.plugin(builder, { dir: join(root, 'plugins') }); dir must be an extensions source"
 }

package/plugins/desktop/main.ts

@@ -10,14 +10,14 @@ import { mkdirSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { app, BrowserWindow, shell } from 'electron'
-import type { App } from '../../app.ts'
+import type { App } from '../../src/app.ts'
 import '../acryl-node-server/src/register.ts'
 import { selectInstance } from '../instance/index.ts'
 import { createDesktopShutdown, installShutdownRequests } from './shutdown.ts'
 import { resolveDesktopUserDataOverride } from './user-data.ts'
 import { windowOptions } from './window.ts'
 
-const projectRoot = fileURLToPath(new URL('../../..', import.meta.url))
+const projectRoot = fileURLToPath(new URL('../..', import.meta.url))
 const chosen = selectInstance({ projectRoot, env: process.env })
 
 /** Where the window opens: `acrylblends.desktopPath` in package.json (the todo template sets `/todo`), else the root. */
@@ -65,7 +65,7 @@ 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('../../app.ts')
+    const { createApp } = await import('../../src/app.ts')
     running = await createApp(chosen)
     const origin = new URL(running.url).origin
     window = new BrowserWindow(windowOptions({ title: chosen.name }))

package/plugins/desktop/plugin.json

@@ -9,8 +9,8 @@
     "electron": "44.9.3"
   },
   "scripts": {
-    "desktop": "electron src/plugins/desktop/main.ts"
+    "desktop": "electron plugins/desktop/main.ts"
   },
   "omit": ["**/*.test.*"],
-  "mount": "nothing to mount: run `npm install`, then `npm run desktop` (the window opens on the app's own server; every electron call is in src/plugins/desktop)"
+  "mount": "nothing to mount: run `npm install`, then `npm run desktop` (the window opens on the app's own server; every electron call is in plugins/desktop)"
 }

package/plugins/desktop/upstream.json

@@ -5,7 +5,7 @@
       "apps/acryl-desktop/src/shell/desktop-user-data.ts": "user-data.ts",
       "apps/acryl-desktop/src/shell/shutdown.ts": "shutdown.ts"
     },
-    "commit": "f8e385e4389fe2fdc6fd2a4366a7f2a7389faacb"
+    "commit": "20bdc263d6f0f8febbd967007bda4cf4a802efd2"
   },
   "rewrittenSpecifiers": 0,
   "digest": "sha256:7dfe960a8bbb476c35540d2202a7aaa62b33492c2ac3e34314e2ecfca45f32f2"