acrylblends 0.0.0-stage → 0.2.0

package/templates/agent/src/routes.ts

@@ -0,0 +1,62 @@
+import type { Context } from '@deepseek-ai/cordis'
+import type {} from './plugins/agent/index.ts'
+import type {} from './plugins/extensions/index.ts'
+import type {} from './plugins/http/index.ts'
+import type {} from './plugins/tasks/index.ts'
+
+export const APP_NAME = '__APP_NAME__'
+
+/**
+ * The app's own routes: `POST /ask` for the agent; `GET /extensions` and `GET /tasks` to observe what it did (every run is a durable
+ * task owning one task per tool call); `POST /tasks/cancel`. Each route lives in a `ctx.effect`.
+ */
+export const routes = {
+  name: 'routes',
+  inject: ['http', 'agent', 'extensions', 'tasks'],
+  apply(ctx: Context) {
+    ctx.effect(() => ctx.http.route('GET', '/', () => ({ body: { app: APP_NAME, ok: true } })))
+    ctx.effect(() => ctx.http.route('GET', '/health', () => ({ body: { ok: true } })))
+    ctx.effect(() =>
+      ctx.http.route('GET', '/extensions', () => ({
+        body: {
+          installed: ctx.extensions.list(),
+          notInstalled: ctx.extensions.pending(),
+          waitingForApproval: ctx.extensions.approvals(),
+        },
+      })),
+    )
+    // The owner's decision on an install that is waiting (the `approval` parameter in blend.yaml).
+    for (const [path, decide] of [
+      ['/extensions/approve', (name: string) => ctx.extensions.approve(name)],
+      ['/extensions/deny', (name: string) => ctx.extensions.deny(name)],
+    ] as const) {
+      ctx.effect(() =>
+        ctx.http.route('POST', path, async ({ body }) => {
+          const name = (body as { name?: unknown } | undefined)?.name
+          if (typeof name !== 'string')
+            return { status: 400, body: { error: 'name must be a string' } }
+          return { body: await decide(name) }
+        }),
+      )
+    }
+    ctx.effect(() =>
+      ctx.http.route('GET', '/tasks', () => ({ body: ctx.tasks.list().slice(0, 100) })),
+    )
+    ctx.effect(() =>
+      ctx.http.route('POST', '/tasks/cancel', ({ body }) => {
+        const id = (body as { id?: unknown } | undefined)?.id
+        if (typeof id !== 'string' || !ctx.tasks.get(id))
+          return { status: 404, body: { error: 'no such task' } }
+        return { body: { cancelled: ctx.tasks.cancel(id) } }
+      }),
+    )
+    ctx.effect(() =>
+      ctx.http.route('POST', '/ask', async ({ body }) => {
+        const question = (body as { question?: unknown } | undefined)?.question
+        if (typeof question !== 'string')
+          return { status: 400, body: { error: 'question must be a string' } }
+        return { body: await ctx.agent.run(question) }
+      }),
+    )
+  },
+}

package/templates/agent/template.json

@@ -0,0 +1,16 @@
+{
+  "plugins": [
+    "instance",
+    "http",
+    "events",
+    "server",
+    "tasks",
+    "agent",
+    "openai",
+    "sandbox",
+    "extensions",
+    "builder",
+    "manifest",
+    "save"
+  ]
+}

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

