@stage-labs/metro 0.1.0-beta.4 → 0.1.0-beta.41

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

@@ -0,0 +1,145 @@
+import { execFileSync } from 'node:child_process';
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  unlinkSync,
+  writeSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { log } from './log.js';
+
+export const STATE_DIR =
+  process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
+mkdirSync(STATE_DIR, { recursive: true });
+
+export const configDir = (): string =>
+  process.env.METRO_CONFIG_DIR ??
+  join(process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), 'metro');
+export const CONFIG_DIR = configDir();
+export const CONFIG_ENV_FILE = join(CONFIG_DIR, '.env');
+
+export const TRAINS_ENV_FILE = join(homedir(), '.metro', '.env');
+
+export function trainsDir(): string {
+  const env = process.env.METRO_TRAINS_DIR?.trim();
+  if (env !== undefined && env !== '') return env;
+  return fileURLToPath(new URL('../../trains', import.meta.url));
+}
+
+export const isLocalMode = (): boolean =>
+  process.env.METRO_MODE?.trim() === 'local';
+
+export const envSources = (): readonly string[] => [
+  join(process.cwd(), '.env'),
+  TRAINS_ENV_FILE,
+  CONFIG_ENV_FILE,
+];
+
+const LINE_RE = /^\s*([A-Za-z_]\w*)\s*=\s*(.*?)\s*$/;
+const QUOTED_RE = /^(['"])(.*)\1$/;
+
+export function readDotenv(path: string): Record<string, string> {
+  if (!existsSync(path)) return {};
+  const out: Record<string, string> = {};
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    const m = LINE_RE.exec(line);
+    if (m?.[1] !== undefined && m[2] !== undefined)
+      out[m[1]] = m[2].replace(QUOTED_RE, '$2');
+  }
+  return out;
+}
+
+export function loadMetroEnv(): void {
+  for (const path of envSources()) {
+    for (const [k, v] of Object.entries(readDotenv(path))) {
+      process.env[k] ??= v;
+    }
+  }
+}
+
+function readLockPid(lockFile: string): number {
+  try {
+    return Number(readFileSync(lockFile, 'utf8').trim());
+  } catch {
+    return NaN;
+  }
+}
+
+function namesMetro(text: string): boolean {
+  return text.includes('server.ts') || text.includes('metro');
+}
+
+function holderIsMetro(pid: number): boolean {
+  try {
+    return namesMetro(readFileSync(`/proc/${pid}/cmdline`, 'utf8'));
+  } catch {
+    return holderCommand(pid);
+  }
+}
+
+function holderCommand(pid: number): boolean {
+  try {
+    return namesMetro(
+      execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }),
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function lockHeldByLiveDaemon(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  return holderIsMetro(pid);
+}
+
+function writeOwnLock(lockFile: string): void {
+  const fd = openSync(lockFile, 'wx');
+  writeSync(fd, String(process.pid));
+  closeSync(fd);
+  process.on('exit', () => {
+    try {
+      if (readFileSync(lockFile, 'utf8').trim() === String(process.pid))
+        unlinkSync(lockFile);
+    } catch {
+    }
+  });
+}
+
+export function acquireLock(lockFile: string): void {
+  for (let attempt = 0; attempt < 5; attempt++) {
+    try {
+      writeOwnLock(lockFile);
+      return;
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== 'EEXIST') throw err;
+      const pid = readLockPid(lockFile);
+      if (lockHeldByLiveDaemon(pid)) {
+        log.info(
+          { pid },
+          'a healthy `metro` daemon is already running; exiting (no second dispatcher)',
+        );
+        process.exit(0);
+      }
+      try {
+        unlinkSync(lockFile);
+      } catch {
+      }
+    }
+  }
+  throw new Error(
+    `metro: could not acquire dispatcher lock (${lockFile}) after retries`,
+  );
+}

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

@@ -0,0 +1,214 @@
+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';
+import type { Member, Project } from '../db/projects.js';
+
+const PREFIX = '/api/projects';
+
+export interface ProjectApiDeps {
+  listProjects: (subject: string) => Promise<Project[]>;
+  createProject: (subject: string, name: unknown) => Promise<Project>;
+  renameProject: (
+    subject: string,
+    id: string,
+    name: unknown,
+  ) => Promise<Project>;
+  deleteProject: (
+    subject: string,
+    id: string,
+  ) => Promise<{ id: string; name: string }>;
+  listMembers: (subject: string, id: string) => Promise<Member[]>;
+  addMember: (
+    subject: string,
+    id: string,
+    invited: unknown,
+    role: unknown,
+  ) => Promise<Member[]>;
+  setMemberRole: (
+    subject: string,
+    id: string,
+    memberId: string,
+    role: unknown,
+  ) => Promise<Member[]>;
+  removeMember: (
+    subject: string,
+    id: string,
+    memberId: string,
+  ) => Promise<Member[]>;
+}
+
+type Routable =
+  | { kind: 'index' }
+  | { kind: 'project'; id: string }
+  | { kind: 'rename'; id: string }
+  | { kind: 'members'; id: string }
+  | { kind: 'member'; id: string; memberId: string };
+
+type Target = Routable | { kind: 'unknown' } | null;
+
+const ALLOWED: Record<Routable['kind'], string[]> = {
+  index: ['GET', 'POST'],
+  project: ['DELETE'],
+  rename: ['POST'],
+  members: ['GET', 'POST'],
+  member: ['POST', 'DELETE'],
+};
+
+function memberTarget(id: string, rest: string[]): Target {
+  if (rest.length === 1) return { kind: 'members', id };
+  if (rest.length > 2) return { kind: 'unknown' };
+  const memberId = parseId(rest[1] ?? '');
+  return memberId === null
+    ? { kind: 'unknown' }
+    : { kind: 'member', id, memberId };
+}
+
+function subTarget(id: string, rest: string[]): Target {
+  if (rest.length === 0) return { kind: 'project', id };
+  const head = rest[0];
+  if (head === 'members') return memberTarget(id, rest);
+  if (rest.length > 1) return { kind: 'unknown' };
+  if (head === 'rename') return { kind: 'rename', id };
+  return { kind: 'unknown' };
+}
+
+function target(path: string): Target {
+  if (path === PREFIX || path === `${PREFIX}/`) return { kind: 'index' };
+  if (!path.startsWith(`${PREFIX}/`)) return null;
+  const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  const head = segments[0];
+  if (head === undefined) return { kind: 'index' };
+  const id = parseId(head);
+  return id === null ? { kind: 'unknown' } : subTarget(id, segments.slice(1));
+}
+
+async function handleIndex(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ProjectApiDeps,
+  session: ApiSession,
+): Promise<void> {
+  if (req.method === 'GET') {
+    sendJson(req, res, 200, { projects: await deps.listProjects(session.subject) });
+    return;
+  }
+  const made = await deps.createProject(
+    session.subject,
+    bodyField(await readJsonBody(req), 'name'),
+  );
+  log.info({ id: made.id, name: made.name }, 'project-api: created project');
+  sendJson(req, res, 201, made);
+}
+
+async function handleMembers(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ProjectApiDeps,
+  session: ApiSession,
+  id: string,
+): Promise<void> {
+  if (req.method === 'GET') {
+    sendJson(req, res, 200, { members: await deps.listMembers(session.subject, id) });
+    return;
+  }
+  const body = await readJsonBody(req);
+  const members = await deps.addMember(
+    session.subject,
+    id,
+    bodyField(body, 'address'),
+    bodyField(body, 'role'),
+  );
+  sendJson(req, res, 200, { members });
+}
+
+async function handleMember(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ProjectApiDeps,
+  session: ApiSession,
+  tgt: { id: string; memberId: string },
+): Promise<void> {
+  if (req.method === 'DELETE') {
+    const members = await deps.removeMember(session.subject, tgt.id, tgt.memberId);
+    sendJson(req, res, 200, { members });
+    return;
+  }
+  const members = await deps.setMemberRole(
+    session.subject,
+    tgt.id,
+    tgt.memberId,
+    bodyField(await readJsonBody(req), 'role'),
+  );
+  sendJson(req, res, 200, { members });
+}
+
+async function route(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ProjectApiDeps,
+  session: ApiSession,
+  tgt: Routable,
+): Promise<void> {
+  try {
+    if (tgt.kind === 'index') await handleIndex(req, res, deps, session);
+    else if (tgt.kind === 'members')
+      await handleMembers(req, res, deps, session, tgt.id);
+    else if (tgt.kind === 'member')
+      await handleMember(req, res, deps, session, tgt);
+    else if (tgt.kind === 'rename')
+      sendJson(
+        req,
+        res,
+        200,
+        await deps.renameProject(
+          session.subject,
+          tgt.id,
+          bodyField(await readJsonBody(req), 'name'),
+        ),
+      );
+    else sendJson(req, res, 200, await deps.deleteProject(session.subject, tgt.id));
+  } catch (err) {
+    apiFailure(req, res, err, 'project-api');
+  }
+}
+
+export function handleProjectApiRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ProjectApiDeps,
+): 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 project' });
+    return true;
+  }
+  if (!ALLOWED[tgt.kind].includes(req.method ?? '')) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  const session = apiSession(req);
+  if (!session) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return true;
+  }
+  route(req, res, deps, session, tgt).catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'project-api: unhandled error');
+    if (!res.headersSent)
+      sendJson(req, res, 500, { error: 'project api failed' });
+  });
+  return true;
+}

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

