@stage-labs/metro 0.1.0-beta.9 → 0.1.0-beta.91

package/runtime/node_modules/@metro-labs/core/src/stations/attachments.ts

@@ -0,0 +1,196 @@
+export const attachDir = (): string =>
+  process.env.METRO_XMTP_ATTACH_DIR ??
+  `${process.env.HOME}/.cache/metro/messenger-uploads`;
+
+const CACHE_NAME_RE = /^msg_[A-Za-z0-9]{1,16}_\d+\.[A-Za-z0-9]{1,5}$/;
+
+export const resolveCachedAttachment = (name: string): string | null =>
+  CACHE_NAME_RE.test(name) ? `${attachDir()}/${name}` : null;
+
+const MIME_EXT: Record<string, string> = {
+  'image/jpeg': 'jpg',
+  'image/jpg': 'jpg',
+  'image/png': 'png',
+  'image/gif': 'gif',
+  'image/webp': 'webp',
+  'image/heic': 'heic',
+  'audio/mp4': 'm4a',
+  'audio/mpeg': 'mp3',
+  'audio/ogg': 'ogg',
+  'audio/wav': 'wav',
+  'video/mp4': 'mp4',
+  'video/quicktime': 'mov',
+  'video/webm': 'webm',
+  'application/pdf': 'pdf',
+};
+
+const extFromName = (filename: string | undefined): string | undefined => {
+  const ext = filename
+    ?.split('?')[0]
+    ?.split('#')[0]
+    ?.split('.')
+    .pop()
+    ?.toLowerCase();
+  return ext !== undefined && ext.length >= 1 && ext.length <= 5
+    ? ext
+    : undefined;
+};
+
+export const extFromMime = (mime: string | undefined): string | undefined => {
+  if (mime === undefined) return undefined;
+  const mapped = MIME_EXT[mime];
+  if (mapped) return mapped;
+  if (mime.startsWith('image/')) return mime.slice(6).replace('jpeg', 'jpg');
+  return undefined;
+};
+
+const extFor = (
+  filename: string | undefined,
+  mime: string | undefined,
+): string => extFromName(filename) ?? extFromMime(mime) ?? 'bin';
+
+const cacheFileName = (
+  messageId: string,
+  index: number,
+  filename: string | undefined,
+  mime: string | undefined,
+): string => {
+  const safeId =
+    messageId.replace(/[^a-zA-Z0-9]/g, '').slice(0, 16) || 'unknown';
+  return `msg_${safeId}_${index}.${extFor(filename, mime)}`;
+};
+
+export interface SavedAttachment {
+  path: string;
+  mime?: string;
+  name?: string;
+  bytes: number;
+}
+
+export const MAX_ATTACHMENT_BYTES = Number(
+  process.env.METRO_ATTACH_MAX_BYTES ?? 100 * 1024 * 1024,
+);
+
+export function assertAttachmentSize(bytes: number): void {
+  if (bytes > MAX_ATTACHMENT_BYTES)
+    throw new Error(
+      `attachment size ${bytes} exceeds limit of ${MAX_ATTACHMENT_BYTES} bytes`,
+    );
+}
+
+export function assertContentLength(header: string | null | undefined): void {
+  if (header == null) return;
+  const n = Number(header);
+  if (Number.isFinite(n)) assertAttachmentSize(n);
+}
+
+const cachePathFor = async (
+  messageId: string,
+  index: number,
+  meta: { mime?: string; name?: string },
+): Promise<string> => {
+  const { mkdir } = await import('node:fs/promises');
+  const nodePath = await import('node:path');
+  const dir = attachDir();
+  await mkdir(dir, { recursive: true });
+  return nodePath.join(
+    dir,
+    cacheFileName(messageId, index, meta.name, meta.mime),
+  );
+};
+
+export const saveBufferToCache = async (
+  data: Uint8Array,
+  messageId: string,
+  index: number,
+  meta: { mime?: string; name?: string },
+): Promise<SavedAttachment> => {
+  assertAttachmentSize(data.length);
+  const { writeFile } = await import('node:fs/promises');
+  const path = await cachePathFor(messageId, index, meta);
+  await writeFile(path, data);
+  return { path, mime: meta.mime, name: meta.name, bytes: data.length };
+};
+
+export const saveStreamToCache = async (
+  chunks: AsyncIterable<Uint8Array>,
+  messageId: string,
+  index: number,
+  meta: { mime?: string; name?: string },
+): Promise<SavedAttachment> => {
+  const { open, rename, rm } = await import('node:fs/promises');
+  const path = await cachePathFor(messageId, index, meta);
+  const part = `${path}.part`;
+  const handle = await open(part, 'w');
+  let bytes = 0;
+  try {
+    for await (const chunk of chunks) {
+      bytes += chunk.length;
+      assertAttachmentSize(bytes);
+      await handle.write(chunk);
+    }
+  } catch (err) {
+    await handle.close();
+    await rm(part, { force: true });
+    throw err;
+  }
+  await handle.close();
+  await rename(part, path);
+  return { path, mime: meta.mime, name: meta.name, bytes };
+};
+
+export const guessMime = (path: string): string => {
+  const ext = (path.split('.').pop() ?? '').toLowerCase();
+  const map: Record<string, string> = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    heic: 'image/heic',
+    mp4: 'video/mp4',
+    mov: 'video/quicktime',
+    webm: 'video/webm',
+    m4v: 'video/x-m4v',
+    m4a: 'audio/mp4',
+    mp3: 'audio/mpeg',
+    ogg: 'audio/ogg',
+    wav: 'audio/wav',
+    pdf: 'application/pdf',
+  };
+  return map[ext] ?? 'application/octet-stream';
+};
+
+export const isImageMime = (mime: string): boolean =>
+  mime.toLowerCase().startsWith('image/');
+export const isImageExt = (path: string): boolean =>
+  /\.(png|jpe?g|gif|webp|heic|bmp|svg)$/i.test(path);
+
+export const appendFile = async (
+  form: FormData,
+  field: string,
+  path: string,
+  name: string,
+): Promise<void> => {
+  const data = await Bun.file(path).arrayBuffer();
+  form.append(field, new Blob([data]), name);
+};
+
+export const kindOf = (mime: string, path: string): string => {
+  if (isImageMime(mime) || isImageExt(path)) return 'image';
+  if (mime.startsWith('video/')) return 'video';
+  if (mime.startsWith('audio/')) return 'audio';
+  return 'file';
+};
+
+export const toCanonical = (a: {
+  path: string;
+  mime: string;
+  name: string;
+}): Record<string, unknown> => ({
+  kind: kindOf(a.mime, a.path),
+  path: a.path,
+  url: a.path,
+  name: a.name,
+  mime: a.mime,
+});