@@ -0,0 +1,45 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { fileURLToPath } from 'node:url'
+import { type App, createApp } from '../src/app.ts'
+import { pinnedInstance, withPort } from '../src/plugins/instance/index.ts'
+
+const projectRoot = fileURLToPath(new URL('..', import.meta.url))
+
+async function withApp(run: (app: App) => Promise<void>) {
+  const home = await mkdtemp(join(tmpdir(), 'agent-test-'))
+  const app = await createApp(withPort(pinnedInstance(home, { root: projectRoot }), 0))
+  try {
+    await run(app)
+  } finally {
+    await app.stop()
+    await rm(home, { recursive: true, force: true })
+  }
+}
+
+const ask = (app: App, body: unknown) =>
+  fetch(`${app.url}/ask`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+
+test('the agent uses a tool and answers over HTTP', () =>
+  withApp(async (app) => {
+    const answer = (await (await ask(app, { question: 'add 2 3' })).json()) as {
+      output: string
+      trace: unknown[]
+    }
+    assert.equal(answer.output, 'The answer is 5.')
+    assert.deepEqual(answer.trace, [{ tool: 'add', input: [2, 3], result: 5 }])
+  }))
+
+test('a body without a question is refused', () =>
+  withApp(async (app) => {
+    const response = await ask(app, {})
+    assert.equal(response.status, 400)
+    await response.body?.cancel()
+  }))

package/templates/agent/test/app.test.ts

@@ -0,0 +1,46 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { fileURLToPath } from 'node:url'
+import { type App, createApp } from '../src/app.ts'
+import { pinnedInstance, withPort } from '../src/plugins/instance/index.ts'
+import { APP_NAME } from '../src/routes.ts'
+
+const projectRoot = fileURLToPath(new URL('..', import.meta.url))
+
+/** Boot the app in a throwaway home on any free port, run the test, always stop it and remove the home. */
+async function withApp(run: (app: App) => Promise<void>) {
+  const home = await mkdtemp(join(tmpdir(), 'app-test-'))
+  const app = await createApp(withPort(pinnedInstance(home, { root: projectRoot }), 0))
+  try {
+    await run(app)
+  } finally {
+    await app.stop()
+    await rm(home, { recursive: true, force: true })
+  }
+}
+
+test('serves the index route', () =>
+  withApp(async (app) => {
+    const response = await fetch(`${app.url}/`)
+    assert.equal(response.status, 200)
+    assert.deepEqual(await response.json(), { app: APP_NAME, ok: true })
+  }))
+
+test('answers health checks and 404 for unknown paths', () =>
+  withApp(async (app) => {
+    assert.equal((await fetch(`${app.url}/health`)).status, 200)
+    const missing = await fetch(`${app.url}/nope`)
+    assert.equal(missing.status, 404)
+    await missing.body?.cancel()
+  }))
+
+test('stops listening when stopped', async () => {
+  const home = await mkdtemp(join(tmpdir(), 'app-test-'))
+  const app = await createApp(withPort(pinnedInstance(home, { root: projectRoot }), 0))
+  await app.stop()
+  await assert.rejects(fetch(`${app.url}/health`))
+  await rm(home, { recursive: true, force: true })
+})

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

@@ -0,0 +1,186 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { createApp } from '../src/app.ts'
+import { pinnedInstance, withPort } from '../src/plugins/instance/index.ts'
+
+/** The agent extends the running app through POST /ask; a restart keeps what it built. */
+test('the agent builds, updates, protects and removes a plugin in the running app, and a restart keeps it', async () => {
+  const project = await mkdtemp(join(tmpdir(), 'builder-project-'))
+  const chosen = withPort(pinnedInstance(join(project, '.acrylblends'), { root: project }), 0)
+  let app = await createApp(chosen)
+  const ask = async (question: string) => {
+    const response = await fetch(`${app.url}/ask`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ question }),
+    })
+    return ((await response.json()) as { output: string }).output
+  }
+  const hello = async () => {
+    const response = await fetch(`${app.url}/hello`)
+    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')
+
+    // The broken version stays on disk, so put the working one back before restarting.
+    await ask('update route hello /hello Bonjour')
+    await app.stop()
+    app = await createApp(chosen)
+    assert.equal(await hello(), 'Bonjour')
+
+    assert.equal(await ask('remove plugin hello'), 'hello: done.')
+    assert.equal(await hello(), 404)
+
+    // Every run is a durable task that owns its tool calls, and the records survived the restart.
+    const records = (await (await fetch(`${app.url}/tasks`)).json()) as Array<{
+      kind: string
+      status: string
+      parent?: string
+    }>
+    const runs = records.filter((record) => record.kind === 'agent-run')
+    assert.equal(runs.length, 5)
+    assert.ok(runs.every((run) => run.status === 'completed'))
+    assert.ok(
+      records.some(
+        (record) => record.kind === 'tool:install_plugin' && record.parent !== undefined,
+      ),
+    )
+  } finally {
+    await app.stop()
+    await rm(project, { recursive: true, force: true })
+  }
+})
+
+test('with approval on, an install waits for the owner; approving it makes it live', async () => {
+  const project = await mkdtemp(join(tmpdir(), 'approval-project-'))
+  const chosen = withPort(pinnedInstance(join(project, '.acrylblends'), { root: project }), 0)
+  const app = await createApp(chosen, { values: { approval: true } })
+  const post = async (path: string, body: unknown) =>
+    (await (
+      await fetch(`${app.url}${path}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+      })
+    ).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.",
+    )
+    assert.equal((await fetch(`${app.url}/hello`)).status, 404)
+    const listed = (await (await fetch(`${app.url}/extensions`)).json()) as {
+      waitingForApproval: Array<{ name: string }>
+    }
+    assert.deepEqual(
+      listed.waitingForApproval.map((request) => request.name),
+      ['hello'],
+    )
+    assert.equal(
+      ((await post('/extensions/approve', { name: 'hello' })) as { state?: string }).state,
+      'active',
+    )
+    assert.deepEqual(await (await fetch(`${app.url}/hello`)).json(), { text: 'Hello' })
+    const tasks = (await (await fetch(`${app.url}/tasks`)).json()) as Array<{ manifest?: string }>
+    assert.ok(
+      tasks.length > 0 && tasks.every((task) => /^sha256:[0-9a-f]{64}$/.test(task.manifest ?? '')),
+    )
+  } finally {
+    await app.stop()
+    await rm(project, { recursive: true, force: true })
+  }
+})
+
+test('the agent builds a sandboxed tool, calls it, and the sandbox refuses a tool that reads outside its folder', async () => {
+  const project = await mkdtemp(join(tmpdir(), 'tool-project-'))
+  const chosen = withPort(pinnedInstance(join(project, '.acrylblends'), { root: project }), 0)
+  const app = await createApp(chosen)
+  const ask = async (question: string) =>
+    (
+      (await (
+        await fetch(`${app.url}/ask`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ question }),
+        })
+      ).json()) as { output: string }
+    ).output
+  try {
+    assert.equal(await ask('create tool triple 3'), 'triple: installed, active.')
+    assert.equal(await ask('run tool triple 14'), '{"n":42}')
+    const refused = await ask('spy tool snoop')
+    assert.match(refused, /^Refused: its check failed: denied:/)
+    const listed = (await (await fetch(`${app.url}/extensions`)).json()) as {
+      installed: Array<{ name: string }>
+    }
+    assert.deepEqual(
+      listed.installed.map((extension) => extension.name),
+      ['triple'],
+    )
+  } finally {
+    await app.stop()
+    await rm(project, { recursive: true, force: true })
+  }
+})
+
+test('GET /events streams what happens: the run as a task, and the install as an extension change', async () => {
+  const project = await mkdtemp(join(tmpdir(), 'events-project-'))
+  const chosen = withPort(pinnedInstance(join(project, '.acrylblends'), { root: project }), 0)
+  const app = await createApp(chosen)
+  const controller = new AbortController()
+  try {
+    const stream = await fetch(`${app.url}/events`, { signal: controller.signal })
+    const reader = stream.body!.getReader()
+    const decoder = new TextDecoder()
+    let text = ''
+    const seen = (what: RegExp) => what.test(text)
+    const pump = (async () => {
+      for (;;) {
+        const { value, done } = await reader.read()
+        if (done) return
+        text += decoder.decode(value, { stream: true })
+      }
+    })().catch(() => undefined)
+    await fetch(`${app.url}/ask`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ question: 'create route hello /hello Hello' }),
+    })
+    for (
+      let waited = 0;
+      waited < 3000 && !seen(/event: extensions\/changed\ndata: [^\n]*"installed"/);
+      waited += 25
+    ) {
+      await new Promise((done) => setTimeout(done, 25))
+    }
+    assert.ok(seen(/event: connected/), 'connected')
+    assert.ok(
+      seen(/event: tasks\/changed\ndata: [^\n]*"kind":"agent-run"[^\n]*"status":"running"/),
+      'the run starts as a task',
+    )
+    assert.ok(
+      seen(/event: tasks\/changed\ndata: [^\n]*"kind":"tool:install_plugin"/),
+      'the install is a task',
+    )
+    assert.ok(
+      seen(/event: extensions\/changed\ndata: \{"args":\["hello","installed"\]\}/),
+      'the extension is reported',
+    )
+    controller.abort()
+    await pump
+  } finally {
+    await app.stop()
+    await rm(project, { recursive: true, force: true })
+  }
+})

package/templates/agent/test/model.test.ts

@@ -0,0 +1,89 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { createServer } from 'node:http'
+import type { AddressInfo } from 'node:net'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { createApp } from '../src/app.ts'
+import { pinnedInstance, withPort } from '../src/plugins/instance/index.ts'
+
+/** A plugin no scripted command knows: the model writes it from scratch. */
+const COUNTER = `import type { Context } from '@deepseek-ai/cordis'
+export const name = 'counter'
+export const inject = ['http']
+export function apply(ctx: Context) {
+  let count = 0
+  const http = ctx.get('http') as { route(m: string, p: string, h: () => { body: unknown }): () => void }
+  ctx.effect(() => http.route('GET', '/count', () => ({ body: { count: ++count } })))
+}
+`
+
+/** Stands in for a real model API: plans write_plugin, then install_plugin, then answers. */
+async function modelApi() {
+  const replies = [
+    {
+      tool_calls: [
+        {
+          id: '1',
+          type: 'function',
+          function: {
+            name: 'write_plugin',
+            arguments: JSON.stringify({ name: 'counter', files: { 'index.ts': COUNTER } }),
+          },
+        },
+      ],
+    },
+    {
+      tool_calls: [
+        {
+          id: '2',
+          type: 'function',
+          function: { name: 'install_plugin', arguments: '{"name":"counter"}' },
+        },
+      ],
+    },
+    { content: 'I built a counter: GET /count.' },
+  ]
+  const server = createServer(async (request, response) => {
+    for await (const _ of request) {
+      // the body is not needed: the replies are in order
+    }
+    response.writeHead(200, { 'content-type': 'application/json' })
+    response.end(
+      JSON.stringify({ choices: [{ message: replies.shift() ?? { content: 'no more' } }] }),
+    )
+  })
+  await new Promise<void>((done) => server.listen(0, '127.0.0.1', done))
+  return {
+    url: `http://127.0.0.1:${(server.address() as AddressInfo).port}/v1`,
+    close: () => new Promise<void>((done) => server.close(() => done())),
+  }
+}
+
+test('with a real model, the agent writes a new Cordis plugin and the running app serves it', async () => {
+  const api = await modelApi()
+  const project = await mkdtemp(join(tmpdir(), 'model-project-'))
+  const app = await createApp(
+    withPort(pinnedInstance(join(project, '.acrylblends'), { root: project }), 0),
+    {
+      model: { baseUrl: api.url, model: 'test' },
+    },
+  )
+  try {
+    const answer = await (
+      await fetch(`${app.url}/ask`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ question: 'add a counter route' }),
+      })
+    ).json()
+    assert.equal((answer as { output: string }).output, 'I built a counter: GET /count.')
+    assert.deepEqual(await (await fetch(`${app.url}/count`)).json(), { count: 1 })
+    assert.deepEqual(await (await fetch(`${app.url}/count`)).json(), { count: 2 })
+  } finally {
+    await app.stop()
+    await api.close()
+    await rm(project, { recursive: true, force: true })
+  }
+})

