@stage-labs/metro 0.1.0-beta.7 → 0.1.0-beta.71

package/runtime/node_modules/@metro-labs/mcp/src/daemon/attach-session.ts

@@ -0,0 +1,280 @@
+import { randomBytes } from 'node:crypto';
+import { ApiError } from './api-error.js';
+import { errMsg, log } from './log.js';
+import type { StationName } from '../db/stations.js';
+import { ensureStationDeps } from './runtime-deps.js';
+import {
+  startInteractiveAttach,
+  type AttachDriver,
+  type AttachOutcome,
+  type AttachPrompt,
+  type AttachStep,
+  type DriverHooks,
+  type InteractiveStation,
+  type StartedAttach,
+} from '../stations/attach-interactive.js';
+
+export type StartAttach = (
+  station: InteractiveStation,
+  input: Record<string, unknown>,
+  hooks: DriverHooks,
+) => Promise<StartedAttach>;
+
+export const ATTACH_ID_RE = /^as_[A-Za-z0-9_-]{22}$/;
+
+const PENDING_TTL_MS = 5 * 60_000;
+const SETTLED_TTL_MS = 60_000;
+const SWEEP_MS = 15_000;
+const MAX_PER_AGENT = 2;
+const MAX_TOTAL = 40;
+
+export interface AttachOwner {
+  subject: string;
+  agentId: string;
+}
+
+export interface AttachView {
+  attachId: string;
+  station: string;
+  status: 'pending' | 'done' | 'failed';
+  step: AttachStep | null;
+  prompt: string;
+  qr: string | null;
+  pairingCode: string | null;
+  accountId: string | null;
+  identity: Record<string, string>;
+  activated: boolean;
+  error: string | null;
+  expiresAt: number;
+}
+
+export type CompleteAttach = (
+  owner: AttachOwner,
+  station: StationName,
+  config: Record<string, unknown>,
+) => Promise<{ accountId: string; activated: boolean }>;
+
+export type AuthorizeAttach = (owner: AttachOwner) => Promise<void>;
+
+export interface AttachSessionDeps {
+  authorize: AuthorizeAttach;
+  complete: CompleteAttach;
+  start?: StartAttach;
+}
+
+interface Session {
+  owner: AttachOwner;
+  driver: AttachDriver | null;
+  view: AttachView;
+}
+
+const missing = (): ApiError => new ApiError('no such attach session', 404);
+
+function newAttachId(): string {
+  return `as_${randomBytes(16).toString('base64url')}`;
+}
+
+function blankView(attachId: string, station: string): AttachView {
+  return {
+    attachId,
+    station,
+    status: 'pending',
+    step: null,
+    prompt: '',
+    qr: null,
+    pairingCode: null,
+    accountId: null,
+    identity: {},
+    activated: false,
+    error: null,
+    expiresAt: Date.now() + PENDING_TTL_MS,
+  };
+}
+
+export class AttachSessions {
+  private sessions = new Map<string, Session>();
+  private sweeper: ReturnType<typeof setInterval> | null = null;
+
+  constructor(private deps: AttachSessionDeps) {}
+
+  private ensureSweeper(): void {
+    if (this.sweeper) return;
+    this.sweeper = setInterval(() => {
+      this.sweep().catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'attach-session: sweep failed');
+      });
+    }, SWEEP_MS);
+    this.sweeper.unref();
+  }
+
+  private own(owner: AttachOwner, attachId: string): Session {
+    const session = this.sessions.get(attachId);
+    if (
+      session?.owner.subject !== owner.subject ||
+      session.owner.agentId !== owner.agentId
+    )
+      throw missing();
+    return session;
+  }
+
+  private admit(owner: AttachOwner): void {
+    if (this.sessions.size >= MAX_TOTAL)
+      throw new ApiError(
+        'too many sign-ins are in flight on this daemon, try again shortly',
+        429,
+      );
+    const mine = [...this.sessions.values()].filter(
+      (s) => s.owner.agentId === owner.agentId && s.view.status === 'pending',
+    );
+    if (mine.length >= MAX_PER_AGENT)
+      throw new ApiError(
+        'this agent already has a sign-in in progress, finish or cancel it first',
+        409,
+      );
+  }
+
+  private settle(session: Session, patch: Partial<AttachView>): void {
+    Object.assign(session.view, patch, {
+      qr: null,
+      pairingCode: null,
+      step: null,
+      expiresAt: Date.now() + SETTLED_TTL_MS,
+    });
+    session.driver = null;
+  }
+
+  private async finish(
+    attachId: string,
+    station: StationName,
+    outcome: AttachOutcome,
+  ): Promise<void> {
+    const session = this.sessions.get(attachId);
+    if (session?.view.status !== 'pending') return;
+    try {
+      const landed = await this.deps.complete(
+        session.owner,
+        station,
+        outcome.config,
+      );
+      this.settle(session, {
+        status: 'done',
+        prompt: '',
+        identity: outcome.identity,
+        accountId: landed.accountId,
+        activated: landed.activated,
+      });
+      log.info(
+        { agentId: session.owner.agentId, station, account: landed.accountId },
+        'attach-session: signed in and attached a station account',
+      );
+    } catch (err) {
+      const reason =
+        err instanceof ApiError ? err.message : 'could not store the account';
+      log.warn({ station, err: errMsg(err) }, 'attach-session: store failed');
+      this.settle(session, { status: 'failed', prompt: '', error: reason });
+    }
+  }
+
+  private hooksFor(attachId: string, station: StationName) {
+    return {
+      prompt: (p: AttachPrompt): void => {
+        const session = this.sessions.get(attachId);
+        if (session?.view.status !== 'pending') return;
+        session.view.step = p.step;
+        session.view.prompt = p.prompt;
+        session.view.qr = p.qr ?? null;
+        session.view.pairingCode = p.pairingCode ?? null;
+      },
+      done: (o: AttachOutcome): void => {
+        this.finish(attachId, station, o).catch((err: unknown) => {
+          log.warn(
+            { attachId, station, err: errMsg(err) },
+            'attach-session: completion failed',
+          );
+        });
+      },
+      fail: (message: string): void => {
+        const session = this.sessions.get(attachId);
+        if (session?.view.status !== 'pending') return;
+        this.settle(session, { status: 'failed', prompt: '', error: message });
+      },
+    };
+  }
+
+  async start(
+    owner: AttachOwner,
+    station: InteractiveStation,
+    input: Record<string, unknown>,
+  ): Promise<AttachView> {
+    await this.deps.authorize(owner);
+    this.admit(owner);
+    this.ensureSweeper();
+    const attachId = newAttachId();
+    const session: Session = {
+      owner,
+      driver: null,
+      view: blankView(attachId, station),
+    };
+    this.sessions.set(attachId, session);
+    try {
+      ensureStationDeps(station);
+      const started = await (this.deps.start ?? startInteractiveAttach)(
+        station,
+        input,
+        this.hooksFor(attachId, station),
+      );
+      session.driver = started.driver;
+      this.hooksFor(attachId, station).prompt(started.prompt);
+    } catch (err) {
+      this.sessions.delete(attachId);
+      throw err;
+    }
+    log.info(
+      { agentId: owner.agentId, station, attachId },
+      'attach-session: started',
+    );
+    return { ...session.view };
+  }
+
+  view(owner: AttachOwner, attachId: string): AttachView {
+    return { ...this.own(owner, attachId).view };
+  }
+
+  async submit(
+    owner: AttachOwner,
+    attachId: string,
+    input: { code?: unknown; password?: unknown },
+  ): Promise<AttachView> {
+    const session = this.own(owner, attachId);
+    const driver = session.driver;
+    if (session.view.status !== 'pending' || !driver)
+      throw new ApiError('this sign-in is already finished', 409);
+    await driver.submit(input);
+    return { ...session.view };
+  }
+
+  async cancel(owner: AttachOwner, attachId: string): Promise<void> {
+    const session = this.own(owner, attachId);
+    this.sessions.delete(attachId);
+    await session.driver?.cancel().catch(() => undefined);
+    log.info({ attachId }, 'attach-session: cancelled');
+  }
+
+  async sweep(now = Date.now()): Promise<void> {
+    for (const [attachId, session] of [...this.sessions]) {
+      if (session.view.expiresAt > now) continue;
+      this.sessions.delete(attachId);
+      const driver = session.driver;
+      session.driver = null;
+      if (!driver) continue;
+      log.info({ attachId }, 'attach-session: expired, credentials discarded');
+      await driver.cancel().catch(() => undefined);
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (this.sweeper) clearInterval(this.sweeper);
+    this.sweeper = null;
+    await this.sweep(Number.MAX_SAFE_INTEGER);
+  }
+}