package/runtime/node_modules/@metro-labs/core/src/stations/messaging-normalize.ts

@@ -0,0 +1,88 @@
+type Args = Record<string, unknown>;
+export interface Normalized {
+  action: string;
+  args: Args;
+}
+
+interface Attachment {
+  kind?: string;
+  path?: string;
+  url?: string;
+  data?: string;
+  mime?: string;
+  name?: string;
+}
+
+interface DiscordFile {
+  file: string;
+  kind: string;
+  name: string;
+}
+
+const discordFile = (a: Attachment): DiscordFile | null => {
+  const file = a.path ?? a.url;
+  if (typeof file !== 'string') return null;
+  return { file, kind: a.kind ?? 'file', name: a.name ?? '' };
+};
+
+function discordAttachments(att: Attachment[]): Args {
+  const usable = att
+    .map(discordFile)
+    .filter((f): f is DiscordFile => f !== null);
+  if (!usable.length) return {};
+  return {
+    files: usable.map((f) => f.file),
+    attachmentKinds: usable.map((f) => f.kind),
+    attachmentNames: usable.map((f) => f.name),
+  };
+}
+
+export function normalizeDiscord(action: string, env: Args): Normalized {
+  const att = (env.attachments as Attachment[] | undefined) ?? [];
+  if (action === 'send') {
+    return { action: 'send', args: { ...env, ...discordAttachments(att) } };
+  }
+  if (action === 'reply') {
+    const replyTo = env.replyTo ?? env.messageId;
+    return {
+      action: 'send',
+      args: { ...env, replyTo, ...discordAttachments(att) },
+    };
+  }
+  if (action === 'unreact')
+    return { action: 'react', args: { ...env, emoji: '' } };
+  if (action === 'read') {
+    return {
+      action: 'fetch',
+      args: { line: env.line, limit: env.limit, before: env.before },
+    };
+  }
+  return { action, args: env };
+}
+
+export function normalizeTelegram(action: string, env: Args): Normalized {
+  if (action === 'reply') {
+    return {
+      action: 'send',
+      args: {
+        line: env.line,
+        text: env.text,
+        replyTo: env.replyTo,
+        attachments: env.attachments,
+      },
+    };
+  }
+  if (action === 'unreact')
+    return { action: 'react', args: { ...env, emoji: '' } };
+  return { action, args: env };
+}
+
+export function normalizeXmtp(action: string, env: Args): Normalized {
+  if (action === 'unreact') {
+    return { action: 'react', args: { ...env, action: 'removed' } };
+  }
+  if (action === 'read') {
+    return { action: 'query', args: { line: env.line, limit: env.limit } };
+  }
+  return { action, args: env };
+}