package/templates/agent/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": ["src", "test", "extensions"]
+}

package/templates/app/README.md

@@ -0,0 +1,26 @@
+# __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
+```
+
+- `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/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/app/blend.yaml

@@ -0,0 +1,23 @@
+# 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.
+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 }
+  rows:
+    - id: http
+      name: http
+    - id: routes
+      name: routes
+    - id: server
+      name: server
+      config:
+        hostname: "{{parameters.hostname}}"

package/templates/app/gitignore

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

package/templates/app/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/app/src/app.ts

@@ -0,0 +1,61 @@
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Context, type Fiber } from '@deepseek-ai/cordis'
+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 { server } from './plugins/server/index.ts'
+import { routes } from './routes.ts'
+
+/** The plugins this app's code provides. `blend.yaml` chooses, orders and configures them. */
+export const registry = { http, 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. */
+export async function createApp(
+  chosen: AppInstance,
+  options: { values?: Readonly<Record<string, ParameterValue>> } = {},
+): Promise<App> {
+  const manifest = readManifest(options.values)
+  const root = new Context()
+  const first = root.plugin(instance, chosen)
+  await first.await()
+  const fibers: Fiber[] = [
+    first,
+    ...(await compose(root, manifest, registry, {
+      server: { port: chosen.port.start, scan: chosen.port.scan },
+    })),
+  ]
+  return {
+    root,
+    url: root.server.url,
+    async stop() {
+      for (const fiber of [...fibers].reverse()) await fiber.dispose()
+    },
+  }
+}

package/templates/app/src/main.ts

@@ -0,0 +1,20 @@
+import { fileURLToPath } from 'node:url'
+import { createApp } from './app.ts'
+import { selectInstance } from './plugins/instance/index.ts'
+import { APP_NAME } from './routes.ts'
+
+// The composition root: the one place that reads the environment (through selectInstance) and chooses where the app lives.
+const chosen = selectInstance({
+  projectRoot: fileURLToPath(new URL('..', import.meta.url)),
+  env: process.env,
+})
+const app = await createApp(chosen)
+console.log(`${APP_NAME} listening on ${app.url} (data in ${chosen.home})`)
+
+const stop = async () => {
+  await app.stop()
+  console.log('stopped')
+  process.exit(0)
+}
+process.once('SIGINT', stop)
+process.once('SIGTERM', stop)

package/templates/app/src/routes.ts

@@ -0,0 +1,14 @@
+import type { Context } from '@deepseek-ai/cordis'
+import type {} from './plugins/http/index.ts'
+
+export const APP_NAME = '__APP_NAME__'
+
+/** The app's own routes. Each one lives in a `ctx.effect`, so it is removed when this plugin is disposed. */
+export const routes = {
+  name: 'routes',
+  inject: ['http'],
+  apply(ctx: Context) {
+    ctx.effect(() => ctx.http.route('GET', '/', () => ({ body: { app: APP_NAME, ok: true } })))
+    ctx.effect(() => ctx.http.route('GET', '/health', () => ({ body: { ok: true } })))
+  },
+}

package/templates/app/template.json

@@ -0,0 +1 @@
+{ "plugins": ["instance", "http", "server", "manifest", "save"] }