@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.210

package/runtime/node_modules/@metro-labs/daemon/src/files/attach-reaper.ts

@@ -0,0 +1,174 @@
+import { readdirSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  attachDir,
+  resolveCachedAttachment,
+} from '@metro-labs/core/stations/attachments';
+import { errMsg, log } from '@metro-labs/core/log';
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const MB = 1024 * 1024;
+const DEFAULT_TTL_DAYS = 7;
+const DEFAULT_MAX_MB = 2048;
+const PART_TTL_MS = 60 * 60 * 1000;
+const SWEEP_MS = 10 * 60 * 1000;
+const SIDECARS = ['.owner', '.grant'] as const;
+
+export interface AttachSweepOptions {
+  dir?: string;
+  now?: number;
+  ttlMs?: number;
+  maxBytes?: number;
+}
+
+export interface AttachSweepResult {
+  expired: number;
+  capped: number;
+  orphans: number;
+  parts: number;
+  freedBytes: number;
+}
+
+interface Entry {
+  name: string;
+  mtime: number;
+  size: number;
+}
+
+const positive = (raw: string | undefined, fallback: number): number => {
+  const value = Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+};
+
+export const attachTtlMs = (): number =>
+  positive(process.env.METRO_ATTACH_TTL_DAYS, DEFAULT_TTL_DAYS) * DAY_MS;
+
+export const attachMaxBytes = (): number =>
+  positive(process.env.METRO_ATTACH_MAX_MB, DEFAULT_MAX_MB) * MB;
+
+const cacheShaped = (name: string): boolean =>
+  resolveCachedAttachment(name) !== null;
+
+function stripSuffix(name: string, suffixes: readonly string[]): string | undefined {
+  const suffix = suffixes.find((s) => name.endsWith(s));
+  if (suffix === undefined) return undefined;
+  const base = name.slice(0, -suffix.length);
+  return cacheShaped(base) ? base : undefined;
+}
+
+function listEntries(dir: string): Entry[] {
+  let names: string[];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const entries: Entry[] = [];
+  for (const name of names) {
+    try {
+      const stat = statSync(join(dir, name));
+      if (stat.isFile()) entries.push({ name, mtime: stat.mtimeMs, size: stat.size });
+    } catch {
+      continue;
+    }
+  }
+  return entries;
+}
+
+function removeEntry(dir: string, name: string): void {
+  rmSync(join(dir, name), { force: true });
+}
+
+function removeWithSidecars(dir: string, name: string): void {
+  removeEntry(dir, name);
+  for (const suffix of SIDECARS) removeEntry(dir, `${name}${suffix}`);
+}
+
+interface Sweep {
+  dir: string;
+  now: number;
+  entries: Entry[];
+  result: AttachSweepResult;
+}
+
+function sweepParts(sweep: Sweep): Set<string> {
+  const fresh = new Set<string>();
+  for (const entry of sweep.entries) {
+    const base = stripSuffix(entry.name, ['.part']);
+    if (base === undefined) continue;
+    if (sweep.now - entry.mtime <= PART_TTL_MS) {
+      fresh.add(base);
+      continue;
+    }
+    removeEntry(sweep.dir, entry.name);
+    sweep.result.parts += 1;
+    sweep.result.freedBytes += entry.size;
+  }
+  return fresh;
+}
+
+function sweepExpired(sweep: Sweep, ttlMs: number): Entry[] {
+  const kept: Entry[] = [];
+  for (const entry of sweep.entries) {
+    if (!cacheShaped(entry.name)) continue;
+    if (sweep.now - entry.mtime <= ttlMs) {
+      kept.push(entry);
+      continue;
+    }
+    removeWithSidecars(sweep.dir, entry.name);
+    sweep.result.expired += 1;
+    sweep.result.freedBytes += entry.size;
+  }
+  return kept;
+}
+
+function sweepOrphans(sweep: Sweep, busy: Set<string>): void {
+  const present = new Set(sweep.entries.map((e) => e.name));
+  for (const entry of sweep.entries) {
+    const base = stripSuffix(entry.name, SIDECARS);
+    if (base === undefined || present.has(base) || busy.has(base)) continue;
+    removeEntry(sweep.dir, entry.name);
+    sweep.result.orphans += 1;
+  }
+}
+
+function capSize(sweep: Sweep, kept: Entry[], maxBytes: number): void {
+  let total = kept.reduce((sum, e) => sum + e.size, 0);
+  for (const entry of [...kept].sort((a, b) => a.mtime - b.mtime)) {
+    if (total <= maxBytes) return;
+    removeWithSidecars(sweep.dir, entry.name);
+    total -= entry.size;
+    sweep.result.capped += 1;
+    sweep.result.freedBytes += entry.size;
+  }
+}
+
+export function sweepAttachments(options: AttachSweepOptions = {}): AttachSweepResult {
+  const dir = options.dir ?? attachDir();
+  const sweep: Sweep = {
+    dir,
+    now: options.now ?? Date.now(),
+    entries: listEntries(dir),
+    result: { expired: 0, capped: 0, orphans: 0, parts: 0, freedBytes: 0 },
+  };
+  const busy = sweepParts(sweep);
+  const kept = sweepExpired(sweep, options.ttlMs ?? attachTtlMs());
+  sweepOrphans(sweep, busy);
+  capSize(sweep, kept, options.maxBytes ?? attachMaxBytes());
+  return sweep.result;
+}
+
+export function startAttachReaper(): void {
+  const run = (): void => {
+    try {
+      const swept = sweepAttachments();
+      if (swept.expired + swept.capped + swept.orphans + swept.parts > 0) {
+        log.info(swept, 'attachments: reaped the cache');
+      }
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'attachments: sweep failed');
+    }
+  };
+  run();
+  setInterval(run, SWEEP_MS).unref?.();
+}

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/files}/attach-serve.ts