package/runtime/node_modules/@metro-labs/core/src/stations/station-runtime.ts

@@ -0,0 +1,64 @@
+import { serializeTrainError, type TrainErrorInfo } from '../train-error.js';
+import type { Normalized } from './messaging-normalize.js';
+
+export const emit = (e: unknown): void =>
+  void process.stdout.write(JSON.stringify(e) + '\n');
+
+export const respond = (
+  id: string,
+  body: { result?: unknown; error?: string; errorInfo?: TrainErrorInfo },
+): void =>
+  void process.stdout.write(
+    JSON.stringify({ op: 'response', id, ...body }) + '\n',
+  );
+
+export const mintId = (): string =>
+  `msg_${Math.random().toString(36).slice(2, 10)}`;
+
+type Args = Record<string, unknown>;
+
+export interface CallMsg {
+  op: 'call';
+  id: string;
+  action: string;
+  args: Args;
+}
+
+export type StationHandler = (id: string, args: Args) => void | Promise<void>;
+
+export interface StationConfig {
+  handlers: Record<string, StationHandler>;
+  normalize: (action: string, args: Args) => Normalized;
+  preDispatch?: (id: string, action: string) => boolean;
+}
+
+const lineTag = (args: Args): string =>
+  typeof args.line === 'string' ? args.line : '?';
+
+export function makeStation({ handlers, normalize, preDispatch }: StationConfig) {
+  const known = Object.keys(handlers).join(', ');
+  return async function handleCall(msg: CallMsg): Promise<void> {
+    const { id } = msg;
+    let action = msg.action;
+    let args: Args = msg.args;
+    try {
+      ({ action, args } = normalize(msg.action, msg.args));
+      emit({ op: 'log', text: `call ${action} recv (line=${lineTag(args)})` });
+      if (preDispatch?.(id, action)) return;
+      const handler = handlers[action];
+      if (!handler) {
+        respond(id, { error: `unknown action '${action}' (have: ${known})` });
+        return;
+      }
+      await handler(id, args);
+      emit({ op: 'log', text: `call ${action} done (line=${lineTag(args)})` });
+    } catch (err) {
+      const info = serializeTrainError(err);
+      emit({
+        op: 'log',
+        text: `call ${action} FAILED (line=${lineTag(args)}): ${info.error}`,
+      });
+      respond(id, info);
+    }
+  };
+}

package/runtime/node_modules/@metro-labs/core/src/stations/types.ts

@@ -0,0 +1,107 @@
+export type Verb =
+  | 'send'
+  | 'reply'
+  | 'react'
+  | 'unreact'
+  | 'edit'
+  | 'delete'
+  | 'read';
+
+export interface ToolResult {
+  content: { type: 'text'; text: string }[];
+  isError?: boolean;
+}
+
+export interface CanonicalAttachment {
+  path?: string;
+  url?: string;
+  data?: string;
+  upload?: string;
+  mime?: string;
+  name?: string;
+}
+
+export interface ToolContext {
+  call(
+    action: string,
+    args: Record<string, unknown>,
+  ): Promise<{ result: unknown }>;
+  ok(text: string): ToolResult;
+  okJson(value: unknown): ToolResult;
+  err(text: string): ToolResult;
+  readFile(path: string): Promise<Buffer>;
+}
+
+export interface StationTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  handle(args: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult>;
+}
+
+export interface MetroMember {
+  id: string;
+  name?: string;
+  display_name?: string;
+  address?: string;
+  roles?: string[];
+  is_admin?: boolean;
+  is_bot?: boolean;
+}
+
+export interface MemberCapability {
+  supported: boolean;
+  complete: boolean;
+  reason?: string;
+  total?: number;
+}
+
+export interface MemberList {
+  members: MetroMember[];
+  capability: MemberCapability;
+}
+
+export type GroupOp =
+  | 'create_group'
+  | 'add_members'
+  | 'remove_members'
+  | 'invite_link';
+
+export type MemberOutcomeStatus = 'added' | 'invited' | 'removed' | 'failed';
+
+export interface MemberOutcome {
+  id: string;
+  status: MemberOutcomeStatus;
+  reason?: string;
+}
+
+export interface GroupCapability {
+  supported: boolean;
+  reason?: string;
+}
+
+export interface GroupResult {
+  capability: GroupCapability;
+  line?: string;
+  id?: string;
+  name?: string;
+  members?: MemberOutcome[];
+  inviteLink?: string;
+}
+
+export type AttachmentMode = 'canonical' | 'native' | 'none';
+
+export interface Station {
+  name: string;
+  hasAccounts: boolean;
+  hasTrain: boolean;
+  messageVerbs: ReadonlySet<Verb>;
+  groupOps?: ReadonlySet<GroupOp>;
+  attachmentMode: AttachmentMode;
+  sendAttachments?(
+    line: string,
+    atts: CanonicalAttachment[],
+    ctx: ToolContext,
+  ): Promise<string[]>;
+  tools: StationTool[];
+}