package/runtime/node_modules/@metro-labs/mcp/src/daemon/boot.ts

@@ -0,0 +1,204 @@
+import { join } from 'node:path';
+import { type Server } from 'node:http';
+import { userSelf } from './events.js';
+import { setTrainCallBackend } from './train-call.js';
+import { errMsg, log, logFatalSync } from './log.js';
+import { acquireLock, isLocalMode, STATE_DIR, trainsDir } from './paths.js';
+import { installCrashGuard, markDaemonReady } from './crash-guard.js';
+import { METRO_VERSION } from './version.js';
+import { funnelDriver, Tunnel, tunnelWanted, webhookPort } from './tunnel.js';
+import {
+  localConnectHint,
+  publicConnectHint,
+  tunnelPendingHint,
+} from './connect-hint.js';
+import { TrainSupervisor } from './supervisor.js';
+import {
+  makeEmit,
+  startWebhookServer,
+  trainEventToMetroEvent,
+} from './http.js';
+import { localAgentKey } from '../db/materialize.js';
+import { fileSource } from '../db/file-source.js';
+import { applyLocalOwner } from './local-owner.js';
+import { localOwner } from '../db/file-admin.js';
+import { ensureStationDeps } from './runtime-deps.js';
+import { localSessionApis } from './local-mode.js';
+import type { ModeInfo } from './mode-api.js';
+import type { SessionApis } from './session-apis.js';
+import {
+  agentLiveness,
+  closeAgentSession,
+  createMetroMcp,
+} from '../mcp/index.js';
+import { metroCall } from '../mcp/ctx.js';
+import { gatherAccountsForAgents } from '../mcp/accounts.js';
+import {
+  accountStationCapabilities,
+  stationByName,
+} from '../stations/registry.js';
+import { prepareAccount } from '../stations/attach.js';
+import { materializeFrom, reloadFrom } from '../db/materialize.js';
+import type { StationName } from '../db/stations.js';
+import { startUploadReaper } from './upload-store.js';
+
+installCrashGuard();
+acquireLock(join(STATE_DIR, '.tail-lock'));
+
+log.info({ self: userSelf() }, 'user identity');
+
+process.stdout.on('error', (err) => {
+  if ((err as NodeJS.ErrnoException).code !== 'EPIPE')
+    log.warn({ err: errMsg(err) }, 'stdout error');
+});
+
+const supervisor = new TrainSupervisor();
+const emit = makeEmit();
+
+supervisor.onTrainEvent((env, train) => {
+  const entry = trainEventToMetroEvent(env, train);
+  if (entry) emit(entry);
+});
+
+let webhookServer: Server | null = null;
+const tunnel = tunnelWanted() ? new Tunnel(funnelDriver(webhookPort()), announcePublic) : null;
+
+function announcePublic(url: string): void {
+  process.stderr.write(`\n${publicConnectHint(url, localOwner())}`);
+}
+
+setTrainCallBackend((train, action, args) =>
+  supervisor.call(train, action, args),
+);
+
+function announceLocalEndpoint(): void {
+  process.stderr.write(
+    `\n${tunnel === null ? localConnectHint(webhookPort(), localOwner()) : tunnelPendingHint()}`,
+  );
+  const key = localAgentKey();
+  if (key === null) {
+    log.info('no agent on this machine yet');
+    return;
+  }
+  const url = `http://127.0.0.1:${String(webhookPort())}/mcp?token=${key}`;
+  process.stderr.write(
+    `\nConnect an agent on this machine:\n\n  claude mcp add --transport http metro "${url}"\n\n`,
+  );
+}
+
+async function syncStations(station: StationName): Promise<void> {
+  const { removed } = await reloadFrom(fileSource);
+  if (stationByName(station)?.hasTrain === false) return;
+  if (removed.includes(station)) await supervisor.stopTrain(station);
+  else {
+    ensureStationDeps(station);
+    supervisor.requestReload(station);
+  }
+}
+
+const hostedMode = (): ModeInfo => ({
+  mode: 'hosted',
+  owner: null,
+  project: null,
+  version: METRO_VERSION,
+});
+
+async function sessionApis(): Promise<SessionApis> {
+  if (isLocalMode())
+    return localSessionApis({
+      syncStations,
+      restart: () => {
+        exitCode = RESTART_EXIT;
+        onShutdown();
+      },
+      stop: () => {
+        exitCode = HOLD_EXIT;
+        onShutdown();
+      },
+      closeAgentSession,
+      gatherAccounts: gatherAccountsForAgents,
+      capabilities: accountStationCapabilities,
+      liveness: agentLiveness,
+      prepareAccount,
+    });
+  const vault = await import('../db/vault.js');
+  const servers = await import('../db/servers.js');
+  return {
+    vaultApi: {
+      list: vault.listVaultForOwner,
+      put: vault.putVaultForOwner,
+      get: vault.getVaultForOwner,
+      remove: vault.deleteVaultForOwner,
+    },
+    serversApi: {
+      list: servers.listServersForOwner,
+      add: servers.addServerForOwner,
+      rename: servers.renameServerForOwner,
+      remove: servers.deleteServerForOwner,
+    },
+    mode: hostedMode,
+  };
+}
+
+async function main(): Promise<void> {
+  if (isLocalMode()) {
+    applyLocalOwner();
+    await materializeFrom(fileSource, { allowEmpty: true });
+  }
+  supervisor.start();
+  const metroMcp = await createMetroMcp();
+  webhookServer = await startWebhookServer(
+    emit,
+    await sessionApis(),
+    metroMcp.httpHandler,
+    metroCall,
+  );
+  metroMcp.startInbound();
+  startUploadReaper();
+  if (isLocalMode()) announceLocalEndpoint();
+  tunnel?.start();
+  log.info(
+    { tunnel: !!tunnel, trainsDir: trainsDir(), mcp: '/', version: METRO_VERSION },
+    'dispatcher ready',
+  );
+  markDaemonReady();
+}
+
+const SHUTDOWN_TIMEOUT_MS = 3_000;
+const RESTART_EXIT = 75;
+const HOLD_EXIT = 76;
+let exitCode = 0;
+let shuttingDown = false;
+async function shutdown(): Promise<void> {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log.info('dispatcher shutting down');
+  tunnel?.stop();
+  if (webhookServer) {
+    const server = webhookServer;
+    await Promise.race([
+      new Promise<void>((r) => {
+        server.close(() => {
+          r();
+        });
+      }),
+      new Promise<void>((r) => {
+        setTimeout(r, SHUTDOWN_TIMEOUT_MS).unref();
+      }),
+    ]);
+  }
+  await supervisor.stop();
+  process.exit(exitCode);
+}
+const onShutdown = (): void => {
+  shutdown().catch((err: unknown) => {
+    log.error({ err: errMsg(err) }, 'dispatcher: shutdown failed');
+    process.exit(1);
+  });
+};
+for (const sig of ['SIGINT', 'SIGTERM'] as const) process.on(sig, onShutdown);
+
+await main().catch((err: unknown) => {
+  logFatalSync({ err: errMsg(err) }, 'dispatcher failed to start');
+  process.exit(1);
+});

