@stage-labs/metro 0.1.0-beta.28 → 0.1.0-beta.280

package/runtime/node_modules/@metro-labs/daemon/src/metro-user/install.ts

@@ -0,0 +1,78 @@
+import { spawnSync } from 'node:child_process';
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import {
+  HELPER_PATH,
+  helperScript,
+  IMDS_UNIT,
+  IMDS_UNIT_PATH,
+  imdsUnitText,
+  SUDOERS_PATH,
+  sudoersText,
+  UPGRADE_UNIT_PATH,
+  upgradeUnitText,
+} from './helper-script.js';
+import { AGENT_NAME } from '../agent-user/user.js';
+
+interface InstallPaths {
+  helper: string;
+  sudoers: string;
+}
+
+type Run = (file: string, args: string[]) => void;
+
+function checked(file: string, args: string[]): void {
+  const run = spawnSync(file, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  if (run.error !== undefined) throw run.error;
+  if (run.status !== 0) throw new Error(`${file} ${args.join(' ')}: ${`${run.stdout}${run.stderr}`.trim() || `exit ${String(run.status)}`}`);
+}
+
+export function installRootHelper(paths: InstallPaths = { helper: HELPER_PATH, sudoers: SUDOERS_PATH }): void {
+  mkdirSync(dirname(paths.helper), { recursive: true, mode: 0o755 });
+  writeFileSync(paths.helper, helperScript(), { mode: 0o755 });
+  chmodSync(paths.helper, 0o755);
+  const work = mkdtempSync(join(tmpdir(), 'metro-sudoers-'));
+  try {
+    const draft = join(work, 'metro');
+    writeFileSync(draft, sudoersText(AGENT_NAME), { mode: 0o440 });
+    checked('visudo', ['-cf', draft]);
+    checked('install', ['-m', '440', draft, paths.sudoers]);
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+export function installImdsGuard(unit: string = IMDS_UNIT_PATH, run: Run = checked): void {
+  writeFileSync(unit, imdsUnitText(), { mode: 0o644 });
+  chmodSync(unit, 0o644);
+  run('systemctl', ['daemon-reload']);
+  run('systemctl', ['enable', IMDS_UNIT]);
+  run('systemctl', ['restart', IMDS_UNIT]);
+}
+
+const PLAIN_PATH = /^\/[A-Za-z0-9_./+-]+$/;
+
+export function installUpgradeUnit(node: string, unit: string = UPGRADE_UNIT_PATH, run: Run = checked): void {
+  if (!PLAIN_PATH.test(node)) throw new Error(`the root upgrade needs node by a plain absolute path, not '${node}'`);
+  writeFileSync(unit, upgradeUnitText(node), { mode: 0o644 });
+  chmodSync(unit, 0o644);
+  run('systemctl', ['daemon-reload']);
+}
+
+export function nodeArg(argv: string[]): string {
+  const at = argv.indexOf('--node');
+  const node = at < 0 ? undefined : argv[at + 1];
+  if (node === undefined) throw new Error('usage: install.ts --node <absolute path of the node that runs the root upgrade>');
+  return node;
+}
+
+if (import.meta.main) {
+  const node = nodeArg(process.argv.slice(2));
+  installRootHelper();
+  installImdsGuard();
+  installUpgradeUnit(node);
+  process.stdout.write(
+    `metro: wrote ${HELPER_PATH}, ${SUDOERS_PATH}, ${IMDS_UNIT_PATH} and ${UPGRADE_UNIT_PATH}; only root and metro reach the instance metadata service, and the root side follows every update\n`,
+  );
+}

package/runtime/node_modules/@metro-labs/daemon/src/metro-user/privilege.ts

@@ -0,0 +1,50 @@
+import { spawnSync } from 'node:child_process';
+import { HELPER_PATH, METRO_USER } from './helper-script.js';
+
+export interface PrivilegeHost {
+  platform: string;
+  uid: number | undefined;
+  user: string;
+}
+
+let metroUid: number | null | undefined;
+
+function uidOfMetro(): number | null {
+  if (metroUid !== undefined) return metroUid;
+  const run = spawnSync('getent', ['passwd', METRO_USER], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  const uid = Number(run.status === 0 ? run.stdout.split(':')[2] : NaN);
+  metroUid = Number.isInteger(uid) && uid > 0 ? uid : null;
+  return metroUid;
+}
+
+const realHost = (): PrivilegeHost => {
+  const uid = process.getuid?.();
+  const linux = process.platform === 'linux';
+  return { platform: process.platform, uid, user: linux && uid !== 0 && uid !== undefined && uid === uidOfMetro() ? METRO_USER : '' };
+};
+
+export const runningAsRoot = (host: PrivilegeHost = realHost()): boolean => host.platform === 'linux' && host.uid === 0;
+
+export const runningAsMetro = (host: PrivilegeHost = realHost()): boolean =>
+  host.platform === 'linux' && host.uid !== 0 && host.user === METRO_USER;
+
+export interface HelperResult {
+  status: number | null;
+  stdout: string;
+  stderr: string;
+}
+
+export function rootHelper(args: string[], input?: string): HelperResult {
+  const run = spawnSync('sudo', ['-n', HELPER_PATH, ...args], { encoding: 'utf8', input, stdio: ['pipe', 'pipe', 'pipe'], timeout: 180_000 });
+  return { status: run.error === undefined ? run.status : null, stdout: run.stdout ?? '', stderr: run.stderr ?? run.error?.message ?? '' };
+}
+
+export function mustHelper(args: string[], input?: string): string {
+  const run = rootHelper(args, input);
+  if (run.status !== 0) throw new Error(run.stderr.trim() || `root-helper ${args[0] ?? ''} failed`);
+  return run.stdout;
+}
+
+export const helperArgv = (args: string[]): [string, string[]] => ['sudo', ['-n', HELPER_PATH, ...args]];
+
+export const rootStepHint = (version: string): string => `as root, once: npx -y @stage-labs/metro@${version} service install --user metro`;

package/runtime/node_modules/@metro-labs/daemon/src/metro-user/root-follow.ts

@@ -0,0 +1,16 @@
+import { log } from '@metro-labs/core/log';
+import { METRO_VERSION } from '@metro-labs/core/version';
+import { rootHelper, rootStepHint, type HelperResult } from './privilege.js';
+
+export function followRelease(run: (args: string[]) => HelperResult = rootHelper, version: string = METRO_VERSION): boolean {
+  const result = run(['upgrade', version]);
+  if (result.status === 0) {
+    log.info({ version, journal: `journalctl -u metro-root-upgrade@${version}` }, 'root: asked the root side to follow this version');
+    return true;
+  }
+  log.warn(
+    { err: result.stderr.trim(), fix: rootStepHint(version) },
+    'root: the root side cannot follow updates by itself yet, since the root helper on this box predates it',
+  );
+  return false;
+}

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

@@ -0,0 +1,132 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from '@metro-labs/core/log';
+import { subscribeEvents, type MetroEvent } from '@metro-labs/core/events';
+import { eventInScope } from '../agents/scope.js';
+import { hasAnyKey } from '../agents/keys.js';
+import {
+  allowedAgents,
+  authenticate,
+} from '../mcp/request-identity.js';
+
+const KEEPALIVE_MS = 25_000;
+
+const monitorEnabled = (): boolean => hasAnyKey();
+
+function cors(req: IncomingMessage): Record<string, string> {
+  return {
+    'access-control-allow-origin': req.headers.origin ?? '*',
+    'access-control-allow-methods': 'GET, OPTIONS',
+    'access-control-allow-headers': 'Authorization, Content-Type',
+    'access-control-max-age': '86400',
+    vary: 'Origin',
+  };
+}
+
+function sendJson(
+  res: ServerResponse,
+  req: IncomingMessage,
+  status: number,
+  body: unknown,
+): void {
+  res.writeHead(status, { 'content-type': 'application/json', ...cors(req) });
+  res.end(JSON.stringify(body));
+}
+
+function startTailStream(
+  req: IncomingMessage,
+  res: ServerResponse,
+  allowed: Set<string>,
+): void {
+  res.writeHead(200, {
+    'content-type': 'text/event-stream',
+    'cache-control': 'no-cache, no-transform',
+    connection: 'keep-alive',
+    'x-accel-buffering': 'no',
+    ...cors(req),
+  });
+  const timers: { keepalive?: ReturnType<typeof setInterval> } = {};
+  const subs: { stop?: () => void } = {};
+  let done = false;
+  const cleanup = (): void => {
+    if (done) return;
+    done = true;
+    subs.stop?.();
+    if (timers.keepalive) clearInterval(timers.keepalive);
+    try {
+      res.end();
+    } catch {
+      log.debug('monitor: tail cleanup end failed');
+    }
+  };
+  const write = (chunk: string): void => {
+    if (done) return;
+    if (res.destroyed || res.writableEnded) {
+      cleanup();
+      return;
+    }
+    try {
+      res.write(chunk);
+    } catch (err) {
+      log.debug({ err: errMsg(err) }, 'monitor: tail write failed');
+      cleanup();
+    }
+  };
+  write(': metro monitor tail (live)\n\n');
+  let id = 0;
+  subs.stop = subscribeEvents((e: MetroEvent): void => {
+    if (!eventInScope(allowed, e.line)) return;
+    id += 1;
+    write(`id: ${id}\nevent: live\ndata: ${JSON.stringify(e)}\n\n`);
+  });
+  timers.keepalive = setInterval(() => {
+    write(': keepalive\n\n');
+  }, KEEPALIVE_MS);
+  timers.keepalive.unref?.();
+  req.on('close', cleanup);
+  req.on('error', cleanup);
+}
+
+function routeApi(
+  req: IncomingMessage,
+  res: ServerResponse,
+  path: string,
+  allowed: Set<string>,
+): void {
+  if (path === '/api/tail') {
+    if (req.method !== 'GET') {
+      sendJson(res, req, 405, { error: 'method not allowed' });
+      return;
+    }
+    startTailStream(req, res, allowed);
+    return;
+  }
+  sendJson(res, req, 404, { error: 'not found' });
+}
+
+function preflight(req: IncomingMessage, res: ServerResponse): boolean {
+  if (!monitorEnabled()) {
+    sendJson(res, req, 404, { error: 'not found' });
+    return true;
+  }
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  return false;
+}
+
+export function handleMonitorRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+): boolean {
+  const path = (req.url ?? '').split('?', 2)[0] ?? '';
+  if (!path.startsWith('/api/')) return false;
+  if (preflight(req, res)) return true;
+  const identity = authenticate(req);
+  if (!identity) {
+    sendJson(res, req, 401, { error: 'unauthorized' });
+    return true;
+  }
+  routeApi(req, res, path, allowedAgents(identity));
+  return true;
+}

package/runtime/node_modules/@metro-labs/daemon/src/monitor/run-event.ts

@@ -0,0 +1,139 @@
+import { classifyEvent, userSelf, type BufferedEvent, type MetroEvent, type RunEvent, type RunEventMetadata } from '@metro-labs/core/events';
+import { isRecord } from '@metro-labs/core/is-record';
+import { Line } from '@metro-labs/core/lines';
+import { STATIONS } from '@metro-labs/core/station-names';
+import { accountFromLine, allowlistForLine, lineReceives, senderPermitted } from '../agents/map.js';
+import { eventInScope } from '../agents/scope.js';
+
+const TEXT_MAX = 8_000;
+const FIELD_MAX = 512;
+const LINE_MAX = 2_048;
+const ACCOUNT_STATIONS = new Set<string>(STATIONS);
+const KINDS = new Set(['msg', 'reply', 'react', 'edit', 'delete', 'system']);
+
+function safeText(value: unknown, max: number): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  return value.slice(0, max).replace(/https?:\/\/[^\s<>"']+|\/(?:attach|api\/uploads|api\/webhooks|api\/threema)\/[^\s<>"']*/gi, (url) => /\/(?:attach|api\/uploads|api\/webhooks|api\/threema)\//i.test(url) ? '[private link]' : url).slice(0, max);
+}
+
+function validLine(line: string): boolean {
+  return typeof line === 'string' && line.length <= LINE_MAX && /^metro:\/\/[a-z][a-z0-9-]*\/[^\s?#]+$/.test(line) && !line.includes('//', 8) && !line.endsWith('/');
+}
+
+const isSelf = (line: string): boolean => line === userSelf();
+const isSynthetic = (payload: unknown): boolean => isRecord(payload) && (payload.contentType === 'attachmentSaved' || payload.contentType === 'attachmentFailed' || payload.contentType === 'transcript');
+
+function sameAccount(line: string, other: string): boolean {
+  if (!validLine(other)) return false;
+  const a = accountFromLine(line);
+  const b = accountFromLine(other);
+  return a !== undefined && b !== undefined && a.station === b.station && a.accountId === b.accountId;
+}
+
+function permittedTraffic(event: MetroEvent): boolean {
+  if (!isSelf(event.to) && !sameAccount(event.line, event.to)) return false;
+  const allowlist = allowlistForLine(event.line);
+  if (isSelf(event.from)) return !isSynthetic(event.payload) || senderPermitted(allowlist, '');
+  return sameAccount(event.line, event.from) && senderPermitted(allowlist, event.from, event.senderVerified);
+}
+
+function visible(event: MetroEvent, allowed: Set<string>): boolean {
+  if (!validLine(event.line) || !eventInScope(allowed, event.line) || !lineReceives(event.line)) return false;
+  const station = Line.station(event.line);
+  if (station !== event.station) return false;
+  if (!ACCOUNT_STATIONS.has(station)) return station === 'claude' && event.event?.type === 'system' && event.isPrivate !== true;
+  return permittedTraffic(event);
+}
+
+function attachmentType(value: unknown): 'image' | 'video' | 'audio' | 'file' {
+  if (!isRecord(value)) return 'file';
+  const mime = typeof value.mime === 'string' ? value.mime : value.contentType;
+  for (const kind of ['image', 'video', 'audio'] as const) {
+    if (value.kind === kind || (typeof mime === 'string' && mime.startsWith(`${kind}/`))) return kind;
+  }
+  return 'file';
+}
+
+function attachmentMetadata(payload: unknown): RunEventMetadata {
+  if (!isRecord(payload)) return {};
+  const saved = payload.contentType === 'attachmentSaved';
+  const failed = payload.contentType === 'attachmentFailed';
+  if (saved || failed) return {
+    attachmentCount: 1,
+    attachmentTypes: [attachmentType(payload)],
+    attachmentStatus: saved ? 'saved' : 'failed',
+    attachmentFor: safeText(payload.attachmentFor, FIELD_MAX),
+  };
+  if (!Array.isArray(payload.attachments) || payload.attachments.length === 0) return {};
+  return {
+    attachmentCount: payload.attachments.length,
+    attachmentTypes: [...new Set(payload.attachments.slice(0, 100).map(attachmentType))],
+  };
+}
+
+function reactionMetadata(event: MetroEvent): RunEventMetadata {
+  if (event.event?.type !== 'react') return {};
+  return {
+    emoji: safeText(event.event.emoji, 32),
+    ...(isRecord(event.payload) && typeof event.payload.removed === 'boolean' ? { removed: event.payload.removed } : {}),
+  };
+}
+
+function metadata(event: MetroEvent, system: boolean): RunEventMetadata {
+  const attachments = attachmentMetadata(event.payload);
+  if (system) return attachments;
+  const structured = event.event;
+  return {
+    ...attachments,
+    ...(typeof event.isPrivate === 'boolean' ? { isPrivate: event.isPrivate } : {}),
+    ...(typeof event.senderVerified === 'boolean' ? { senderVerified: event.senderVerified } : {}),
+    ...(typeof event.mentionsSelf === 'boolean' ? { mentionsSelf: event.mentionsSelf } : {}),
+    ...(typeof event.replyToSelf === 'boolean' ? { replyToSelf: event.replyToSelf } : {}),
+    ...reactionMetadata(event),
+    ...(structured !== undefined && 'targetId' in structured ? { targetId: safeText(structured.targetId, FIELD_MAX) } : {}),
+  };
+}
+
+function messageFields(event: MetroEvent, system: boolean): Partial<RunEvent> & { truncated: boolean } {
+  if (system) return { truncated: false };
+  return {
+    lineName: safeText(event.lineName, FIELD_MAX),
+    from: safeText(event.from, LINE_MAX),
+    fromName: safeText(event.fromName, FIELD_MAX),
+    fromDisplayName: safeText(event.fromDisplayName, FIELD_MAX),
+    to: safeText(event.to, LINE_MAX),
+    text: safeText(event.text, TEXT_MAX),
+    truncated: typeof event.text === 'string' && event.text.length > TEXT_MAX,
+  };
+}
+
+function validIdentity(event: MetroEvent): boolean {
+  return typeof event.id === 'string' && event.id.length <= FIELD_MAX
+    && typeof event.ts === 'string' && event.ts.length <= 64 && Number.isFinite(Date.parse(event.ts));
+}
+
+const replyId = (event: MetroEvent): string | undefined => event.replyTo ?? (event.event?.type === 'reply' ? event.event.replyTo : undefined);
+const accountId = (event: MetroEvent): string | null => ACCOUNT_STATIONS.has(event.station) ? accountFromLine(event.line)?.accountId ?? null : null;
+
+export function runEvent(entry: BufferedEvent, agentId: string): RunEvent | null {
+  const { event, busSeq } = entry;
+  if (!visible(event, new Set([agentId])) || !validIdentity(event)) return null;
+  const structured = event.event ?? classifyEvent(event);
+  if (!KINDS.has(structured.type)) return null;
+  const system = structured.type === 'system' || isSynthetic(event.payload);
+  return {
+    ...messageFields(event, system),
+    id: safeText(event.id, FIELD_MAX) ?? '',
+    seq: busSeq,
+    ts: new Date(event.ts).toISOString(),
+    kind: system ? 'system' : structured.type,
+    direction: system ? 'system' : isSelf(event.from) ? 'outbound' : 'inbound',
+    agentId,
+    station: event.station,
+    accountId: accountId(event),
+    line: event.line,
+    messageId: safeText(event.messageId, FIELD_MAX),
+    replyTo: safeText(replyId(event), FIELD_MAX),
+    metadata: metadata(event, system),
+  };
+}

package/runtime/node_modules/@metro-labs/daemon/src/monitor/run-events.ts

@@ -0,0 +1,101 @@
+import { createHash, randomUUID } from 'node:crypto';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { bufferedSince, BUS_BUFFER_MAX, currentBusSeq, type BufferedEvent, type RunEvent, type RunEventsPage } from '@metro-labs/core/events';
+import { ID_RE } from '@metro-labs/core/ids';
+import { ApiError } from '@metro-labs/http/api-error';
+import { sessionRoute } from '@metro-labs/http/api-http';
+import { accountEnabled, allowlistForAccount, knownAccounts, knownAgentIds } from '../agents/map.js';
+import { runEvent } from './run-event.js';
+
+const EPOCH = randomUUID();
+const DEFAULT_LIMIT = 100;
+const PAGE_BYTES_MAX = 1_000_000;
+const CURSOR_RE = /^([a-f0-9-]{36}):([a-f0-9]{64}):(0|[1-9]\d{0,15})$/;
+
+interface Cursor { epoch: string; policy: string; seq: number }
+interface Query { agentId: string; limit: number; cursor: Cursor | null }
+
+function cursorOf(raw: string | null): Cursor | null {
+  if (raw === null) return null;
+  const match = CURSOR_RE.exec(raw);
+  if (!match || !Number.isSafeInteger(Number(match[3]))) throw new ApiError('invalid run events cursor', 400);
+  return { epoch: match[1] ?? '', policy: match[2] ?? '', seq: Number(match[3]) };
+}
+
+function limitOf(raw: string | null): number {
+  if (raw === null) return DEFAULT_LIMIT;
+  const limit = Number(raw);
+  if (!/^[1-9]\d{0,2}$/.test(raw) || limit > BUS_BUFFER_MAX) throw new ApiError('limit must be between 1 and 500', 400);
+  return limit;
+}
+
+function queryOf(url: string): Query {
+  const params = new URL(url, 'http://localhost').searchParams;
+  for (const key of params.keys()) {
+    if (!['agent', 'limit', 'cursor'].includes(key) || params.getAll(key).length !== 1) throw new ApiError('invalid run events query', 400);
+  }
+  const agentId = params.get('agent') ?? '';
+  if (!ID_RE.test(agentId)) throw new ApiError('agent must be an agent id', 400);
+  return { agentId, limit: limitOf(params.get('limit')), cursor: cursorOf(params.get('cursor')) };
+}
+
+function policyOf(agentId: string, owner: string): string {
+  const accounts = knownAccounts().filter((account) => account.agentId === agentId).map(({ station, id }) => [
+    station, id, accountEnabled(station, id), allowlistForAccount(station, id) ?? [],
+  ]);
+  return createHash('sha256').update(JSON.stringify([owner, agentId, accounts])).digest('hex');
+}
+
+function bounded(events: RunEvent[], limit: number): RunEvent[] {
+  const rows: RunEvent[] = [];
+  let bytes = 0;
+  for (const event of events.slice(0, limit)) {
+    bytes += Buffer.byteLength(JSON.stringify(event)) + 1;
+    if (bytes > PAGE_BYTES_MAX) break;
+    rows.push(event);
+  }
+  return rows;
+}
+
+function resetNeeded(cursor: Cursor | null, policy: string, oldest: number, newest: number): boolean {
+  return cursor === null || cursor.epoch !== EPOCH || cursor.policy !== policy || cursor.seq < oldest - 1 || cursor.seq > newest;
+}
+
+function page(query: Query, owner: string): RunEventsPage {
+  const { agentId, limit, cursor } = query;
+  if (!knownAgentIds().includes(agentId)) throw new ApiError('no such agent', 404);
+  const policy = policyOf(agentId, owner);
+  const buffered = bufferedSince(0);
+  const newest = currentBusSeq();
+  const oldest = buffered[0]?.busSeq ?? newest + 1;
+  const reset = resetNeeded(cursor, policy, oldest, newest);
+  const visible = buffered.filter((entry) => reset || entry.busSeq > (cursor?.seq ?? newest)).flatMap((entry) => {
+    const event = runEvent(entry, agentId);
+    return event === null ? [] : [event];
+  });
+  const pending = reset ? visible.slice(-limit) : visible;
+  const events = bounded(pending, limit);
+  const hasMore = pending.length > events.length;
+  return {
+    events, cursor: `${EPOCH}:${policy}:${pageSeq(events, hasMore, newest)}`, hasMore, reset,
+    retention: retention(buffered, agentId),
+  };
+}
+
+const pageSeq = (events: RunEvent[], hasMore: boolean, newest: number): number => hasMore ? events.at(-1)?.seq ?? newest : newest;
+function retention(buffered: BufferedEvent[], agentId: string): RunEventsPage['retention'] {
+  let oldestAt: string | null = null;
+  for (const entry of buffered) {
+    const event = runEvent(entry, agentId);
+    if (event === null) continue;
+    oldestAt = event.ts;
+    break;
+  }
+  return { capacity: BUS_BUFFER_MAX, oldestAt, oldestSeq: buffered[0]?.busSeq ?? null };
+}
+
+export function handleRunEventsRequest(req: IncomingMessage, res: ServerResponse): boolean {
+  return sessionRoute(req, res, {
+    methods: { '/api/run/events': ['GET'] }, admin: false, label: 'run-events',
+  }, (session) => Promise.resolve(page(queryOf(req.url ?? ''), session.subject)));
+}