package/runtime/node_modules/@metro-labs/core/src/str.ts

@@ -0,0 +1,5 @@
+export function str(v: unknown): string {
+  if (typeof v === 'string') return v;
+  if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+  return '';
+}

package/runtime/node_modules/@metro-labs/core/src/train-error.ts

@@ -0,0 +1,53 @@
+export interface TrainErrorInfo {
+  code: string;
+  message: string;
+  retryable?: boolean;
+  retryAfterMs?: number;
+}
+
+export class TrainError extends Error {
+  readonly code: string;
+  readonly retryable?: boolean;
+  readonly retryAfterMs?: number;
+  constructor(
+    code: string,
+    message: string,
+    opts?: { retryable?: boolean; retryAfterMs?: number },
+  ) {
+    super(message);
+    this.name = 'TrainError';
+    this.code = code;
+    this.retryable = opts?.retryable;
+    this.retryAfterMs = opts?.retryAfterMs;
+  }
+  toErrorInfo(): TrainErrorInfo {
+    return {
+      code: this.code,
+      message: this.message,
+      ...(this.retryable !== undefined ? { retryable: this.retryable } : {}),
+      ...(this.retryAfterMs !== undefined
+        ? { retryAfterMs: this.retryAfterMs }
+        : {}),
+    };
+  }
+}
+
+export function serializeTrainError(err: unknown): {
+  error: string;
+  errorInfo?: TrainErrorInfo;
+} {
+  if (err instanceof TrainError)
+    return { error: err.message, errorInfo: err.toErrorInfo() };
+  return { error: err instanceof Error ? err.message : String(err) };
+}
+
+export function coerceErrorInfo(v: unknown): TrainErrorInfo | undefined {
+  if (!v || typeof v !== 'object') return undefined;
+  const o = v as Record<string, unknown>;
+  if (typeof o.code !== 'string' || typeof o.message !== 'string')
+    return undefined;
+  const info: TrainErrorInfo = { code: o.code, message: o.message };
+  if (typeof o.retryable === 'boolean') info.retryable = o.retryable;
+  if (typeof o.retryAfterMs === 'number') info.retryAfterMs = o.retryAfterMs;
+  return info;
+}

package/runtime/node_modules/@metro-labs/core/src/version.ts

@@ -0,0 +1,2 @@
+export const METRO_VERSION =
+  process.env.METRO_VERSION ?? process.env.npm_package_version ?? 'dev';

package/runtime/node_modules/@metro-labs/daemon/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@metro-labs/daemon",
+  "version": "0.1.0-beta.15",
+  "private": true,
+  "description": "The metro daemon a user runs on their own machine with `metro serve`: the MCP server Claude Code connects to, the station subprocesses it supervises, the model gateway, and the signed-identity APIs the page at metro.box talks to.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bonustrack/metro.git"
+  },
+  "homepage": "https://github.com/bonustrack/metro#readme",
+  "bugs": "https://github.com/bonustrack/metro/issues",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": "./src/mcp/index.ts"
+  },
+  "scripts": {
+    "start": "bun src/server.ts",
+    "build": "tsc",
+    "test": "tsc --noEmit && DYLD_FALLBACK_LIBRARY_PATH=/usr/lib METRO_STATE_DIR=\"$(mktemp -d /tmp/metro-test.XXXXXX)\" bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/core": "workspace:*",
+    "@metro-labs/http": "workspace:*",
+    "@metro-labs/discord-bot": "workspace:*",
+    "@metro-labs/telegram": "workspace:*",
+    "@metro-labs/telegram-bot": "workspace:*",
+    "@metro-labs/webhook": "workspace:*",
+    "@metro-labs/whatsapp": "workspace:*",
+    "@metro-labs/xmtp": "workspace:*",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "viem": "2.52.2",
+    "ws": "^8.18.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.2",
+    "@types/ws": "^8.18.0",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}

package/runtime/node_modules/@metro-labs/daemon/src/agents/account-attach.ts

@@ -0,0 +1,19 @@
+import { STATIONS, type StationName } from '@metro-labs/core/station-names';
+
+const ACCOUNT_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+
+export interface AccountRef {
+  agentId: string;
+  station: StationName;
+  accountId: string;
+}
+
+export function isStationName(raw: unknown): raw is StationName {
+  return (
+    typeof raw === 'string' && (STATIONS as readonly string[]).includes(raw)
+  );
+}
+
+export function parseAccountId(raw: string): string | null {
+  return ACCOUNT_ID_RE.test(raw) ? raw : null;
+}