@love-moon/app-sdk 0.3.2

package/examples/01_example/.env.example

@@ -0,0 +1,17 @@
+# Copy to .env (or export inline) before running.
+
+# Conductor backend (no trailing slash). Default is local dev.
+CONDUCTOR_BASE_URL=http://localhost:6152
+
+# API token from Conductor → Settings → API Tokens.
+# Keep this secret. The CLI runs entirely server-side, so it stays out of
+# any browser.
+CONDUCTOR_TOKEN=ct_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+# Which daemon + workspace this CLI should run AI work against.
+# The daemon must already be online and have reported the workspace path.
+CONDUCTOR_DAEMON_HOST=duino-mbp
+CONDUCTOR_WORKSPACE_PATH=/Users/me/work/acme
+
+# Display name stamped on the project when it's first created.
+CONDUCTOR_APP_NAME=App SDK CLI Example

package/examples/01_example/README.md

@@ -0,0 +1,80 @@
+# Minimal CLI example
+
+The smallest possible app using `@love-moon/app-sdk`. About **35 lines of
+business code** to:
+
+1. Connect to a Conductor backend with a user token.
+2. Find-or-create a project bound to a daemon + workspace.
+3. Create an AI task.
+4. Read one prompt from stdin, send it, stream the AI reply to stdout.
+
+Pure Node — no React, no BFF, no web server. Use this to learn what the SDK
+does end-to-end before integrating it into your own app.
+
+> For a full-stack browser demo (BFF + React widget + SSE bridge), see
+> the sibling [`../02_bff/`](../02_bff/).
+
+## Setup
+
+```bash
+# 1. Build the SDK so the file: dependency resolves.
+cd ../..  # → modules/app-sdk
+npm install
+npm run build
+
+# 2. Install the example's local file: link.
+cd examples/01_example
+npm install
+
+# 3. Configure.
+cp .env.example .env
+$EDITOR .env
+
+# 4. Run. (Either source .env yourself or use a tool like dotenv-cli.)
+export $(cat .env | grep -v '^#' | xargs)
+npm start
+```
+
+Prerequisites: a running Conductor backend (default `http://localhost:6152`)
+and an online daemon registered for the configured workspace.
+
+## Sample session
+
+```text
+→ connecting to http://localhost:6152
+→ binding project "App SDK CLI Example" on duino-mbp:/Users/me/work/acme
+  project p_abc123 (reused)
+You: list the three biggest files in this repo
+→ creating task
+  task t_xyz789
+
+AI:
+Sure — looking at the workspace…
+1. web/src/app/api/projects/route.ts (998 lines)
+2. web/src/lib/realtime/agent-gateway.ts (...)
+3. ...
+```
+
+## What it deliberately doesn't do
+
+- **No multi-turn loop**: sends one prompt and exits. A real CLI would loop
+  on stdin with `client.tasks.sendMessage(taskId, content)` for each turn.
+- **No interrupt UI**: nothing reads Ctrl+C to call `tasks.interrupt()`.
+- **No error retry**: on transient `network_error` it just exits with code 1.
+
+These are intentionally out of scope — the example is a teaching tool, not
+a finished product. The SDK supports all of them; see `../../README.md`.
+
+## Code walkthrough
+
+[`chat-cli.mjs`](./chat-cli.mjs) is annotated inline. The four SDK calls
+are:
+
+```js
+const client  = await connect({ baseUrl, bearerToken });
+const project = await client.projects.bind({ name, daemonHost, workspacePath });
+const task    = await client.tasks.create({ projectId: project.id, title, initialMessage });
+for await (const delta of client.tasks.streamReply(task.id)) { /* … */ }
+```
+
+Everything else (env parsing, stdin readline, terminal output) is plain Node.

