acrylblends 0.0.0-stage → 0.2.0

package/plugins/tasks/index.ts

@@ -0,0 +1,232 @@
+/**
+ * Durable task records (`ctx.tasks`).
+ *
+ * The idea comes from Pi Durable (see spec 013, "Ideas from Pi Durable"), kept to what Cordis does not already do: every piece of work
+ * gets a record with an id, an optional owner (parent), its input, status, result or error, and timestamps. Each change is appended to
+ * `<home>/tasks.jsonl` before the call that made it returns, so nothing is presented as done before it is recorded. At startup the log is
+ * folded back into records, and a task still `running` is marked `interrupted`: it is reported, never silently run again, because an
+ * external side effect may already have happened. Cancelling a task cancels the tasks it owns and aborts their signals.
+ */
+
+import { randomUUID } from 'node:crypto'
+import { type Context, Service } from '@deepseek-ai/cordis'
+import type {} from '../instance/index.ts'
+import { openStore, type StoreKind, type TaskChange, type TaskStore } from './store.ts'
+
+export interface TasksConfig {
+  /** Recorded on every task: the digest of the manifest the app was composed from. */
+  manifest?: string
+  /** Where changes are kept: a JSON lines file (default) or a SQLite file. */
+  store?: StoreKind
+}
+
+export type TaskStatus = 'running' | 'completed' | 'failed' | 'cancelled' | 'interrupted'
+
+export interface TaskRecord {
+  readonly id: string
+  readonly kind: string
+  readonly parent?: string
+  /** The digest of the manifest the app was composed from, so a task traces to the configuration that ran it. */
+  readonly manifest?: string
+  readonly input: unknown
+  readonly status: TaskStatus
+  readonly result?: unknown
+  readonly error?: string
+  /** Free-form progress the owner attached (for example a tool-call trace). */
+  readonly detail?: unknown
+  readonly createdAt: string
+  readonly updatedAt: string
+}
+
+/** What the owner of a running task holds. */
+export interface TaskHandle {
+  readonly id: string
+  /** Aborted when the task, or a task that owns it, is cancelled. */
+  readonly signal: AbortSignal
+  /** Record progress without changing the status. */
+  progress(detail: unknown): void
+  complete(result: unknown, detail?: unknown): void
+  fail(error: unknown, detail?: unknown): void
+}
+
+export interface TaskFilter {
+  readonly status?: TaskStatus
+  readonly parent?: string
+  readonly kind?: string
+}
+
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    tasks: Tasks
+  }
+
+  interface Events {
+    /** A task record changed (after the change was written). */
+    'tasks/changed'(record: TaskRecord): void
+  }
+}
+
+type Change = Partial<TaskRecord> & { readonly id: string }
+const changeOf = (change: TaskChange) => change as unknown as Change
+
+const FINAL: ReadonlySet<TaskStatus> = new Set(['completed', 'failed', 'cancelled', 'interrupted'])
+const message = (error: unknown) => (error instanceof Error ? error.message : String(error))
+
+export class Tasks extends Service {
+  readonly file: string
+  /** Tasks found running at startup and marked interrupted. */
+  readonly interrupted: readonly string[]
+  private readonly records = new Map<string, TaskRecord>()
+  private readonly controllers = new Map<string, AbortController>()
+
+  private readonly store: TaskStore
+  private readonly manifest: string | undefined
+
+  constructor(ctx: Context, config: TasksConfig = {}) {
+    super(ctx, 'tasks')
+    this.manifest = config.manifest
+    const opened = openStore(config.store ?? 'jsonl', ctx.appInstance.home)
+    this.file = opened.file
+    this.store = opened.store
+    // Disposers run newest first, so this one runs last: the store closes after pending work has been recorded.
+    ctx.effect(() => () => this.store.close(), 'tasks: close the store')
+    this.load()
+    const interrupted: string[] = []
+    for (const record of this.records.values()) {
+      if (record.status === 'running') {
+        this.write({
+          id: record.id,
+          status: 'interrupted',
+          error: 'the app stopped while this task was running',
+        })
+        interrupted.push(record.id)
+      }
+    }
+    this.interrupted = interrupted
+    // Work still running when the app stops is cancelled, so its owner's signal fires and the record says what happened.
+    ctx.effect(
+      () => () => {
+        for (const id of [...this.controllers.keys()])
+          this.finish(id, { status: 'cancelled', error: 'the app stopped' })
+      },
+      'tasks: cancel running work',
+    )
+  }
+
+  /** Start a task. The record is written before this returns. */
+  start(kind: string, input: unknown, options: { parent?: string } = {}): TaskHandle {
+    if (options.parent !== undefined && !this.records.has(options.parent))
+      throw new Error(`tasks: no task "${options.parent}" to own this one`)
+    const id = randomUUID()
+    const now = new Date().toISOString()
+    const controller = new AbortController()
+    if (options.parent !== undefined) {
+      const parentSignal = this.controllers.get(options.parent)?.signal
+      if (parentSignal?.aborted) controller.abort()
+    }
+    this.controllers.set(id, controller)
+    this.write({
+      id,
+      kind,
+      ...(options.parent === undefined ? {} : { parent: options.parent }),
+      ...(this.manifest === undefined ? {} : { manifest: this.manifest }),
+      input,
+      status: 'running',
+      createdAt: now,
+      updatedAt: now,
+    })
+    return {
+      id,
+      signal: controller.signal,
+      progress: (detail) => {
+        if (!this.isRunning(id)) return
+        this.write({ id, detail })
+      },
+      complete: (result, detail) =>
+        this.finish(id, {
+          status: 'completed',
+          result,
+          ...(detail === undefined ? {} : { detail }),
+        }),
+      fail: (error, detail) =>
+        this.finish(id, {
+          status: 'failed',
+          error: message(error),
+          ...(detail === undefined ? {} : { detail }),
+        }),
+    }
+  }
+
+  get(id: string): TaskRecord | undefined {
+    return this.records.get(id)
+  }
+
+  /** Records, newest first. */
+  list(filter: TaskFilter = {}): TaskRecord[] {
+    return [...this.records.values()]
+      .filter(
+        (record) =>
+          (filter.status === undefined || record.status === filter.status) &&
+          (filter.parent === undefined || record.parent === filter.parent) &&
+          (filter.kind === undefined || record.kind === filter.kind),
+      )
+      .sort((a, b) => (a.createdAt < b.createdAt ? 1 : a.createdAt > b.createdAt ? -1 : 0))
+  }
+
+  /** Cancel a running task and every running task it owns, children first. Returns the ids cancelled. */
+  cancel(id: string): string[] {
+    const cancelled: string[] = []
+    const visit = (taskId: string) => {
+      for (const child of this.list({ parent: taskId })) visit(child.id)
+      if (this.isRunning(taskId)) {
+        this.finish(taskId, { status: 'cancelled', error: 'cancelled' })
+        cancelled.push(taskId)
+      }
+    }
+    if (!this.records.has(id)) throw new Error(`tasks: no task "${id}"`)
+    visit(id)
+    return cancelled
+  }
+
+  private isRunning(id: string): boolean {
+    return this.records.get(id)?.status === 'running'
+  }
+
+  private finish(id: string, change: Omit<Change, 'id'>): void {
+    if (!this.isRunning(id)) return
+    this.write({ id, ...change })
+    const controller = this.controllers.get(id)
+    this.controllers.delete(id)
+    controller?.abort()
+  }
+
+  /** Append one change and apply it. The line is on disk before the record changes in memory. */
+  private write(change: Change): void {
+    const now = new Date().toISOString()
+    const line = { updatedAt: now, ...change }
+    this.store.append(line)
+    const record = this.apply(line)
+    this.ctx.emit('tasks/changed', record)
+  }
+
+  private apply(change: Change): TaskRecord {
+    const current = this.records.get(change.id)
+    const next = { ...(current ?? {}), ...change } as TaskRecord
+    if (current && FINAL.has(current.status) && change.status !== undefined) return current
+    this.records.set(change.id, next)
+    return next
+  }
+
+  private load(): void {
+    for (const change of this.store.load()) this.apply(changeOf(change))
+  }
+}
+
+/** The plugin: mount it after `instance`. */
+export const tasks = {
+  name: 'tasks',
+  inject: ['appInstance'],
+  apply(ctx: Context, config?: TasksConfig) {
+    new Tasks(ctx, config ?? {})
+  },
+}

