@stage-labs/metro 0.1.0-beta.6 → 0.1.0-beta.61

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

@@ -0,0 +1,138 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import {
+  apiFailure,
+  apiSession,
+  bodyField,
+  cors,
+  readJsonBody,
+  sendJson,
+  type ApiSession,
+} from './api-http.js';
+import { parseId } from '../db/ids.js';
+
+const PREFIX = '/api/agents';
+
+export interface AgentConnectors {
+  id: string;
+  name: string;
+  connectorIds: string[];
+}
+
+export interface AgentConnectorApiDeps {
+  agentConnectors: (subject: string, agentId: string) => Promise<AgentConnectors>;
+  addConnector: (
+    subject: string,
+    agentId: string,
+    connectorId: string,
+  ) => Promise<AgentConnectors>;
+  removeConnector: (
+    subject: string,
+    agentId: string,
+    connectorId: string,
+  ) => Promise<AgentConnectors>;
+}
+
+type Routable =
+  | { kind: 'connectors'; id: string }
+  | { kind: 'connector'; id: string; connectorId: string };
+
+type Target = Routable | { kind: 'unknown' } | null;
+
+const ALLOWED: Record<Routable['kind'], string[]> = {
+  connectors: ['GET', 'POST'],
+  connector: ['DELETE'],
+};
+
+function connectorTarget(id: string, rest: string[]): Target {
+  if (rest.length === 1) return { kind: 'connectors', id };
+  if (rest.length > 2) return { kind: 'unknown' };
+  const connectorId = parseId(rest[1] ?? '');
+  return connectorId === null
+    ? { kind: 'unknown' }
+    : { kind: 'connector', id, connectorId };
+}
+
+export function target(path: string): Target {
+  if (!path.startsWith(`${PREFIX}/`)) return null;
+  const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  const id = parseId(segments[0] ?? '');
+  const head = segments[1];
+  if (id === null || head === undefined) return null;
+  if (head === 'connectors') return connectorTarget(id, segments.slice(1));
+  return null;
+}
+
+async function handleConnectors(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AgentConnectorApiDeps,
+  session: ApiSession,
+  id: string,
+): Promise<void> {
+  if (req.method === 'GET') {
+    sendJson(req, res, 200, await deps.agentConnectors(session.subject, id));
+    return;
+  }
+  const connectorId = bodyField(await readJsonBody(req), 'connectorId');
+  if (typeof connectorId !== 'string' || parseId(connectorId) === null) {
+    sendJson(req, res, 400, { error: 'connectorId is required' });
+    return;
+  }
+  sendJson(req, res, 200, await deps.addConnector(session.subject, id, connectorId));
+}
+
+async function route(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AgentConnectorApiDeps,
+  session: ApiSession,
+  tgt: Routable,
+): Promise<void> {
+  try {
+    if (tgt.kind === 'connectors') await handleConnectors(req, res, deps, session, tgt.id);
+    else
+      sendJson(
+        req,
+        res,
+        200,
+        await deps.removeConnector(session.subject, tgt.id, tgt.connectorId),
+      );
+  } catch (err) {
+    apiFailure(req, res, err, 'agent-api');
+  }
+}
+
+export function handleAgentConnectorRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AgentConnectorApiDeps,
+): boolean {
+  const tgt = target((req.url ?? '').split('?')[0] ?? '');
+  if (tgt === null) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (tgt.kind === 'unknown') {
+    sendJson(req, res, 404, { error: 'no such connector' });
+    return true;
+  }
+  if (!ALLOWED[tgt.kind].includes(req.method ?? '')) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  apiSession(req)
+    .then((session) => {
+      if (!session) {
+        sendJson(req, res, 401, { error: 'unauthorized' });
+        return;
+      }
+      return route(req, res, deps, session, tgt);
+    })
+    .catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'agent-api: unhandled error');
+    if (!res.headersSent) sendJson(req, res, 500, { error: 'agent api failed' });
+  });
+  return true;
+}

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

@@ -0,0 +1,8 @@
+export class ApiError extends Error {
+  constructor(
+    message: string,
+    readonly status: number,
+  ) {
+    super(message);
+  }
+}

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

