@stage-labs/metro 0.1.0-beta.70 → 0.1.0-beta.72

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

@@ -0,0 +1,192 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from './api-error.js';
+import { apiFailure, apiSession, cors, readJsonBody, sendJson } from './api-http.js';
+import { isRecord } from './is-record.js';
+import { log } from './log.js';
+import { beginLogin, CodexAuthError, finishLogin, readCodexCliAuth } from '../gateway/codex-auth.js';
+import { beginDeviceLogin, pollDeviceLogin } from '../gateway/codex-device.js';
+import { codexModels, currentTokens, freshCodexState } from '../gateway/codex.js';
+import { openrouterModels } from '../gateway/openrouter.js';
+import type { CodexTokens } from '../gateway/codex-auth.js';
+import { GatewayError } from '../gateway/forward.js';
+import {
+  applyModelUpdate,
+  ModelConfigError,
+  publicModelConfig,
+  readModelConfig,
+  setCodexAuth,
+  writeModelConfig,
+  type ModelConfig,
+} from '../gateway/model-config.js';
+
+const PATH = '/api/model';
+const CODEX = '/api/model/codex/';
+const OPENROUTER = '/api/model/openrouter/';
+const BODY_MAX = 16 * 1024;
+const DEVICE_PREFIX = 'device/';
+const DEVICE_ID_RE = /^[A-Za-z0-9_-]{16,64}$/;
+
+export interface ModelApiDeps {
+  authorize: (subject: string) => void;
+  read?: () => ModelConfig;
+  write?: (cfg: ModelConfig) => void;
+  issuer?: string;
+  fetchImpl?: typeof fetch;
+  codexHome?: string;
+  codexBase?: string;
+  openrouterBase?: string;
+}
+
+interface Store {
+  read: () => ModelConfig;
+  write: (cfg: ModelConfig) => void;
+}
+
+type Handler = (req: IncomingMessage, deps: ModelApiDeps, store: Store) => Promise<unknown>;
+
+interface Route {
+  method: 'GET' | 'POST';
+  run: Handler;
+}
+
+function asApiError(err: unknown): never {
+  if (err instanceof ModelConfigError || err instanceof CodexAuthError) throw new ApiError(err.message, 400);
+  if (err instanceof GatewayError) throw new ApiError(err.message, 502);
+  throw err;
+}
+
+async function update(req: IncomingMessage, store: Store): Promise<unknown> {
+  const patch = await readJsonBody(req, BODY_MAX);
+  let next: ModelConfig;
+  try {
+    next = applyModelUpdate(store.read(), patch);
+  } catch (err) {
+    asApiError(err);
+  }
+  store.write(next);
+  log.info({ provider: next.provider }, 'model-api: route updated');
+  return publicModelConfig(next);
+}
+
+function saveCodex(store: Store, cfg: ModelConfig, note: string): unknown {
+  store.write(cfg);
+  log.info({ signedIn: cfg.codex.auth !== null, plan: cfg.codex.auth?.plan ?? null }, note);
+  return publicModelConfig(cfg);
+}
+
+const modelApiState = freshCodexState();
+
+async function pollDevice(id: string, deps: ModelApiDeps, store: Store): Promise<unknown> {
+  const result = await pollDeviceLogin(id, deps.fetchImpl).catch(asApiError);
+  if (result.status !== 'done') return result;
+  return { status: 'done', settings: saveCodex(store, setCodexAuth(store.read(), result.tokens), 'model-api: Codex connected by device code') };
+}
+
+const CODEX_ROUTES: Record<string, Route> = {
+  device: {
+    method: 'POST',
+    run: async (_req, deps) => {
+      const login = await beginDeviceLogin(deps.issuer, deps.fetchImpl).catch(asApiError);
+      return { id: login.id, user_code: login.userCode, verify_url: login.verifyUrl, interval: login.interval };
+    },
+  },
+  login: {
+    method: 'POST',
+    run: (_req, deps) => Promise.resolve({ url: beginLogin(deps.issuer).url }),
+  },
+  callback: {
+    method: 'POST',
+    run: async (req, deps, store) => {
+      const body = await readJsonBody(req, BODY_MAX);
+      const raw = isRecord(body) && typeof body.url === 'string' ? body.url : '';
+      const tokens = await finishLogin(raw, deps.issuer, deps.fetchImpl).catch(asApiError);
+      return saveCodex(store, setCodexAuth(store.read(), tokens), 'model-api: Codex connected');
+    },
+  },
+  logout: {
+    method: 'POST',
+    run: (_req, _deps, store) => Promise.resolve(saveCodex(store, setCodexAuth(store.read(), null), 'model-api: Codex disconnected')),
+  },
+  import: {
+    method: 'POST',
+    run: (_req, deps, store) => {
+      let tokens;
+      try {
+        tokens = readCodexCliAuth(deps.codexHome);
+      } catch (err) {
+        asApiError(err);
+      }
+      return Promise.resolve(saveCodex(store, setCodexAuth(store.read(), tokens), 'model-api: Codex CLI login imported'));
+    },
+  },
+  models: {
+    method: 'GET',
+    run: async (_req, deps, store) => {
+      const cfg = store.read();
+      if (cfg.codex.auth === null) throw new ApiError('Codex is not connected: sign in with ChatGPT first', 400);
+      const codexDeps = { issuer: deps.issuer, fetchImpl: deps.fetchImpl, base: deps.codexBase, save: (t: CodexTokens) => { store.write(setCodexAuth(store.read(), t)); } };
+      const auth = await currentTokens(cfg, codexDeps, modelApiState).catch(asApiError);
+      const models = await codexModels(auth, codexDeps).catch(asApiError);
+      return { models };
+    },
+  },
+};
+
+const OPENROUTER_ROUTES: Record<string, Route> = {
+  models: {
+    method: 'GET',
+    run: async (_req, deps) => ({ models: await openrouterModels(deps.openrouterBase, deps.fetchImpl).catch(asApiError) }),
+  },
+};
+
+const named = (table: Record<string, Route>, name: string, method: string | undefined): Route | number => {
+  const route = table[name];
+  if (route === undefined) return 404;
+  return route.method === method ? route : 405;
+};
+
+function settingsRoute(method: string | undefined): Route | number {
+  if (method === 'GET') return { method: 'GET', run: (_req, _deps, store) => Promise.resolve(publicModelConfig(store.read())) };
+  if (method === 'PUT') return { method: 'POST', run: (req, _deps, store) => update(req, store) };
+  return 405;
+}
+
+function codexRoute(rest: string, method: string | undefined): Route | number {
+  if (rest in CODEX_ROUTES) return named(CODEX_ROUTES, rest, method);
+  const id = rest.startsWith(DEVICE_PREFIX) ? rest.slice(DEVICE_PREFIX.length) : '';
+  if (!DEVICE_ID_RE.test(id)) return 404;
+  return method === 'GET' ? { method: 'GET', run: (_req, deps, store) => pollDevice(id, deps, store) } : 405;
+}
+
+const mine = (path: string): boolean => path === PATH || path.startsWith(CODEX) || path.startsWith(OPENROUTER);
+
+function routeFor(path: string, method: string | undefined): Route | number {
+  if (path === PATH) return settingsRoute(method);
+  if (path.startsWith(OPENROUTER)) return named(OPENROUTER_ROUTES, path.slice(OPENROUTER.length), method);
+  return codexRoute(path.slice(CODEX.length), method);
+}
+
+export function handleModelRequest(req: IncomingMessage, res: ServerResponse, deps: ModelApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (!mine(path)) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  const route = routeFor(path, req.method);
+  if (typeof route === 'number') {
+    sendJson(req, res, route, { error: route === 404 ? 'not found' : 'method not allowed' });
+    return true;
+  }
+  const store: Store = { read: deps.read ?? readModelConfig, write: deps.write ?? writeModelConfig };
+  apiSession(req)
+    .then(async (session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      deps.authorize(session.subject);
+      sendJson(req, res, 200, await route.run(req, deps, store));
+    })
+    .catch((err: unknown) => {
+      apiFailure(req, res, err, 'model-api');
+    });
+  return true;
+}

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