package/plugins/tasks/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "tasks",
+  "description": "Durable task records: id, owner, input, status, result, trace; appended to a log in the app's home and readable after a restart.",
+  "requires": ["instance"],
+  "inject": ["appInstance"],
+  "provides": ["tasks"],
+  "dependencies": {
+    "@deepseek-ai/cordis": "4.0.4"
+  },
+  "mount": "mount it after instance: root.plugin(tasks, {}); the agent records every run as a task when it is present"
+}

package/plugins/tasks/store.ts

@@ -0,0 +1,86 @@
+/**
+ * Where task changes are kept. A store is an append-only log of changes: `append` must have made the change durable before it
+ * returns, and `load` returns every change in the order it was appended. The records are folded from the log, so a new backend only
+ * has to keep that promise; `store.test.ts` runs the same conformance suite against every backend.
+ */
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname } from 'node:path'
+
+/** One change to a task record: its id and the fields that changed. Stores treat it as opaque JSON. */
+export interface TaskChange {
+  readonly id: string
+  readonly [field: string]: unknown
+}
+
+export interface TaskStore {
+  /** Every change so far, oldest first. A change that was only partly written (a crash mid-append) is skipped. */
+  load(): TaskChange[]
+  /** Make one change durable. */
+  append(change: TaskChange): void
+  /** Release the file. */
+  close(): void
+}
+
+/** One JSON object per line in a text file. Easy to read, copy and diff. */
+export function jsonlStore(file: string): TaskStore {
+  return {
+    load() {
+      if (!existsSync(file)) return []
+      const changes: TaskChange[] = []
+      for (const line of readFileSync(file, 'utf8').split('\n')) {
+        if (line.trim() === '') continue
+        try {
+          changes.push(JSON.parse(line) as TaskChange)
+        } catch {
+          // A torn last line (the app stopped mid-write) is skipped; every complete line before it still counts.
+        }
+      }
+      return changes
+    },
+    append(change) {
+      mkdirSync(dirname(file), { recursive: true })
+      appendFileSync(file, `${JSON.stringify(change)}\n`)
+    },
+    close() {},
+  }
+}
+
+/** The pieces of `node:sqlite` used here. */
+interface Database {
+  exec(sql: string): void
+  prepare(sql: string): { run(...values: unknown[]): unknown; all(): Array<{ change: string }> }
+  close(): void
+}
+
+/**
+ * A SQLite file with one table, `task_changes(seq, id, change)`, appended to and never updated. Writes are synchronous with full
+ * durability (`synchronous = FULL`, write-ahead log), so a change is on disk before the call that made it returns. Uses Node's
+ * built-in `node:sqlite` (loaded only when this store is used, because Node marks it experimental and warns on load).
+ */
+export function sqliteStore(file: string): TaskStore {
+  mkdirSync(dirname(file), { recursive: true })
+  const { DatabaseSync } = createRequire(import.meta.url)('node:sqlite') as {
+    DatabaseSync: new (path: string) => Database
+  }
+  const db = new DatabaseSync(file)
+  db.exec('PRAGMA journal_mode = WAL; PRAGMA synchronous = FULL;')
+  db.exec(
+    'CREATE TABLE IF NOT EXISTS task_changes (seq INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL, change TEXT NOT NULL)',
+  )
+  const insert = db.prepare('INSERT INTO task_changes (id, change) VALUES (?, ?)')
+  const select = db.prepare('SELECT change FROM task_changes ORDER BY seq')
+  return {
+    load: () => select.all().map((row) => JSON.parse(row.change) as TaskChange),
+    append: (change) => void insert.run(change.id, JSON.stringify(change)),
+    close: () => db.close(),
+  }
+}
+
+export type StoreKind = 'jsonl' | 'sqlite'
+
+export function openStore(kind: StoreKind, directory: string): { store: TaskStore; file: string } {
+  const file = `${directory}/tasks.${kind === 'sqlite' ? 'sqlite' : 'jsonl'}`
+  return { store: kind === 'sqlite' ? sqliteStore(file) : jsonlStore(file), file }
+}