package/examples/01_example/chat-cli.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * Minimal CLI app: chat with your Conductor daemon from a terminal.
+ *
+ * What it shows: the four moves any third-party server-side integration
+ * needs to perform.
+ *
+ *   1. connect()                  — open an AppClient with a Conductor token.
+ *   2. client.projects.bind()     — idempotent find-or-create of the
+ *                                   project (daemon + workspace pair).
+ *   3. client.tasks.create()      — start a new AI conversation in that
+ *                                   project.
+ *   4. client.tasks.streamReply() — stream the AI reply token-preview by
+ *                                   token-preview to stdout. (Send a
+ *                                   message first via tasks.sendMessage,
+ *                                   or use `initialMessage` on create.)
+ *
+ * Total business code: ~35 lines (the rest is config + UX).
+ */
+
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout, exit, env } from 'node:process';
+import { connect } from '@love-moon/app-sdk/server';
+
+function readRequired(key) {
+  const v = env[key];
+  if (!v) {
+    console.error(`Missing env var ${key}. See README for setup.`);
+    exit(1);
+  }
+  return v;
+}
+
+const config = {
+  baseUrl: env.CONDUCTOR_BASE_URL ?? 'http://localhost:6152',
+  token: readRequired('CONDUCTOR_TOKEN'),
+  daemonHost: readRequired('CONDUCTOR_DAEMON_HOST'),
+  workspacePath: readRequired('CONDUCTOR_WORKSPACE_PATH'),
+  appName: env.CONDUCTOR_APP_NAME ?? 'App SDK CLI Example',
+};
+
+async function main() {
+  console.log(`→ connecting to ${config.baseUrl}`);
+  const client = await connect({
+    baseUrl: config.baseUrl,
+    bearerToken: config.token,
+    onUnauthorized: () => console.error('! token rejected (401)'),
+  });
+
+  console.log(`→ binding project "${config.appName}" on ${config.daemonHost}:${config.workspacePath}`);
+  const project = await client.projects.bind({
+    name: config.appName,
+    daemonHost: config.daemonHost,
+    workspacePath: config.workspacePath,
+  });
+  console.log(`  project ${project.id} (${project.createdByApp ? 'created' : 'reused'})`);
+
+  // Prompt the user for the initial message right away, so the task is
+  // created with content and the AI starts working immediately.
+  const rl = createInterface({ input: stdin, output: stdout });
+  const prompt = await rl.question('You: ');
+  rl.close();
+  if (!prompt.trim()) {
+    console.log('(empty input — nothing to do)');
+    await client.close();
+    return;
+  }
+
+  console.log(`→ creating task`);
+  const task = await client.tasks.create({
+    projectId: project.id,
+    title: prompt.slice(0, 60),
+    initialMessage: prompt,
+  });
+  console.log(`  task ${task.id}`);
+
+  // Stream the AI reply. streamReply yields cumulative text previews; we
+  // print only the new tail each time so the terminal shows a smooth flow.
+  console.log('\nAI:');
+  let printedSoFar = '';
+  for await (const delta of client.tasks.streamReply(task.id)) {
+    if (delta.type === 'text') {
+      // The first delta is the full preview-so-far; later deltas are
+      // already diffed by the SDK. Most of the time the cumulative preview
+      // grows monotonically, but the backend may emit a reset (e.g. a tool
+      // call replaces the text). When that happens we print the whole new
+      // text rather than a corrupt slice.
+      stdout.write(delta.text);
+      if (delta.text && delta.text.startsWith(printedSoFar)) {
+        printedSoFar = delta.text;
+      } else {
+        // Reset path: the SDK already detected a non-continuation and is
+        // handing us the FULL new preview as `delta.text`, not an
+        // incremental tail. Tracking `printedSoFar + delta.text` here would
+        // double-count and corrupt the prefix used by the 'done' fill-in
+        // below.
+        printedSoFar = delta.text;
+      }
+    } else if (delta.type === 'done') {
+      // streamReply guarantees a single 'done' carrying the persisted message.
+      // If the rolling previews missed any trailing characters, fill them in
+      // (only when the persisted content is a continuation of what we printed).
+      const full = delta.message.content;
+      if (full.startsWith(printedSoFar) && printedSoFar.length < full.length) {
+        stdout.write(full.slice(printedSoFar.length));
+      }
+      stdout.write('\n');
+      break;
+    } else if (delta.type === 'error') {
+      stdout.write(`\n! AI failed: ${delta.error.message}\n`);
+      break;
+    }
+    // 'status' deltas are ignored in this minimal example.
+  }
+
+  await client.close();
+}
+
+main().catch((err) => {
+  // ConductorAppError has a stable `code` field for branching; for a CLI we
+  // just print message + code.
+  const code = err?.code ? ` [${err.code}]` : '';
+  console.error(`\n! ${err.message ?? err}${code}`);
+  exit(1);
+});