@@ -0,0 +1,95 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from './api-error.js';
+import { errMsg, log } from './log.js';
+import { signedIdentity } from './signed-identity.js';
+import { identitySubject } from './identity-registry.js';
+
+const BODY_MAX = 4 * 1024;
+
+export interface ApiSession {
+  subject: string;
+}
+
+export function cors(req: IncomingMessage): Record<string, string> {
+  return {
+    'access-control-allow-origin': req.headers.origin ?? '*',
+    'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS',
+    'access-control-allow-headers': 'Authorization, Content-Type',
+    'access-control-allow-private-network': 'true',
+    'access-control-max-age': '86400',
+    vary: 'Origin',
+  };
+}
+
+export function sendJson(
+  req: IncomingMessage,
+  res: ServerResponse,
+  status: number,
+  body: unknown,
+): void {
+  res.writeHead(status, {
+    'content-type': 'application/json',
+    'cache-control': 'no-store',
+    ...cors(req),
+  });
+  res.end(JSON.stringify(body));
+}
+
+export async function apiSession(req: IncomingMessage): Promise<ApiSession | null> {
+  const address = await signedIdentity(req);
+  const subject = address === null ? undefined : identitySubject(address);
+  return subject === undefined ? null : { subject };
+}
+
+export interface AgentIdentity {
+  subject: string;
+  agentId: string;
+}
+
+export function projectParam(req: IncomingMessage): string | null {
+  const raw = new URL(req.url ?? '/', 'http://localhost').searchParams.get(
+    'project',
+  );
+  return raw === null || raw === '' ? null : raw;
+}
+
+export async function readJsonBody(req: IncomingMessage, max = BODY_MAX): Promise<unknown> {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  let over = false;
+  for await (const c of req) {
+    const buf = c as Buffer;
+    total += buf.length;
+    if (total > max) over = true;
+    if (!over) chunks.push(buf);
+    else if (total > 2 * max) break;
+  }
+  if (over) throw new ApiError('request body too large', 413);
+  const raw = Buffer.concat(chunks).toString('utf8').trim();
+  if (raw === '') return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new ApiError('body must be JSON', 400);
+  }
+}
+
+export function apiFailure(
+  req: IncomingMessage,
+  res: ServerResponse,
+  err: unknown,
+  label = 'agent-api',
+): void {
+  if (err instanceof ApiError) {
+    sendJson(req, res, err.status, { error: err.message });
+    return;
+  }
+  log.warn({ err: errMsg(err) }, `${label}: request failed`);
+  if (!res.headersSent) sendJson(req, res, 500, { error: `${label} failed` });
+}
+
+export function bodyField(body: unknown, key: string): unknown {
+  return typeof body === 'object' && body !== null && !Array.isArray(body)
+    ? (body as Record<string, unknown>)[key]
+    : undefined;
+}

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