package/plugins/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "verbatimModuleSyntax": true,
+    "erasableSyntaxOnly": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["*/**/*.ts"]
+}

package/templates/agent/Dockerfile

@@ -0,0 +1,15 @@
+# A container for this app: the starter pack a hosting platform runs per user.
+#   docker build -t my-app .
+#   docker run -p 3100:3100 -v my-app-data:/data -e ACRYLBLENDS_MODEL_URL=... -e ACRYLBLENDS_MODEL=... -e ACRYLBLENDS_MODEL_KEY=... my-app
+# The app's own data (settings, installed extensions, the ledger, tasks) lives in /data: mount a volume there to keep what the agent built.
+FROM node:24-slim
+WORKDIR /app
+COPY package.json ./
+RUN npm install --no-audit --no-fund
+COPY . .
+ENV ACRYLBLENDS_HOME=/data ACRYLBLENDS_HOST=0.0.0.0 ACRYLBLENDS_PORT=3100
+RUN mkdir -p /data && chown -R node:node /data /app
+USER node
+VOLUME /data
+EXPOSE 3100
+CMD ["node", "src/main.ts"]

package/templates/agent/README.md

@@ -0,0 +1,52 @@
+# __APP_NAME__
+
+A Cordis app on Node, scaffolded by `acrylblends init`. TypeScript, run by Node with no build step. Every part is a
+Cordis plugin.
+
+```sh
+npm install
+npm run dev        # prints its URL; data lives in .acrylblends/
+npm test
+npm run check      # type-check
+
+curl -X POST <url>/ask -H 'content-type: application/json' -d '{"question":"add 2 3"}'
+# {"status":"completed","output":"The answer is 5.","steps":2}
+```
+
+- `src/main.ts` chooses where the app lives (`src/plugins/instance`) and starts it.
+- `blend.yaml` is the app as data: which plugins it mounts, in what order, with what config and parameters. Switch
+  one off with `disabled: true`. `npm run lock` writes `blend.lock.json`: the manifest's digest and a digest of
+  every plugin folder, so a diff of the lock shows what changed.
+- `src/app.ts` holds the registry of plugins the code provides, and mounts the manifest's rows.
+- `src/plugins/agent` is the offline agent: a scripted model, a tool registry, memory, and one child fiber per run.
+- `src/plugins/extensions` installs, updates and removes plugins while the app runs; a failed update keeps the previous
+  version running. `src/plugins/builder` gives the agent tools to do that itself, writing into `extensions/`.
+
+Give it a real model and it builds any Cordis plugin you describe (any OpenAI-compatible API; nothing is installed):
+
+```sh
+ACRYLBLENDS_MODEL_URL=https://api.deepseek.com/v1 ACRYLBLENDS_MODEL=deepseek-chat ACRYLBLENDS_MODEL_KEY=sk-... npm run dev
+ACRYLBLENDS_MODEL_URL=http://127.0.0.1:11434/v1 ACRYLBLENDS_MODEL=qwen2.5-coder npm run dev     # Ollama, no key
+curl -X POST <url>/ask -H 'content-type: application/json' -d '{"question":"add a GET /time route that returns the current time"}'
+```
+
+Without a model it runs offline with a scripted model that knows these commands:
+
+```sh
+curl -X POST <url>/ask -H 'content-type: application/json' -d '{"question":"create route hello /hello Hello"}'
+curl <url>/hello              # {"text":"Hello"}
+curl <url>/extensions         # what is installed, and its state
+curl <url>/tasks              # every run as a durable task, with the tool calls it owns
+```
+
+Other commands: `update route <name> <path> <text>`, `break plugin <name>` (shows the rollback), `remove plugin <name>`,
+`list plugins`. What the agent writes lands in `extensions/`, is part of your app, and starts again at the next start.
+- `src/routes.ts` is your own plugin: routes added inside `ctx.effect`.
+- `src/plugins/` holds the plugins copied from the ACRYLBLENDS library. They are yours now; edit them freely.
+  Add more with `acrylblends add <plugin>`.
+
+`npm run save -- "message"` commits the app with git (and pushes when it has a remote). It refuses a file that looks like
+it holds a secret, and refuses to push a private app (anything but `visibility: public` in `blend.yaml`) to a public
+remote.
+
+Set `ACRYLBLENDS_HOME` to keep data elsewhere, and `ACRYLBLENDS_PORT` to choose the first port tried.