package/examples/01_example/package-lock.json

@@ -0,0 +1,52 @@
+{
+  "name": "conductor-app-sdk-cli-example",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "conductor-app-sdk-cli-example",
+      "version": "0.0.0",
+      "dependencies": {
+        "@love-moon/app-sdk": "file:../.."
+      }
+    },
+    "../..": {
+      "name": "@love-moon/app-sdk",
+      "version": "0.1.0",
+      "dependencies": {
+        "ws": "^8.18.0",
+        "zod": "^3.24.1"
+      },
+      "devDependencies": {
+        "@types/node": "^22.10.2",
+        "@types/react": "^19.0.0",
+        "@types/react-dom": "^19.0.0",
+        "@types/ws": "^8.5.12",
+        "@vitejs/plugin-react": "^4.3.4",
+        "jsdom": "^25.0.1",
+        "react": "^19.0.0",
+        "react-dom": "^19.0.0",
+        "tsup": "^8.3.5",
+        "typescript": "^5.6.3",
+        "vitest": "^2.1.4"
+      },
+      "peerDependencies": {
+        "react": ">=18.0.0",
+        "react-dom": ">=18.0.0"
+      },
+      "peerDependenciesMeta": {
+        "react": {
+          "optional": true
+        },
+        "react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@love-moon/app-sdk": {
+      "resolved": "../..",
+      "link": true
+    }
+  }
+}

package/examples/01_example/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "conductor-app-sdk-cli-example",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Minimal CLI app that talks to a user's Conductor daemon via @love-moon/app-sdk.",
+  "type": "module",
+  "scripts": {
+    "start": "node chat-cli.mjs"
+  },
+  "dependencies": {
+    "@love-moon/app-sdk": "file:../.."
+  }
+}

package/examples/02_bff/.env.example

@@ -0,0 +1,16 @@
+# Copy to .env.local and fill in.
+
+# Conductor backend base URL (no trailing slash).
+CONDUCTOR_BASE_URL=http://localhost:6152
+
+# API token issued from Conductor Settings → API Tokens.
+# IMPORTANT: keep this server-side only. Never embed in client code.
+CONDUCTOR_TOKEN=ct_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+# The daemon + workspace this app should run AI tasks against.
+# Must already be online + registered with Conductor.
+CONDUCTOR_DAEMON_HOST=duino-mbp
+CONDUCTOR_WORKSPACE_PATH=/Users/me/work/acme
+
+# The display name shown to the user inside Conductor for this app.
+CONDUCTOR_APP_NAME=App SDK Demo

package/examples/02_bff/README.md