@@ -0,0 +1,224 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join, parse as parsePath } from 'node:path';
+import { errMsg, log } from './log.js';
+import { coerceErrorInfo, type TrainErrorInfo } from './train-error.js';
+import type { StructuredEvent } from './events.js';
+import type { CallMsg } from '../stations/station-runtime.js';
+
+export {
+  TrainError,
+  serializeTrainError,
+  type TrainErrorInfo,
+} from './train-error.js';
+
+export const CALL_TIMEOUT_MS = 60_000;
+
+export interface Pending {
+  resolve: (r: TrainCallResponse) => void;
+  reject: (err: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+export interface CallTarget {
+  name: string;
+  pending: Map<string, Pending>;
+  proc: ({ stdin?: unknown } & Record<string, unknown>) | null;
+}
+
+export const STDOUT_LINE_MAX = 4 * 1024 * 1024;
+
+export type TrainEvent = {
+  station?: string;
+  line?: string;
+  line_name?: string;
+  from?: string;
+  from_name?: string;
+  from_display_name?: string;
+  to?: string;
+  message_id?: string;
+  reply_to?: string;
+  is_private?: boolean;
+  text?: string;
+  emoji?: string;
+  payload?: unknown;
+  ts?: string;
+  id?: string;
+  event?: StructuredEvent;
+} & Record<string, unknown>;
+
+export interface TrainCallResponse {
+  result?: unknown;
+  error?: string;
+  errorInfo?: TrainErrorInfo;
+}
+
+export type TrainMessage =
+  | {
+      op: 'response';
+      id: string;
+      result?: unknown;
+      error?: string;
+      errorInfo?: TrainErrorInfo;
+    }
+  | { op: 'log'; text?: string }
+  | { op: 'event'; event: TrainEvent }
+  | { op: 'ignore' };
+
+export function parseTrainLine(
+  name: string,
+  line: string,
+): TrainMessage | null {
+  let msg: {
+    op?: string;
+    id?: string;
+    result?: unknown;
+    error?: string;
+    errorInfo?: unknown;
+    text?: string;
+  } & Record<string, unknown>;
+  try {
+    msg = JSON.parse(line) as typeof msg;
+  } catch (err) {
+    log.warn(
+      { name, err: errMsg(err), line: line.slice(0, 200) },
+      'train: bad JSON',
+    );
+    return null;
+  }
+  if (msg.op === 'response') {
+    if (typeof msg.id !== 'string') return { op: 'ignore' };
+    return {
+      op: 'response',
+      id: msg.id,
+      result: msg.result,
+      error: msg.error,
+      errorInfo: coerceErrorInfo(msg.errorInfo),
+    };
+  }
+  if (msg.op === 'log') return { op: 'log', text: msg.text };
+  if (typeof msg.line !== 'string') {
+    log.warn(
+      { name, line: line.slice(0, 200) },
+      'train: event missing `line` (string) — dropped',
+    );
+    return { op: 'ignore' };
+  }
+  return { op: 'event', event: msg };
+}
+
+export function drainLines(
+  name: string,
+  buf: string,
+  onLine: (line: string) => void,
+): string {
+  if (buf.length > STDOUT_LINE_MAX && !buf.includes('\n')) {
+    log.warn(
+      { name, bytes: buf.length },
+      'train: dropping oversized stdout line',
+    );
+    return '';
+  }
+  let nl;
+  while ((nl = buf.indexOf('\n')) !== -1) {
+    const line = buf.slice(0, nl).trim();
+    buf = buf.slice(nl + 1);
+    if (!line) continue;
+    onLine(line);
+  }
+  return buf;
+}
+
+export function readCalls(
+  name: string,
+  handleCall: (msg: CallMsg) => Promise<void>,
+): void {
+  let buf = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk: Buffer | string) => {
+    buf += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+    buf = drainLines(name, buf, (line) => {
+      try {
+        const msg = JSON.parse(line) as Partial<CallMsg>;
+        if (msg.op === 'call')
+          handleCall(msg as CallMsg).catch((e: unknown) => {
+            process.stderr.write(`call failed: ${errMsg(e)}\n`);
+          });
+      } catch (err: unknown) {
+        process.stderr.write(`bad stdin line: ${errMsg(err)}\n`);
+      }
+    });
+  });
+}
+
+export function encodeCall(id: string, action: string, args: unknown): string {
+  return JSON.stringify({ op: 'call', id, action, args }) + '\n';
+}
+
+function isTrainFile(name: string): boolean {
+  return (
+    /\.(ts|js|mjs)$/.test(name) &&
+    !name.startsWith('_') &&
+    !name.startsWith('.')
+  );
+}
+
+export function listTrainFiles(dir: string): { name: string; path: string }[] {
+  return readdirSync(dir)
+    .filter(isTrainFile)
+    .map((f) => ({ name: parsePath(f).name, path: join(dir, f) }))
+    .filter((t) => {
+      try {
+        return statSync(t.path).isFile();
+      } catch {
+        return false;
+      }
+    });
+}
+
+export function mintCallId(seq: number): string {
+  return `req_${seq}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export function failAllPending(
+  pending: Map<string, Pending>,
+  reason: string,
+): void {
+  for (const p of pending.values()) {
+    clearTimeout(p.timer);
+    p.reject(new Error(reason));
+  }
+  pending.clear();
+}
+
+export function sendCall(
+  t: CallTarget,
+  id: string,
+  action: string,
+  args: unknown,
+): Promise<TrainCallResponse> {
+  return new Promise<TrainCallResponse>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      t.pending.delete(id);
+      reject(
+        new Error(
+          `train '${t.name}' call '${action}' timed out after ${CALL_TIMEOUT_MS}ms`,
+        ),
+      );
+    }, CALL_TIMEOUT_MS);
+    t.pending.set(id, { resolve, reject, timer });
+    try {
+      const stdin = (
+        t.proc as {
+          stdin?: { write: (s: string) => void; flush: () => void };
+        } | null
+      )?.stdin;
+      if (!stdin || typeof stdin === 'number')
+        throw new Error('stdin not piped');
+      stdin.write(encodeCall(id, action, args));
+      stdin.flush();
+    } catch (err) {
+      clearTimeout(timer);
+      t.pending.delete(id);
+      reject(new Error(`train '${t.name}' stdin write failed: ${errMsg(err)}`));
+    }
+  });
+}