package/templates/agent/blend.yaml

@@ -0,0 +1,58 @@
+# The app as data, in ACRYL's Blend format (blends.acryl.dev/v1alpha1): which plugins it mounts, in what order, with what config.
+# Edit this, not app.ts, to switch a plugin off (disabled: true) or change its config. `npm run lock` records what the app is built from.
+# Order matters: http comes before extensions, because installed extensions start again at boot and may add routes.
+apiVersion: blends.acryl.dev/v1alpha1
+kind: Blueprint
+metadata:
+  id: acrylblends.__APP_NAME__
+  name: __APP_NAME__
+  version: 0.1.0
+  visibility: private # `npm run save` never pushes a private app to a public remote
+spec:
+  runtime: cordis
+  parameters:
+    # 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 }
+    # 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.
+    approval: { type: boolean, default: false }
+  rows:
+    - id: tasks
+      name: tasks
+      config:
+        store: "{{parameters.taskStore}}"
+    - id: model
+      name: model
+    - id: tools
+      name: tools
+    - id: memory
+      name: memory
+    - id: agent
+      name: agent
+      config:
+        steps: "{{parameters.steps}}"
+    - id: http
+      name: http
+    - id: events
+      name: events
+      config:
+        topics: [tasks/changed, extensions/changed]
+    - id: sandbox
+      name: sandbox
+    - id: extensions
+      name: extensions
+      config:
+        approval: "{{parameters.approval}}"
+    - id: builder
+      name: builder
+    - id: save
+      name: save
+    - id: routes
+      name: routes
+    - id: server
+      name: server
+      config:
+        hostname: "{{parameters.hostname}}"