package/runtime/node_modules/@metro-labs/mcp/src/daemon/bundle-api.ts

@@ -0,0 +1,111 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { apiFailure, apiSession, cors, readJsonBody, sendJson } from './api-http.js';
+import { ApiError } from './api-error.js';
+import { isRecord } from './is-record.js';
+import { parseId } from '../db/ids.js';
+import type { LoadedAccount, LoadedAgent, LoadedConnector } from '../db/materialize.js';
+import { STATIONS } from '../db/stations.js';
+
+const AGENTS = '/api/agents';
+const RESTORE_PATH = `${AGENTS}/restore`;
+const BUNDLE_MAX = 2 * 1024 * 1024;
+const STATION_NAMES = new Set<string>(STATIONS);
+
+export interface AgentBundle {
+  version: 1;
+  agent: { id: string; name: string; key: string; stations: LoadedAccount[] };
+  connectors: LoadedConnector[];
+}
+
+export const loadedAgentOf = (bundle: AgentBundle): LoadedAgent => ({
+  id: bundle.agent.id,
+  name: bundle.agent.name,
+  key: bundle.agent.key,
+  accounts: bundle.agent.stations,
+  connectors: [],
+});
+
+export interface RestoredAgent {
+  id: string;
+  name: string;
+  stations: number;
+  connectors: number;
+}
+
+export interface BundleApiDeps {
+  bundle: (subject: string, agentId: string) => Promise<AgentBundle>;
+  restore: (subject: string, bundle: AgentBundle) => Promise<RestoredAgent>;
+}
+
+const bad = (what: string): ApiError => new ApiError(`bundle: ${what}`, 400);
+
+function stationOf(raw: unknown): LoadedAccount {
+  if (!isRecord(raw) || typeof raw.station !== 'string' || !STATION_NAMES.has(raw.station))
+    throw bad('a station is not a known station');
+  if (typeof raw.id !== 'string' || !isRecord(raw.config)) throw bad('a station has no id or config');
+  const allowlist = Array.isArray(raw.allowlist)
+    ? raw.allowlist.filter((s): s is string => typeof s === 'string')
+    : null;
+  return { station: raw.station as LoadedAccount['station'], id: raw.id, allowlist, config: raw.config };
+}
+
+function connectorOf(raw: unknown): LoadedConnector {
+  if (!isRecord(raw) || typeof raw.id !== 'string' || typeof raw.name !== 'string' || typeof raw.url !== 'string')
+    throw bad('a connector is missing its id, name or url');
+  if (!isRecord(raw.config)) throw bad('a connector has no config');
+  return { id: raw.id, name: raw.name, url: raw.url, transport: 'http', config: raw.config };
+}
+
+function agentOf(raw: unknown): AgentBundle['agent'] {
+  if (!isRecord(raw)) throw bad('not a v1 agent bundle');
+  const { id, name, key, stations } = raw;
+  if (typeof id !== 'string' || parseId(id) === null) throw bad('agent id is not an id');
+  if (typeof name !== 'string' || typeof key !== 'string' || key === '') throw bad('agent has no name or key');
+  if (!Array.isArray(stations)) throw bad('agent has no station list');
+  return { id, name, key, stations: stations.map(stationOf) };
+}
+
+export function parseBundle(raw: unknown): AgentBundle {
+  if (!isRecord(raw) || raw.version !== 1) throw bad('not a v1 agent bundle');
+  const connectors = Array.isArray(raw.connectors) ? raw.connectors : [];
+  return { version: 1, agent: agentOf(raw.agent), connectors: connectors.map(connectorOf) };
+}
+
+async function answer(req: IncomingMessage, deps: BundleApiDeps, subject: string, path: string): Promise<unknown> {
+  if (path === RESTORE_PATH) return deps.restore(subject, parseBundle(await readJsonBody(req, BUNDLE_MAX)));
+  const id = parseId(path.slice(AGENTS.length + 1).split('/')[0] ?? '');
+  if (id === null) throw new ApiError('no such agent', 404);
+  return deps.bundle(subject, id);
+}
+
+export function handleBundleRequest(req: IncomingMessage, res: ServerResponse, deps: BundleApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const isRestore = path === RESTORE_PATH;
+  const isBundle = /^\/api\/agents\/[^/]+\/bundle$/.test(path);
+  if (!isRestore && !isBundle) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== (isRestore ? 'POST' : 'GET')) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  apiSession(req)
+    .then((session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      return answer(req, deps, session.subject, path);
+    })
+    .then((body) => {
+      sendJson(req, res, isRestore ? 201 : 200, body);
+    })
+    .catch((err: unknown) => {
+      if (err instanceof ApiError) apiFailure(req, res, err, 'bundle-api');
+      else {
+        log.warn({ err: errMsg(err) }, 'bundle-api: request failed');
+        if (!res.headersSent) sendJson(req, res, 500, { error: 'bundle api failed' });
+      }
+    });
+  return true;
+}