@@ -0,0 +1,99 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { ID_RE } from '../db/ids.js';
+import { readFileSync } from 'node:fs';
+import { resolveCachedAttachment } from '../stations/attachments.js';
+import { writeSecure } from './secure-fs.js';
+
+const GRANT_SUFFIX = '.grant';
+
+export interface AttachmentGrant {
+  token: string;
+  agentId: string;
+  mintedAt: number;
+}
+
+function newAttachmentToken(prefix = 'at'): string {
+  return `${prefix}_${randomBytes(32).toString('base64url')}`;
+}
+
+function parseGrant(raw: string): AttachmentGrant | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+  if (typeof parsed !== 'object' || parsed === null) return undefined;
+  const { token, agentId, mintedAt } = parsed as Record<string, unknown>;
+  if (typeof token !== 'string' || token === '') return undefined;
+  if (typeof agentId !== 'string' || !ID_RE.test(agentId)) return undefined;
+  return {
+    token,
+    agentId,
+    mintedAt: typeof mintedAt === 'number' ? mintedAt : 0,
+  };
+}
+
+function readGrant(path: string): AttachmentGrant | undefined {
+  try {
+    return parseGrant(readFileSync(`${path}${GRANT_SUFFIX}`, 'utf8'));
+  } catch {
+    return undefined;
+  }
+}
+
+export function issueGrant(
+  path: string,
+  agentId: string,
+  prefix?: string,
+): string {
+  const existing = readGrant(path);
+  if (existing?.agentId === agentId) return existing.token;
+  const grant: AttachmentGrant = {
+    token: newAttachmentToken(prefix),
+    agentId,
+    mintedAt: Date.now(),
+  };
+  writeSecure(`${path}${GRANT_SUFFIX}`, `${JSON.stringify(grant)}\n`);
+  return grant.token;
+}
+
+function sameToken(presented: string, stored: string): boolean {
+  const a = Buffer.from(presented, 'utf8');
+  const b = Buffer.from(stored, 'utf8');
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+
+export function grantAllowsPath(
+  path: string,
+  owner: string,
+  presented: string,
+): boolean {
+  if (presented === '') return false;
+  const grant = readGrant(path);
+  if (grant === undefined) return false;
+  if (grant.agentId !== owner) return false;
+  return sameToken(presented, grant.token);
+}
+
+export function readAttachmentGrant(name: string): AttachmentGrant | undefined {
+  const path = resolveCachedAttachment(name);
+  return path === null ? undefined : readGrant(path);
+}
+
+export function issueAttachmentGrant(
+  name: string,
+  agentId: string,
+): string | undefined {
+  const path = resolveCachedAttachment(name);
+  return path === null ? undefined : issueGrant(path, agentId);
+}
+
+export function grantAllows(
+  name: string,
+  owner: string,
+  presented: string,
+): boolean {
+  const path = resolveCachedAttachment(name);
+  return path === null ? false : grantAllowsPath(path, owner, presented);
+}

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

@@ -0,0 +1,32 @@
+import { readFileSync } from 'node:fs';
+import { ID_RE } from '../db/ids.js';
+import { resolveCachedAttachment } from '../stations/attachments.js';
+import { writeSecure } from './secure-fs.js';
+
+const OWNER_SUFFIX = '.owner';
+
+export function recordOwner(path: string, agentId: string): void {
+  writeSecure(`${path}${OWNER_SUFFIX}`, `${agentId}\n`);
+}
+
+export function ownerOf(path: string): string | undefined {
+  let raw: string;
+  try {
+    raw = readFileSync(`${path}${OWNER_SUFFIX}`, 'utf8');
+  } catch {
+    return undefined;
+  }
+  const agentId = raw.trim();
+  return ID_RE.test(agentId) ? agentId : undefined;
+}
+
+export function recordAttachmentOwner(name: string, agentId: string): void {
+  const path = resolveCachedAttachment(name);
+  if (path === null) return;
+  recordOwner(path, agentId);
+}
+
+export function attachmentOwner(name: string): string | undefined {
+  const path = resolveCachedAttachment(name);
+  return path === null ? undefined : ownerOf(path);
+}

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

@@ -0,0 +1,128 @@
+import { createReadStream } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import {
+  guessMime,
+  resolveCachedAttachment,
+} from '../stations/attachments.js';
+import {
+  allowedAgents,
+  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 { currentTunnelUrl, webhookPort } from './tunnel.js';
+import { isLocalMode } from './paths.js';
+
+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) ?? 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(/\/+$/, '');
+  return currentTunnelUrl();
+}
+
+const servesLocally = (): boolean => isLocalMode();
+
+const localBase = (): string | null =>
+  servesLocally() ? `http://127.0.0.1:${String(webhookPort())}` : null;
+
+export const publicBaseOrDefault = (): string =>
+  publicBaseUrl() ?? localBase() ?? DEFAULT_PUBLIC_BASE;
+
+export function attachmentUrl(
+  pathOrName: string,
+  agentId: string,
+): string | null {
+  const base = publicBaseUrl() ?? localBase();
+  if (!base) return null;
+  const name = pathOrName.split('/').pop();
+  if (!name || !resolveCachedAttachment(name)) return null;
+  recordAttachmentOwner(name, agentId);
+  const token = issueAttachmentGrant(name, agentId);
+  if (token === undefined) return null;
+  return `${base}/attach/${encodeURIComponent(name)}?token=${encodeURIComponent(token)}`;
+}
+
+export function attachmentEventUrl(
+  payload: Record<string, unknown>,
+  agentId: string,
+): 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;
+  return typeof p === 'string' ? attachmentUrl(p, agentId) : null;
+}
+
+async function serveFile(
+  res: ServerResponse,
+  method: string,
+  name: string,
+): Promise<void> {
+  const path = resolveCachedAttachment(name);
+  if (!path) {
+    res.writeHead(404).end();
+    return;
+  }
+  let size: number;
+  try {
+    size = (await stat(path)).size;
+  } catch {
+    res.writeHead(404).end();
+    return;
+  }
+  res.writeHead(200, {
+    'content-type': guessMime(path),
+    'content-length': String(size),
+    'cache-control': 'private, max-age=86400',
+  });
+  if (method === 'HEAD') {
+    res.end();
+    return;
+  }
+  const stream = createReadStream(path);
+  stream.on('error', (err) => {
+    log.warn({ err: errMsg(err) }, 'attach: read stream error');
+    res.end();
+  });
+  stream.pipe(res);
+}
+
+export function handleAttachRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+): boolean {
+  const [rawPath] = (req.url ?? '').split('?', 2);
+  const m = /^\/attach\/([^/]+)$/.exec(rawPath ?? '');
+  if (!m) return false;
+  const method = req.method ?? 'GET';
+  if (method !== 'GET' && method !== 'HEAD') {
+    res.writeHead(405).end();
+    return true;
+  }
+  const name = decodeURIComponent(m[1] ?? '');
+  if (resolveCachedAttachment(name) === null) {
+    res.writeHead(404).end();
+    return true;
+  }
+  if (!authorized(req, name)) {
+    res.writeHead(401).end();
+    return true;
+  }
+  serveFile(res, method, name).catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'attach: serve error');
+    if (!res.headersSent) res.writeHead(500).end();
+  });
+  return true;
+}