@@ -0,0 +1,63 @@
+# Conductor App SDK — end-to-end demo
+
+A tiny Next.js app that uses `@love-moon/app-sdk` to embed a chat with a
+user's Conductor AI tool. **Total business code: ~120 lines.**
+
+```
+┌─────────────────┐      ┌─────────────────┐      ┌──────────────────────┐
+│  browser:       │      │  /api/conductor │      │  Conductor backend   │
+│  <ChatView />   │ ──── │  Next.js BFF    │ ──── │  + /ws/app + daemon  │
+│  + REST adapter │ SSE  │  app-sdk/server │      │                      │
+└─────────────────┘      └─────────────────┘      └──────────────────────┘
+```
+
+## Run it
+
+```bash
+# 1. Build the SDK (the example uses file: link to ../..).
+cd ../.. && npm run build && cd -
+
+# 2. Install + start.
+npm install
+cp .env.example .env.local
+$EDITOR .env.local          # fill in CONDUCTOR_TOKEN + DAEMON_HOST + WORKSPACE_PATH
+npm run dev                 # → http://localhost:3001
+```
+
+You need a running Conductor backend (typically `http://localhost:6152` via
+`cd web && pnpm dev`) and an online daemon (typically `make debug-cli`).
+
+## What it shows
+
+| File | Concern |
+| --- | --- |
+| `lib/conductor.ts` | Server-side singleton `AppClient`; `projects.bind()` to find-or-create the demo project (idempotent). |
+| `app/api/conductor/bind/route.ts` | Page bootstrap: bind project + create a fresh task; return ids. |
+| `app/api/conductor/[...path]/route.ts` | Catch-all BFF that forwards 4 routes to Conductor:<br>• `GET /tasks/:id/messages` → `tasks.history()`<br>• `POST /tasks/:id/messages` → `tasks.sendMessage()`<br>• `POST /tasks/:id/interrupt` → `tasks.interrupt()`<br>• `GET /tasks/:id/events` → SSE bridge over `tasks.subscribe()` |
+| `app/page.tsx` | React page: bootstrap, mount `<ChatView />`. |
+
+The SSE bridge (~30 lines in the catch-all) is the most interesting piece —
+that's how the SDK's server-side AsyncIterable becomes a client-side
+EventSource without needing a custom Next.js server.
+
+## What it deliberately skips
+
+- **End-user authentication**: the BFF trusts the local browser session. A
+  real app would gate every route behind its own auth (cookie / JWT).
+- **Persistence**: every page load creates a new task. A real app would
+  persist `(userId, taskId)` somewhere and resume.
+- **CSRF protection**: standard Next.js patterns apply, not shown here.
+- **Rate limiting**: trivial to add at the BFF (per user / per IP).
+
+These are intentionally out of scope — they're host application concerns,
+not SDK concerns.
+
+## Common errors
+
+| Symptom | Cause |
+| --- | --- |
+| `Missing env var CONDUCTOR_TOKEN` on bind | `.env.local` not configured. |
+| Bind returns `daemon_offline` | Daemon at `CONDUCTOR_DAEMON_HOST` isn't running. Start the daemon (`make debug-cli` for dev). |
+| Bind returns `binding_validation_failed` | Daemon doesn't recognize the `CONDUCTOR_WORKSPACE_PATH`. Use a path the daemon has already reported. |
+| SSE silently disconnects after ~30s | Reverse proxy buffering. The response sets `X-Accel-Buffering: no`; check your proxy config. |
+| `401 unauthorized` | Token revoked or invalid. Mint a new one in Conductor Settings → API Tokens. |

package/examples/02_bff/app/api/conductor/[...path]/route.ts