package/runtime/node_modules/@metro-labs/mcp/src/daemon/claude-api.ts

@@ -0,0 +1,97 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { apiFailure, apiSession, cors, sendJson } from './api-http.js';
+import { ApiError } from './api-error.js';
+import {
+  claudeDir,
+  deleteClaudeSession,
+  listClaudeProjects,
+  listClaudeSessions,
+  listMemory,
+  readMemoryFile,
+  readTranscript,
+} from './claude-files.js';
+
+const PREFIX = '/api/claude';
+const PAGE = 100;
+const PAGE_MAX = 500;
+
+export interface ClaudeApiDeps {
+  authorize: (subject: string) => void;
+  dir?: () => string;
+}
+
+function projectOf(query: URLSearchParams): string {
+  const project = query.get('project');
+  if (project === null || project === '') throw new ApiError('project is required', 400);
+  return project;
+}
+
+function pageOf(query: URLSearchParams): { offset: number; limit: number } {
+  const offset = Math.max(0, Math.floor(Number(query.get('offset') ?? '0')) || 0);
+  const limit = Math.min(PAGE_MAX, Math.max(1, Math.floor(Number(query.get('limit') ?? String(PAGE))) || PAGE));
+  return { offset, limit };
+}
+
+type Handler = (query: URLSearchParams, dir: string, item: string) => unknown;
+
+const COLLECTIONS: Record<string, Handler> = {
+  projects: (_query, dir) => ({ projects: listClaudeProjects(dir) }),
+  sessions: (query, dir) => ({ sessions: listClaudeSessions(projectOf(query), dir) }),
+  memory: (query, dir) => listMemory(projectOf(query), dir),
+};
+
+const ITEMS: Record<string, Handler> = {
+  sessions: (query, dir, id) => {
+    const { offset, limit } = pageOf(query);
+    return readTranscript(projectOf(query), id, offset, limit, dir);
+  },
+  memory: (query, dir, name) => ({ name, content: readMemoryFile(projectOf(query), name, dir) }),
+};
+
+function answer(method: string, path: string, query: URLSearchParams, dir: string): unknown {
+  const rest = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  const [head = '', item] = rest;
+  if (method === 'DELETE') {
+    if (rest.length !== 2 || head !== 'sessions') throw new ApiError('method not allowed', 405);
+    deleteClaudeSession(projectOf(query), item ?? '', dir);
+    return { deleted: item };
+  }
+  const handler = rest.length === 1 ? COLLECTIONS[head] : rest.length === 2 ? ITEMS[head] : undefined;
+  if (handler === undefined) throw new ApiError('no such route', 404);
+  return handler(query, dir, item ?? '');
+}
+
+export function handleClaudeRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ClaudeApiDeps,
+): boolean {
+  const [path = '', search = ''] = (req.url ?? '').split('?');
+  if (path !== PREFIX && !path.startsWith(`${PREFIX}/`)) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== 'GET' && req.method !== 'DELETE') {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  apiSession(req)
+    .then((session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      deps.authorize(session.subject);
+      return answer(req.method ?? 'GET', path, new URLSearchParams(search), (deps.dir ?? claudeDir)());
+    })
+    .then((body) => {
+      sendJson(req, res, 200, body);
+    })
+    .catch((err: unknown) => {
+      if (err instanceof ApiError) apiFailure(req, res, err, 'claude-api');
+      else {
+        log.warn({ err: errMsg(err) }, 'claude-api: request failed');
+        if (!res.headersSent) sendJson(req, res, 500, { error: 'claude-api failed' });
+      }
+    });
+  return true;
+}