@@ -16,6 +16,8 @@ import { handleBundleRequest, type BundleApiDeps } from './bundle-api.js';
 import { handleUpdateRequest, type UpdateApiDeps } from './update-api.js';
 import { handleControlRequest, type ControlApiDeps } from './control-api.js';
 import { handleMachineRequest, type MachineApiDeps } from './machine-api.js';
+import { handleModelRequest, type ModelApiDeps } from './model-api.js';
+import type { GatewayDeps } from '../gateway/gateway.js';
 import { handleTerminalRequest, type TerminalApiDeps } from './terminal-api.js';
 
 export interface SessionApis {
@@ -26,6 +28,8 @@ export interface SessionApis {
   updateApi?: UpdateApiDeps;
   controlApi?: ControlApiDeps;
   machineApi?: MachineApiDeps;
+  modelApi?: ModelApiDeps;
+  gateway?: GatewayDeps;
   terminalApi?: TerminalApiDeps;
   localCli?: LocalCliDeps;
   claudeApi?: ClaudeApiDeps;
@@ -53,6 +57,7 @@ export function handleSessionApis(
     ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
     ...when(apis.controlApi, (d) => handleControlRequest(req, res, d)),
     ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
+    ...when(apis.modelApi, (d) => handleModelRequest(req, res, d)),
     ...when(apis.terminalApi, (d) => handleTerminalRequest(req, res, d)),
     ...when(apis.claudeApi, (d) => handleClaudeRequest(req, res, d)),
     ...when(apis.agentApi, (d) => handleAgentApiRequest(req, res, d)),

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

@@ -34,12 +34,22 @@ function sizeTmuxWindow(command: string[], session: string, cols: number, rows:
   if (command[0] !== 'tmux') return;
   const child = spawn('tmux', resizeWindowArgs(session, cols, rows), { stdio: 'ignore' });
   child.on('error', (err) => {
-    log.debug({ err: errMsg(err) }, 'terminal: resize-window failed');
+    log.warn({ err: errMsg(err) }, 'terminal: resize-window could not run');
+  });
+  child.on('exit', (code) => {
+    if (code !== 0) log.warn({ code, session, cols, rows }, 'terminal: tmux refused the window resize');
   });
 }
 
-const dimension = (raw: unknown, fallback: number): number =>
-  typeof raw === 'number' && Number.isInteger(raw) && raw > 1 && raw <= MAX_DIMENSION ? raw : fallback;
+const dimension = (raw: unknown): number | null =>
+  typeof raw === 'number' && Number.isInteger(raw) && raw > 1 && raw <= MAX_DIMENSION ? raw : null;
+
+export function sizeFrom(control: unknown): { cols: number; rows: number } | null {
+  if (!isRecord(control)) return null;
+  const cols = dimension(control.cols);
+  const rows = dimension(control.rows);
+  return cols === null || rows === null ? null : { cols, rows };
+}
 
 function runTerminal(ws: WebSocket, command: string[], subject: string, session: string): void {
   const terminal = new Bun.Terminal({
@@ -61,12 +71,11 @@ function runTerminal(ws: WebSocket, command: string[], subject: string, session:
       return;
     }
     try {
-      const control: unknown = JSON.parse(bytes.toString('utf8'));
-      if (isRecord(control) && 'cols' in control) {
-        const cols = dimension(control.cols, DEFAULT_COLS);
-        const rows = dimension(control.rows, DEFAULT_ROWS);
-        terminal.resize(cols, rows);
-        sizeTmuxWindow(command, session, cols, rows);
+      const size = sizeFrom(JSON.parse(bytes.toString('utf8')));
+      if (size !== null) {
+        terminal.resize(size.cols, size.rows);
+        proc.kill('SIGWINCH');
+        sizeTmuxWindow(command, session, size.cols, size.rows);
       }
     } catch (err) {
       log.warn({ err: errMsg(err) }, 'terminal: bad control frame');

package/runtime/node_modules/@metro-labs/mcp/src/gateway/bedrock.ts

@@ -0,0 +1,252 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { log } from '../daemon/log.js';
+import { EventStreamDecoder, type EventStreamMessage } from './eventstream.js';
+import { errorFrame, GatewayError, idleMessage, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
+import type { BedrockSettings } from './model-config.js';
+
+const ANTHROPIC_VERSION = 'bedrock-2023-05-31';
+const EXTRA_INPUT_RE = /^([A-Za-z0-9_]+)(?:\.[^:]*)?: Extra inputs are not permitted/;
+const MAX_REPAIRS = 4;
+const PING_MS = 25_000;
+
+export interface Adaptations {
+  fields: Set<string>;
+  dropBetas: boolean;
+}
+
+export const freshAdaptations = (): Adaptations => ({ fields: new Set(), dropBetas: false });
+
+export interface BedrockUpstream {
+  settings: BedrockSettings;
+  base: string;
+  learned: Adaptations;
+  watch: Watch;
+}
+
+interface Rewritten {
+  modelId: string;
+  stream: boolean;
+  body: Record<string, unknown>;
+  betas: string[];
+}
+
+interface Attempt {
+  body: Record<string, unknown>;
+  betas: string[];
+}
+
+const PREFIXES: [RegExp, string][] = [
+  [/^us-gov-/, 'us-gov'],
+  [/^us-/, 'us'],
+  [/^eu-/, 'eu'],
+  [/^ap-/, 'apac'],
+];
+
+export function regionPrefix(region: string): string {
+  for (const [pattern, prefix] of PREFIXES) if (pattern.test(region)) return prefix;
+  return 'global';
+}
+
+export function bedrockModelId(requested: string, region: string): string {
+  if (requested.includes('anthropic.')) return requested;
+  return `${regionPrefix(region)}.anthropic.${requested}`;
+}
+
+export const bedrockBase = (region: string): string => `https://bedrock-runtime.${region}.amazonaws.com`;
+
+function splitBetas(header: string | string[] | undefined): string[] {
+  const raw = Array.isArray(header) ? header.join(',') : (header ?? '');
+  return raw
+    .split(',')
+    .map((b) => b.trim())
+    .filter((b) => b !== '');
+}
+
+export function rewriteForBedrock(
+  body: Record<string, unknown>,
+  model: string,
+  betaHeader: string | string[] | undefined,
+  region: string,
+): Rewritten {
+  const betas = splitBetas(betaHeader);
+  const out: Record<string, unknown> = {
+    ...Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'model' && key !== 'stream')),
+    anthropic_version: ANTHROPIC_VERSION,
+  };
+  if (betas.length > 0) out.anthropic_beta = betas;
+  return { modelId: bedrockModelId(model, region), stream: body.stream === true, body: out, betas };
+}
+
+export function errorKind(status: number, errorType: string | null): string {
+  if (status === 429 || errorType === 'ThrottlingException') return 'rate_limit_error';
+  if (status === 400) return 'invalid_request_error';
+  if (status === 401 || status === 403) return 'permission_error';
+  if (status === 404) return 'not_found_error';
+  if (status === 503) return 'overloaded_error';
+  return 'api_error';
+}
+
+const invokeUrl = (up: BedrockUpstream, modelId: string, action: string): string =>
+  `${up.base}/model/${encodeURIComponent(modelId)}/${action}`;
+
+function callBedrock(up: BedrockUpstream, url: string, body: unknown, accept: string): Promise<Response> {
+  return fetch(url, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${up.settings.apiKey}`,
+      'content-type': 'application/json',
+      accept,
+    },
+    body: JSON.stringify(body),
+    signal: up.watch.signal,
+  });
+}
+
+const without = (body: Record<string, unknown>, keys: Set<string>): Record<string, unknown> =>
+  Object.fromEntries(Object.entries(body).filter(([key]) => !keys.has(key)));
+
+function applyLearned(req: Rewritten, learned: Adaptations): Attempt {
+  const dropped = new Set(learned.fields);
+  if (learned.dropBetas) dropped.add('anthropic_beta');
+  return { body: without(req.body, dropped), betas: learned.dropBetas ? [] : req.betas };
+}
+
+function repair(attempt: Attempt, learned: Adaptations, message: string): Attempt | null {
+  const named = EXTRA_INPUT_RE.exec(message)?.[1];
+  if (named !== undefined && named in attempt.body) {
+    learned.fields.add(named);
+    log.warn({ field: named }, 'gateway: Bedrock refused an extra input; dropping it from every request');
+    return { body: without(attempt.body, new Set([named])), betas: attempt.betas };
+  }
+  if (attempt.betas.length > 0) {
+    learned.dropBetas = true;
+    log.warn({ betas: attempt.betas }, 'gateway: retrying without anthropic_beta');
+    return { body: without(attempt.body, new Set(['anthropic_beta'])), betas: [] };
+  }
+  return null;
+}
+
+async function withRepairs(up: BedrockUpstream, req: Rewritten, send: (attempt: Attempt) => Promise<Response>): Promise<Response> {
+  let attempt = applyLearned(req, up.learned);
+  for (let repairs = 0; ; repairs += 1) {
+    const res = await send(attempt);
+    if (res.status !== 400 || repairs >= MAX_REPAIRS) return res;
+    const text = await res.text();
+    const next = repair(attempt, up.learned, upstreamMessage(text, 'Bedrock returned no body'));
+    if (next === null) return new Response(text, { status: 400, headers: res.headers });
+    attempt = next;
+  }
+}
+
+function invoke(up: BedrockUpstream, req: Rewritten): Promise<Response> {
+  const action = req.stream ? 'invoke-with-response-stream' : 'invoke';
+  const accept = req.stream ? 'application/vnd.amazon.eventstream' : 'application/json';
+  const url = invokeUrl(up, req.modelId, action);
+  return withRepairs(up, req, (attempt) => callBedrock(up, url, attempt.body, accept));
+}
+
+function eventTypeOf(event: string): string {
+  try {
+    const parsed = JSON.parse(event) as { type?: unknown };
+    return typeof parsed.type === 'string' ? parsed.type : 'message';
+  } catch {
+    return 'message';
+  }
+}
+
+function writeEvent(res: ServerResponse, message: EventStreamMessage): void {
+  if (message.headers[':message-type'] === 'event') {
+    const parsed = JSON.parse(message.payload.toString('utf8')) as { bytes?: unknown };
+    if (typeof parsed.bytes !== 'string') return;
+    const event = Buffer.from(parsed.bytes, 'base64').toString('utf8');
+    res.write(`event: ${eventTypeOf(event)}\ndata: ${event}\n\n`);
+    return;
+  }
+  const errorType = message.headers[':exception-type'] ?? message.headers[':error-code'] ?? null;
+  const body = {
+    type: 'error',
+    error: { type: errorKind(500, errorType), message: upstreamMessage(message.payload.toString('utf8'), 'Bedrock stream error') },
+  };
+  res.write(`event: error\ndata: ${JSON.stringify(body)}\n\n`);
+}
+
+async function relayStream(upstream: Response, res: ServerResponse, watch: Watch): Promise<void> {
+  res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive' });
+  const body = upstream.body;
+  if (body === null) {
+    res.end();
+    return;
+  }
+  const ping = setInterval(() => res.write('event: ping\ndata: {"type":"ping"}\n\n'), PING_MS);
+  try {
+    const decoder = new EventStreamDecoder();
+    const reader = body.getReader();
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      watch.touch();
+      for (const message of decoder.push(Buffer.from(value))) writeEvent(res, message);
+    }
+  } catch (err) {
+    if (!watch.idle()) throw err;
+    res.write(errorFrame('api_error', idleMessage(watch.ms)));
+  } finally {
+    clearInterval(ping);
+    watch.stop();
+    res.end();
+  }
+}
+
+async function relayFailure(upstream: Response, res: ServerResponse): Promise<void> {
+  const text = await upstream.text();
+  sendError(res, providerStatus(upstream.status), errorKind(upstream.status, upstream.headers.get('x-amzn-errortype')), upstreamMessage(text, 'Bedrock returned no body'));
+}
+
+export async function bedrockMessages(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  model: string,
+  up: BedrockUpstream,
+): Promise<void> {
+  const rewritten = rewriteForBedrock(body, model, req.headers['anthropic-beta'], up.settings.region);
+  const upstream = await invoke(up, rewritten);
+  if (!upstream.ok) {
+    await relayFailure(upstream, res);
+    return;
+  }
+  if (rewritten.stream) {
+    await relayStream(upstream, res, up.watch);
+    return;
+  }
+  const text = await upstream.text();
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(text);
+}
+
+const estimateTokens = (body: Record<string, unknown>): number => Math.ceil(JSON.stringify(body).length / 4);
+
+export async function bedrockCount(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  model: string,
+  up: BedrockUpstream,
+): Promise<void> {
+  const rewritten = rewriteForBedrock(body, model, req.headers['anthropic-beta'], up.settings.region);
+  const url = invokeUrl(up, rewritten.modelId, 'count-tokens');
+  const upstream = await withRepairs(up, rewritten, (attempt) => callBedrock(up, url, { input: { invokeModel: { body: JSON.stringify(attempt.body) } } }, 'application/json'));
+  const text = await upstream.text();
+  let counted: number | null = null;
+  if (upstream.ok) {
+    const parsed = JSON.parse(text) as { inputTokens?: unknown };
+    if (typeof parsed.inputTokens === 'number') counted = parsed.inputTokens;
+  }
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ input_tokens: counted ?? estimateTokens(rewritten.body) }));
+}
+
+export function assertBedrockReady(settings: BedrockSettings): void {
+  if (settings.apiKey === '' || settings.region === '')
+    throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs an API key and a region: add them on the Model page.');
+}