@@ -0,0 +1,277 @@
+/**
+ * BFF pass-through for the widget's default REST adapter.
+ *
+ * Routes (relative to this catch-all):
+ *
+ *   GET  /tasks/:taskId/messages?pagination=1&limit&before_id
+ *        → forwarded to client.tasks.history()
+ *   POST /tasks/:taskId/messages
+ *        → forwarded to client.tasks.sendMessage()
+ *   POST /tasks/:taskId/interrupt
+ *        → forwarded to client.tasks.interrupt()
+ *   GET  /tasks/:taskId/events
+ *        → SSE stream from client.tasks.subscribe()
+ *
+ * In a real BFF you'd:
+ *   - Authenticate the requesting *user* (cookie / JWT) before each call.
+ *   - Look up which Conductor task they're allowed to drive.
+ *   - Probably rate-limit per user.
+ *   - Possibly translate / strip metadata before forwarding to Conductor.
+ *
+ * The demo skips all of that — it trusts the local browser session.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import { getClient } from '@/lib/conductor';
+import { isConductorAppError, ConductorAppError } from '@love-moon/app-sdk';
+
+export const runtime = 'nodejs';
+// SSE streams are long-lived; tell Next not to time them out.
+export const dynamic = 'force-dynamic';
+
+interface RouteContext {
+  params: Promise<{ path: string[] }>;
+}
+
+export async function GET(req: NextRequest, ctx: RouteContext) {
+  const segments = (await ctx.params).path ?? [];
+  // Expect /tasks/:taskId/<messages|events>
+  if (segments[0] !== 'tasks' || !segments[1]) return notFound();
+  const taskId = decodeURIComponent(segments[1]);
+  const op = segments[2];
+
+  try {
+    const client = await getClient();
+    if (op === 'messages') {
+      const url = new URL(req.url);
+      const beforeId = url.searchParams.get('before_id') ?? undefined;
+      const limitParam = url.searchParams.get('limit');
+      const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined;
+      const page = await client.tasks.history(taskId, { beforeId, limit });
+      // Translate to the wire shape the widget's REST adapter expects.
+      return NextResponse.json({
+        messages: page.messages,
+        pagination: {
+          has_more_before: page.hasMoreBefore,
+          oldest_message_id: page.oldestMessageId,
+        },
+      });
+    }
+
+    if (op === 'events') {
+      return startEventStream(req, taskId);
+    }
+
+    return notFound();
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+export async function POST(req: NextRequest, ctx: RouteContext) {
+  const segments = (await ctx.params).path ?? [];
+  if (segments[0] !== 'tasks' || !segments[1]) return notFound();
+  const taskId = decodeURIComponent(segments[1]);
+  const op = segments[2];
+
+  try {
+    const client = await getClient();
+    const body = await req.json().catch(() => ({}));
+
+    if (op === 'messages') {
+      const content = String(body?.content ?? '');
+      if (!content) {
+        return NextResponse.json({ error: 'content required' }, { status: 400 });
+      }
+      // Threat model: the BFF is a trust boundary between the browser and
+      // Conductor. The browser cannot be trusted to:
+      //   - Author messages as `system` / `assistant` (would let an attacker
+      //     forge AI replies in the chat log).
+      //   - Stamp `audit.actor='app'` (would let an attacker disguise a
+      //     browser-originated message as a server-side app message and
+      //     defeat `streamReply`'s SDK-echo filter).
+      // We therefore hard-code role='user' and strip metadata.audit before
+      // forwarding. The SDK then stamps its own audit fields server-side.
+      const incomingMetadata =
+        body?.metadata && typeof body.metadata === 'object' && !Array.isArray(body.metadata)
+          ? { ...(body.metadata as Record<string, unknown>) }
+          : undefined;
+      if (incomingMetadata) delete incomingMetadata.audit;
+      const msg = await client.tasks.sendMessage(taskId, {
+        content,
+        clientRequestId: typeof body?.clientRequestId === 'string' ? body.clientRequestId : undefined,
+        role: 'user',
+        ...(incomingMetadata ? { metadata: incomingMetadata } : {}),
+      });
+      return NextResponse.json(msg);
+    }
+
+    if (op === 'interrupt') {
+      const targetReplyTo = String(body?.target_reply_to ?? body?.targetReplyTo ?? '');
+      if (!targetReplyTo) {
+        return NextResponse.json({ error: 'target_reply_to required' }, { status: 400 });
+      }
+      await client.tasks.interrupt(taskId, { targetReplyTo });
+      return NextResponse.json({ ok: true });
+    }
+
+    return notFound();
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+/**
+ * Bridge the SDK's `subscribe(taskId)` AsyncIterable to a Server-Sent Events
+ * response. The widget connects via `new EventSource(...)` and renders each
+ * `data: <JSON>` line as a ChatEvent.
+ *
+ * Lifecycle:
+ *   - Client navigates away → req.signal aborts → we break the loop, the
+ *     AsyncIterator's return() runs, and the underlying WS subscription is
+ *     released.
+ */
+async function startEventStream(req: NextRequest, taskId: string): Promise<Response> {
+  const client = await getClient();
+  const encoder = new TextEncoder();
+  const abortController = new AbortController();
+  // Name the listener so we can remove it in cleanup. Otherwise long-lived
+  // edge runtimes / proxies that reuse the same request signal would leak
+  // listeners across SSE streams.
+  const onRequestAbort = (): void => abortController.abort();
+  let removeReqAbortListener: (() => void) | null = null;
+  if (req.signal.aborted) {
+    abortController.abort();
+  } else {
+    req.signal.addEventListener('abort', onRequestAbort, { once: true });
+    removeReqAbortListener = () => {
+      req.signal.removeEventListener('abort', onRequestAbort);
+    };
+  }
+
+  // Keep-alive timer: emit an SSE comment every 15s to keep idle
+  // connections alive past proxy timeouts (nginx default 60s,
+  // some CDNs lower).
+  let keepAliveTimer: ReturnType<typeof setInterval> | null = null;
+  let closed = false;
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      // Safe wrapper: enqueue can throw `TypeError` once the controller
+      // is closed (e.g. after `cancel()` fires). Returning false signals
+      // the producer loop to bail out.
+      const safeEnqueue = (chunk: Uint8Array): boolean => {
+        if (closed) return false;
+        try {
+          controller.enqueue(chunk);
+          return true;
+        } catch {
+          closed = true;
+          return false;
+        }
+      };
+
+      // SSE preamble: a comment line tells some proxies "keep this alive".
+      if (!safeEnqueue(encoder.encode(':ok\n\n'))) return;
+
+      keepAliveTimer = setInterval(() => {
+        // Backpressure check: if the client isn't draining the stream fast
+        // enough (negative desiredSize means the internal queue is over the
+        // high-water mark), skip this keep-alive tick rather than piling
+        // more chunks into the buffer. The real events that follow are
+        // small; missing a keep-alive comment is harmless.
+        if (typeof controller.desiredSize === 'number' && controller.desiredSize < 0) {
+          return;
+        }
+        if (!safeEnqueue(encoder.encode(': keepalive\n\n'))) {
+          if (keepAliveTimer) {
+            clearInterval(keepAliveTimer);
+            keepAliveTimer = null;
+          }
+        }
+      }, 15_000);
+
+      try {
+        for await (const event of client.tasks.subscribe(taskId, {
+          signal: abortController.signal,
+        })) {
+          if (closed || req.signal.aborted) break;
+          const ok = safeEnqueue(
+            encoder.encode(`data: ${JSON.stringify(event)}\n\n`),
+          );
+          if (!ok) break;
+        }
+      } catch (err) {
+        // Surface terminal errors as a synthetic event then close. Preserve
+        // the original ConductorAppError `code` (e.g. `task_not_running`,
+        // `daemon_offline`) rather than hard-coding `subscribe_failed` — the
+        // browser-side widget switches its UI hint based on the code, so
+        // collapsing every terminal error to a single bucket would lose
+        // useful disambiguation. Fall back to `subscribe_failed` only when
+        // the thrown value isn't an SDK error.
+        const code =
+          err instanceof ConductorAppError ? err.code : 'subscribe_failed';
+        const payload = {
+          type: 'task_failed',
+          taskId,
+          error: {
+            code,
+            message: (err as Error)?.message ?? 'subscribe stream ended',
+          },
+        };
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify(payload)}\n\n`));
+      } finally {
+        cleanup();
+        if (!closed) {
+          try {
+            controller.close();
+          } catch {
+            /* already closed */
+          }
+        }
+      }
+    },
+    cancel() {
+      abortController.abort();
+      cleanup();
+    },
+  });
+
+  function cleanup() {
+    closed = true;
+    if (keepAliveTimer) {
+      clearInterval(keepAliveTimer);
+      keepAliveTimer = null;
+    }
+    if (removeReqAbortListener) {
+      removeReqAbortListener();
+      removeReqAbortListener = null;
+    }
+  }
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream; charset=utf-8',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+      // Prevent buffering proxies (nginx) from holding events back.
+      'X-Accel-Buffering': 'no',
+    },
+  });
+}
+
+function notFound() {
+  return NextResponse.json({ error: 'Not found' }, { status: 404 });
+}
+
+function errorResponse(err: unknown) {
+  if (isConductorAppError(err)) {
+    return NextResponse.json(
+      { error: err.message, code: err.code },
+      { status: err.status ?? 500 },
+    );
+  }
+  return NextResponse.json(
+    { error: (err as Error)?.message ?? 'Internal error' },
+    { status: 500 },
+  );
+}