package/templates/agent/dockerignore

@@ -0,0 +1,3 @@
+node_modules/
+.acrylblends/
+.git/

package/templates/agent/gitignore

@@ -0,0 +1,2 @@
+node_modules/
+.acrylblends/

package/templates/agent/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "__APP_NAME__",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "start": "node src/main.ts",
+    "dev": "node --watch src/main.ts",
+    "test": "node --test",
+    "check": "tsc --noEmit",
+    "lock": "node src/plugins/manifest/lock.ts",
+    "save": "node src/plugins/save/cli.ts",
+    "upgrade": "node src/plugins/manifest/upgrade-cli.ts"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "6.0.3"
+  }
+}

package/templates/agent/src/app.ts

@@ -0,0 +1,98 @@
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Context, type Fiber } from '@deepseek-ai/cordis'
+import { agent, memory, model, tools } from './plugins/agent/index.ts'
+import { builder } from './plugins/builder/index.ts'
+import { events } from './plugins/events/index.ts'
+import { extensions } from './plugins/extensions/index.ts'
+import { http } from './plugins/http/index.ts'
+import { type AppInstance, instance } from './plugins/instance/index.ts'
+import {
+  blueprintsIn,
+  compose,
+  loadManifest,
+  type ParameterValue,
+} from './plugins/manifest/index.ts'
+import { type OpenAIConfig, openai } from './plugins/openai/index.ts'
+import { sandboxPlugin } from './plugins/sandbox/index.ts'
+import { save } from './plugins/save/index.ts'
+import { server } from './plugins/server/index.ts'
+import { tasks } from './plugins/tasks/index.ts'
+import { routes } from './routes.ts'
+
+/** The plugins this app's code provides. `blend.yaml` chooses, orders and configures them. */
+export const registry = {
+  tasks,
+  model,
+  tools,
+  memory,
+  agent,
+  http,
+  events,
+  extensions,
+  builder,
+  save,
+  sandbox: sandboxPlugin,
+  routes,
+  server,
+}
+
+/** The manifest next to this app's source. */
+export const MANIFEST = join(fileURLToPath(new URL('..', import.meta.url)), 'blend.yaml')
+
+/**
+ * The app's manifest, resolved. A Blend finds its Blueprint in `blueprints/<id>.yaml`; an app that is itself a Blueprint never looks.
+ * `createApp` and the tests read it the same way.
+ */
+export function readManifest(values?: Readonly<Record<string, ParameterValue>>) {
+  return loadManifest(MANIFEST, {
+    known: Object.keys(registry),
+    getBlueprint: blueprintsIn(join(fileURLToPath(new URL('..', import.meta.url)), 'blueprints')),
+    ...(values ? { values } : {}),
+  })
+}
+
+export interface App {
+  readonly root: Context
+  readonly url: string
+  stop(): Promise<void>
+}
+
+/**
+ * The app: `instance` first (where it lives, chosen at run time), then the manifest's rows in order. The app's own `extensions/`
+ * folder is trusted to install at start, and is where the builder writes.
+ */
+export async function createApp(
+  chosen: AppInstance,
+  options: {
+    values?: Readonly<Record<string, ParameterValue>>
+    /** A real model (any OpenAI-compatible API) in place of the offline scripted one. */
+    model?: OpenAIConfig
+  } = {},
+): Promise<App> {
+  const manifest = readManifest(options.values)
+  const extensionsDir = join(chosen.root, 'extensions')
+  const root = new Context()
+  const first = root.plugin(instance, chosen)
+  await first.await()
+  const fibers: Fiber[] = [
+    first,
+    // The `model` row mounts the scripted model, or the real one when a model is configured.
+    ...(await compose(root, manifest, options.model ? { ...registry, model: openai } : registry, {
+      ...(options.model ? { model: { ...options.model } } : {}),
+      // Runtime values the manifest cannot hold: the manifest's own digest (every task records it), and who may install.
+      tasks: { manifest: `sha256:${manifest.digest}` },
+      // The `approval` parameter in blend.yaml (the extensions row) turns this source into one that asks.
+      extensions: { sources: [{ dir: extensionsDir, trust: 'install' }] },
+      builder: { dir: extensionsDir },
+      server: { port: chosen.port.start, scan: chosen.port.scan, hostname: chosen.host },
+    })),
+  ]
+  return {
+    root,
+    url: root.server.url,
+    async stop() {
+      for (const fiber of [...fibers].reverse()) await fiber.dispose()
+    },
+  }
+}

package/templates/agent/src/main.ts

@@ -0,0 +1,25 @@
+import { fileURLToPath } from 'node:url'
+import { createApp } from './app.ts'
+import { selectInstance } from './plugins/instance/index.ts'
+import { modelConfigFrom } from './plugins/openai/index.ts'
+import { APP_NAME } from './routes.ts'
+
+// The composition root: the one place that reads the environment. selectInstance chooses where the app lives;
+// modelConfigFrom picks a real model when ACRYLBLENDS_MODEL_URL and ACRYLBLENDS_MODEL are set (ACRYLBLENDS_MODEL_KEY for hosted APIs).
+const chosen = selectInstance({
+  projectRoot: fileURLToPath(new URL('..', import.meta.url)),
+  env: process.env,
+})
+const model = modelConfigFrom(process.env)
+const app = await createApp(chosen, model ? { model } : {})
+console.log(
+  `${APP_NAME} listening on ${app.url} (data in ${chosen.home}; model: ${model ? `${model.model} at ${model.baseUrl}` : 'offline scripted'})`,
+)
+
+const stop = async () => {
+  await app.stop()
+  console.log('stopped')
+  process.exit(0)
+}
+process.once('SIGINT', stop)
+process.once('SIGTERM', stop)