@@ -4,44 +4,43 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import {
   guessMime,
   resolveCachedAttachment,
-} from '../stations/attachments.js';
+} from '@metro-labs/core/stations/attachments';
 import {
   allowedAgents,
-  authConfigFromEnv,
   authenticate,
   extractToken,
 } from '../mcp/request-identity.js';
 import { attachmentOwner, recordAttachmentOwner } from './attach-owner.js';
 import { grantAllows, issueAttachmentGrant } from './attach-grant.js';
-import { errMsg, log } from './log.js';
-import { loadTunnelConfig } from './tunnel.js';
+import { errMsg, log } from '@metro-labs/core/log';
+import { currentTunnelUrl } from '../net/tunnel.js';
+
+export const webhookPort = (): number => Number(process.env.METRO_WEBHOOK_PORT) || 8420;
 
 function authorized(req: IncomingMessage, name: string): boolean {
   const owner = attachmentOwner(name);
   if (owner === undefined) return false;
   if (grantAllows(name, owner, extractToken(req) ?? '')) return true;
-  return allowedAgents(authenticate(req, authConfigFromEnv()) ?? undefined).has(
+  return allowedAgents(authenticate(req) ?? undefined).has(
     owner,
   );
 }
 
-const DEFAULT_PUBLIC_BASE = 'https://mcp.metro.box';
-
 export function publicBaseUrl(): string | null {
   const env = process.env.METRO_PUBLIC_URL?.trim();
   if (env) return env.replace(/\/+$/, '');
-  const host = loadTunnelConfig()?.hostname;
-  return host ? `https://${host}` : null;
+  return currentTunnelUrl();
 }
 
-export const publicBaseOrDefault = (): string =>
-  publicBaseUrl() ?? DEFAULT_PUBLIC_BASE;
+export const loopbackBase = (): string => `http://127.0.0.1:${String(webhookPort())}`;
+
+export const publicBaseOrDefault = (): string => publicBaseUrl() ?? loopbackBase();
 
 export function attachmentUrl(
   pathOrName: string,
   agentId: string,
 ): string | null {
-  const base = publicBaseUrl();
+  const base = publicBaseUrl() ?? loopbackBase();
   if (!base) return null;
   const name = pathOrName.split('/').pop();
   if (!name || !resolveCachedAttachment(name)) return null;
@@ -57,7 +56,7 @@ export function attachmentEventUrl(
 ): string | null {
   if (payload.contentType !== 'attachmentSaved') return null;
   if (typeof payload.url === 'string' && payload.url.length > 0) return null;
-  const p = payload.attachmentPath ?? payload.localPath;
+  const p = payload.attachmentPath;
   return typeof p === 'string' ? attachmentUrl(p, agentId) : null;
 }
 

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/files}/upload-api.ts

@@ -1,17 +1,16 @@
 import { open, rename, rm, type FileHandle } from 'node:fs/promises';
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { guessMime } from '../stations/attachments.js';
+import { guessMime } from '@metro-labs/core/stations/attachments';
 import { safeFileName } from '../stations/attach-inline.js';
 import {
   allowedAgents,
-  authConfigFromEnv,
   authenticate,
   extractToken,
 } from '../mcp/request-identity.js';
-import { ApiError } from './api-error.js';
-import { apiFailure, cors, sendJson } from './api-http.js';
-import { log } from './log.js';
-import { writeSecure } from './secure-fs.js';
+import { ApiError } from '@metro-labs/http/api-error';
+import { apiFailure, cors, sendJson } from '@metro-labs/http/api-http';
+import { log } from '@metro-labs/core/log';
+import { writeSecure } from '@metro-labs/core/secure-fs';
 import {
   createUploadSlot,
   liveUploadBytes,
@@ -38,7 +37,7 @@ const VAGUE_MIMES = new Set([
 
 const mib = (n: number): string => `${Math.round(n / (1024 * 1024))} MiB`;
 
-export const uploadLimit = (): string =>
+const uploadLimit = (): string =>
   `${mib(MAX_UPLOAD_BYTES)} (${MAX_UPLOAD_BYTES} bytes)`;
 
 const tooLarge = (): string =>
@@ -69,23 +68,7 @@ const query = (req: IncomingMessage, key: string): string | undefined =>
   new URL(req.url ?? '/', 'http://localhost').searchParams.get(key) ?? undefined;
 
 const identityScope = (req: IncomingMessage): Set<string> =>
-  allowedAgents(authenticate(req, authConfigFromEnv()) ?? undefined);
-
-function ownerFromScope(req: IncomingMessage, allowed: Set<string>): string {
-  const requested = query(req, 'agent');
-  if (requested !== undefined) {
-    if (!allowed.has(requested))
-      throw new ApiError(`agent ${requested} is outside your scope`, 403);
-    return requested;
-  }
-  const [only] = [...allowed];
-  if (allowed.size === 1 && only !== undefined) return only;
-  throw new ApiError(
-    `this credential covers ${allowed.size} agents; ` +
-      'name the owning agent with ?agent=<id>',
-    400,
-  );
-}
+  allowedAgents(authenticate(req) ?? undefined);
 
 function mimeFor(req: IncomingMessage, name: string): string {
   const explicit = query(req, 'mime');
@@ -186,10 +169,10 @@ async function handleCreate(
   req: IncomingMessage,
   res: ServerResponse,
 ): Promise<void> {
-  const allowed = identityScope(req);
-  if (allowed.size === 0) throw new ApiError('unauthorized', 401);
+  const [owner] = identityScope(req);
+  if (owner === undefined) throw new ApiError('unauthorized', 401);
   const name = safeFileName(query(req, 'name'));
-  const id = createUploadSlot(ownerFromScope(req, allowed), {
+  const id = createUploadSlot(owner, {
     name,
     mime: mimeFor(req, name),
   });

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/files}/upload-store.ts

@@ -1,11 +1,11 @@
 import { randomBytes } from 'node:crypto';
 import { readdirSync, rmSync, statSync } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { ensureSecureDir, readJson, writeSecure } from './secure-fs.js';
+import { ensureSecureDir, readJson, writeSecure } from '@metro-labs/core/secure-fs';
 import { grantAllowsPath, issueGrant } from './attach-grant.js';
 import { ownerOf, recordOwner } from './attach-owner.js';
-import { errMsg, log } from './log.js';
+import { errMsg, log } from '@metro-labs/core/log';
 
 export const UPLOAD_TTL_MS = 30 * 60 * 1000;
 export const MAX_UPLOAD_BYTES = 64 * 1024 * 1024;
@@ -16,7 +16,7 @@ const SUFFIXES = ['', '.part', '.meta', '.owner', '.grant'] as const;
 const SWEEP_MS = 60_000;
 
 export const uploadDir = (): string =>
-  process.env.METRO_UPLOAD_DIR ?? join(tmpdir(), 'metro-uploads');
+  process.env.METRO_UPLOAD_DIR ?? join(homedir(), '.metro', 'uploads');
 
 export const newUploadId = (): string =>
   `up_${randomBytes(16).toString('base64url')}`;

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

@@ -0,0 +1,233 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { log } from '@metro-labs/core/log';
+import { EventStreamDecoder, type EventStreamMessage } from './eventstream.js';
+import { errorFrame, GatewayError, providerStatus, relayFrames, sendError, upstreamMessage, type Watch } from './forward.js';
+import type { Connection } from './model-config.js';
+import { estimateTokens } from './subscription.js';
+import { UsageScanner } from './usage.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;
+
+export interface Adaptations {
+  fields: Set<string>;
+  dropBetas: boolean;
+}
+
+export const freshAdaptations = (): Adaptations => ({ fields: new Set(), dropBetas: false });
+
+export interface BedrockUpstream {
+  settings: Connection;
+  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'],
+];
+
+function regionPrefix(region: string): string {
+  for (const [pattern, prefix] of PREFIXES) if (pattern.test(region)) return prefix;
+  return 'global';
+}
+
+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 !== '');
+}
+
+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 };
+}
+
+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 eventFrame(message: EventStreamMessage): string {
+  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');
+    return `event: ${eventTypeOf(event)}\ndata: ${event}\n\n`;
+  }
+  const errorType = message.headers[':exception-type'] ?? message.headers[':error-code'] ?? null;
+  return errorFrame(errorKind(500, errorType), upstreamMessage(message.payload.toString('utf8'), 'Bedrock stream error'));
+}
+
+function relayStream(upstream: Response, res: ServerResponse, watch: Watch, key: string): Promise<void> {
+  const decoder = new EventStreamDecoder();
+  return relayFrames(upstream, res, watch, key, {
+    push: (chunk, emit) => {
+      for (const message of decoder.push(Buffer.from(chunk))) emit(eventFrame(message));
+    },
+    close: () => '',
+    idle: (message) => errorFrame('api_error', message),
+  });
+}
+
+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, up.settings.id);
+    return;
+  }
+  const text = await upstream.text();
+  const scanner = new UsageScanner(up.settings.id);
+  scanner.feed(text);
+  scanner.done();
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(text);
+}
+
+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: Connection): 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.');
+}