@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

package/runtime/node_modules/@metro-labs/daemon/src/server/cloudwatch.ts

@@ -0,0 +1,178 @@
+import { readFile, statfs } from 'node:fs/promises';
+import { uptime } from 'node:os';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { signV4 } from '@metro-labs/http/sigv4';
+
+const IMDS = 'http://169.254.169.254/latest';
+const EVERY_MS = 60_000;
+const FIRST_MS = 15_000;
+const IMDS_TIMEOUT_MS = 2_000;
+const SEND_TIMEOUT_MS = 15_000;
+const NAMESPACE = 'CWAgent';
+const CONTENT_TYPE = 'application/x-www-form-urlencoded; charset=utf-8';
+const BOOT_WINDOW_S = 300;
+const SENT = 'sending memory and disk to CloudWatch every minute';
+
+export interface Readings {
+  memory: number;
+  disk: number;
+}
+
+export interface Started {
+  name: 'server_booted' | 'metro_started';
+  at: number;
+}
+
+interface RoleKeys {
+  accessKeyId: string;
+  secretAccessKey: string;
+  sessionToken: string;
+}
+
+interface Instance {
+  instanceId: string;
+  region: string;
+  keys: RoleKeys | null;
+}
+
+export interface PublisherDeps {
+  fetch: (url: string, init: RequestInit) => Promise<Response>;
+  readings: () => Promise<Readings | null>;
+}
+
+export function memoryPercent(meminfo: string): number | null {
+  const kb = (name: string): number | null => {
+    const match = new RegExp(`^${name}:\\s+(\\d+) kB`, 'm').exec(meminfo);
+    return match === null ? null : Number(match[1]);
+  };
+  const total = kb('MemTotal');
+  const available = kb('MemAvailable');
+  if (total === null || available === null || total <= 0) return null;
+  return ((total - available) / total) * 100;
+}
+
+export function diskPercent(fs: { blocks: number; bfree: number; bavail: number }): number | null {
+  const used = fs.blocks - fs.bfree;
+  const room = used + fs.bavail;
+  return room > 0 ? (used / room) * 100 : null;
+}
+
+async function liveReadings(): Promise<Readings | null> {
+  const memory = memoryPercent(await readFile('/proc/meminfo', 'utf8'));
+  const disk = diskPercent(await statfs('/'));
+  return memory === null || disk === null ? null : { memory, disk };
+}
+
+const LIVE: PublisherDeps = { fetch: (url, init) => fetch(url, init), readings: liveReadings };
+
+async function imdsGet(deps: PublisherDeps, token: string, path: string): Promise<string> {
+  const res = await deps.fetch(`${IMDS}/${path}`, { headers: { 'x-aws-ec2-metadata-token': token }, signal: AbortSignal.timeout(IMDS_TIMEOUT_MS) });
+  return res.ok ? (await res.text()).trim() : '';
+}
+
+async function imdsToken(deps: PublisherDeps): Promise<string> {
+  try {
+    const res = await deps.fetch(`${IMDS}/api/token`, {
+      method: 'PUT',
+      headers: { 'x-aws-ec2-metadata-token-ttl-seconds': '300' },
+      signal: AbortSignal.timeout(IMDS_TIMEOUT_MS),
+    });
+    return res.ok ? (await res.text()).trim() : '';
+  } catch {
+    return '';
+  }
+}
+
+function keysOf(raw: string): RoleKeys | null {
+  const parsed: unknown = JSON.parse(raw);
+  if (!isRecord(parsed)) return null;
+  const { AccessKeyId: accessKeyId, SecretAccessKey: secretAccessKey, Token: sessionToken } = parsed;
+  if (typeof accessKeyId !== 'string' || typeof secretAccessKey !== 'string' || typeof sessionToken !== 'string') return null;
+  return { accessKeyId, secretAccessKey, sessionToken };
+}
+
+export async function thisInstance(deps: PublisherDeps): Promise<Instance | null> {
+  const token = await imdsToken(deps);
+  if (token === '') return null;
+  const instanceId = await imdsGet(deps, token, 'meta-data/instance-id');
+  const region = await imdsGet(deps, token, 'meta-data/placement/region');
+  if (instanceId === '' || region === '') return null;
+  const role = (await imdsGet(deps, token, 'meta-data/iam/security-credentials/')).split('\n')[0] ?? '';
+  if (role === '') return { instanceId, region, keys: null };
+  return { instanceId, region, keys: keysOf(await imdsGet(deps, token, `meta-data/iam/security-credentials/${role}`)) };
+}
+
+export function startedOf(nowMs: number, processSeconds: number, bootSeconds: number): Started {
+  const at = (secondsAgo: number): number => Math.round(nowMs / 1000 - secondsAgo);
+  return bootSeconds < BOOT_WINDOW_S ? { name: 'server_booted', at: at(bootSeconds) } : { name: 'metro_started', at: at(processSeconds) };
+}
+
+export function readingParams(instanceId: string, readings: Readings, started: Started | null = null): Record<string, string> {
+  const datum = (at: number, name: string, value: number, dims: [string, string][], unit = 'Percent'): [string, string][] => [
+    [`MetricData.member.${String(at)}.MetricName`, name],
+    [`MetricData.member.${String(at)}.Unit`, unit],
+    [`MetricData.member.${String(at)}.Value`, value.toFixed(2)],
+    ...dims.flatMap(([key, v], i): [string, string][] => [
+      [`MetricData.member.${String(at)}.Dimensions.member.${String(i + 1)}.Name`, key],
+      [`MetricData.member.${String(at)}.Dimensions.member.${String(i + 1)}.Value`, v],
+    ]),
+  ];
+  return Object.fromEntries([
+    ['Action', 'PutMetricData'],
+    ['Version', '2010-08-01'],
+    ['Namespace', NAMESPACE],
+    ...datum(1, 'mem_used_percent', readings.memory, [['InstanceId', instanceId]]),
+    ...datum(2, 'disk_used_percent', readings.disk, [
+      ['InstanceId', instanceId],
+      ['path', '/'],
+    ]),
+    ...(started === null ? [] : datum(3, started.name, started.at, [['InstanceId', instanceId]], 'Seconds')),
+  ]);
+}
+
+async function send(deps: PublisherDeps, instance: Instance, keys: RoleKeys, readings: Readings, started: Started | null): Promise<void> {
+  const url = `https://monitoring.${instance.region}.amazonaws.com/`;
+  const body = new URLSearchParams(readingParams(instance.instanceId, readings, started)).toString();
+  const signed = await signV4({ method: 'POST', url, headers: { 'content-type': CONTENT_TYPE }, body, region: instance.region, service: 'monitoring', ...keys });
+  const res = await deps.fetch(url, { method: 'POST', headers: signed.headers, body, signal: AbortSignal.timeout(SEND_TIMEOUT_MS) });
+  if (res.ok) return;
+  const text = await res.text();
+  const code = /<Code>([^<]+)<\/Code>/.exec(text)?.[1] ?? `HTTP ${String(res.status)}`;
+  const message = /<Message>([^<]+)<\/Message>/.exec(text)?.[1];
+  throw new Error(`CloudWatch refused the readings: ${code}${message === undefined ? '' : ` (${message})`}`);
+}
+
+export async function publishOnce(deps: PublisherDeps = LIVE, started: Started | null = null): Promise<string> {
+  const instance = await thisInstance(deps);
+  if (instance === null) return 'off: this server is not an EC2 instance';
+  if (instance.keys === null) return `waiting: instance ${instance.instanceId} has no IAM role, so memory and disk are not sent`;
+  const readings = await deps.readings();
+  if (readings === null) return 'skipped: could not read memory or disk';
+  await send(deps, instance, instance.keys, readings, started);
+  return SENT;
+}
+
+export function startCloudWatchPublisher(): void {
+  if (process.platform !== 'linux') return;
+  let started: Started | null = startedOf(Date.now(), process.uptime(), uptime());
+  let last = '';
+  const note = (status: string, warn: boolean): void => {
+    if (status === last) return;
+    last = status;
+    if (warn) log.warn({ status }, 'cloudwatch: could not send memory and disk');
+    else log.info({ status }, 'cloudwatch');
+  };
+  const run = (): void => {
+    publishOnce(LIVE, started)
+      .then((status) => {
+        if (status === SENT) started = null;
+        note(status, false);
+      })
+      .catch((err: unknown) => {
+        note(errMsg(err), true);
+      });
+  };
+  setTimeout(run, FIRST_MS).unref?.();
+  setInterval(run, EVERY_MS).unref?.();
+}

package/runtime/node_modules/@metro-labs/daemon/src/server/control.ts

@@ -0,0 +1,39 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { sessionRoute } from '@metro-labs/http/api-http';
+import { log } from '@metro-labs/core/log';
+
+const STOP = '/api/stop';
+const RESTART = '/api/restart';
+const EXIT_DELAY_MS = 500;
+
+export interface ControlApiDeps {
+  restart: () => void;
+  stop: () => void;
+  served?: () => boolean;
+}
+
+interface Action {
+  run: () => void;
+  body: Record<string, boolean>;
+}
+
+const servedByCli = (): boolean => (process.env.METRO_CLI_BIN?.trim() ?? '') !== '';
+
+function actionFor(path: string, deps: ControlApiDeps): Action {
+  return path === STOP ? { run: deps.stop, body: { stopping: true } } : { run: deps.restart, body: { restarting: true } };
+}
+
+export function handleControlRequest(req: IncomingMessage, res: ServerResponse, deps: ControlApiDeps): boolean {
+  return sessionRoute(req, res, { methods: { [STOP]: ['POST'], [RESTART]: ['POST'] }, admin: true, label: 'control-api' }, async (session, path) => {
+    const action = actionFor(path, deps);
+    if (!(deps.served ?? servedByCli)())
+      throw new ApiError(
+        'this daemon was not started by metro serve, so nothing on the machine would bring it back: use the shell instead',
+        400,
+      );
+    log.info({ path, subject: session.subject }, 'control-api: requested from the page');
+    setTimeout(action.run, EXIT_DELAY_MS).unref();
+    return Promise.resolve(action.body);
+  });
+}

package/runtime/node_modules/@metro-labs/daemon/src/server/machine.ts

@@ -0,0 +1,58 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { hostname, homedir } from 'node:os';
+import { statfs } from 'node:fs/promises';
+import { errMsg, log } from '@metro-labs/core/log';
+import { sessionRoute } from '@metro-labs/http/api-http';
+import { publicBaseUrl, webhookPort } from '../files/attach-serve.js';
+import { claudeDir } from '../claude/files.js';
+import { METRO_VERSION } from '@metro-labs/core/version';
+import { agentsDir } from '../agents/files.js';
+import { localOwner } from '../agents/file-admin.js';
+
+const PATH = '/api/server';
+
+export interface MachineApiDeps {
+  startedAt?: string;
+}
+
+const bootedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
+
+interface Disk {
+  path: string;
+  totalBytes: number;
+  freeBytes: number;
+}
+
+async function diskInfo(path = homedir()): Promise<Disk | null> {
+  try {
+    const s = await statfs(path);
+    return { path, totalBytes: s.bsize * s.blocks, freeBytes: s.bsize * s.bavail };
+  } catch (err) {
+    log.warn({ err: errMsg(err), path }, 'machine: could not read the disk');
+    return null;
+  }
+}
+
+export async function machineInfo(startedAt = bootedAt): Promise<Record<string, unknown>> {
+  const store = process.env.METRO_RUNTIME_STORE?.trim() ?? '';
+  return {
+    disk: await diskInfo(),
+    version: METRO_VERSION,
+    owner: localOwner(),
+    hostname: hostname(),
+    platform: process.platform,
+    arch: process.arch,
+    port: webhookPort(),
+    publicUrl: publicBaseUrl(),
+    uptimeSeconds: Math.round(process.uptime()),
+    startedAt,
+    bun: process.versions.bun ?? null,
+    agentsDir: agentsDir(),
+    claudeDir: claudeDir(),
+    runtimeStore: store === '' ? null : store,
+  };
+}
+
+export function handleMachineRequest(req: IncomingMessage, res: ServerResponse, deps: MachineApiDeps): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET'] }, admin: false, label: 'machine-api' }, () => machineInfo(deps.startedAt));
+}

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

@@ -0,0 +1,26 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { readJsonBody, sessionRoute, type ApiSession } from '@metro-labs/http/api-http';
+import { isOrganizationId } from '@metro-labs/http/workos-token';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+
+const PATH = '/api/owner';
+
+export interface OwnerApiDeps {
+  setOwner: (owner: string) => string;
+}
+
+async function move(req: IncomingMessage, session: ApiSession, deps: OwnerApiDeps): Promise<{ owner: string }> {
+  const body = await readJsonBody(req);
+  const owner = isRecord(body) && typeof body.owner === 'string' ? body.owner.trim() : '';
+  if (!isOrganizationId(owner)) throw new ApiError('owner must be an organization id', 400);
+  if (owner === session.subject) throw new ApiError('this machine already belongs to that organization', 409);
+  const saved = deps.setOwner(owner);
+  log.info({ from: session.subject, to: saved }, 'owner: this machine moved to another organization');
+  return { owner: saved };
+}
+
+export function handleOwnerRequest(req: IncomingMessage, res: ServerResponse, deps: OwnerApiDeps): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['POST'] }, admin: true, label: 'owner-api' }, (session) => move(req, session, deps));
+}

package/runtime/node_modules/@metro-labs/daemon/src/server/update.ts

@@ -0,0 +1,90 @@
+import { execFile } from 'node:child_process';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { log } from '@metro-labs/core/log';
+import { ApiError } from '@metro-labs/http/api-error';
+import { sessionRoute } from '@metro-labs/http/api-http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { METRO_VERSION } from '@metro-labs/core/version';
+
+const PATH = '/api/update';
+const CHECK_TTL_MS = 10 * 60_000;
+const CHECK_TIMEOUT_MS = 30_000;
+const UPDATE_TIMEOUT_MS = 5 * 60_000;
+const RESTART_DELAY_MS = 500;
+const OUTPUT_TAIL = 800;
+
+interface UpdateCheck {
+  current: string;
+  latest: string;
+  newer: boolean;
+}
+
+interface UpdateResult {
+  updated: boolean;
+  version: string;
+  restarting: boolean;
+}
+
+export interface UpdateApiDeps {
+  restart: () => void;
+  cliBin?: () => string;
+}
+
+const cliBinFromEnv = (): string => process.env.METRO_CLI_BIN?.trim() ?? '';
+
+function runCli(bin: string, args: string[], timeout: number): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    execFile(process.execPath, [bin, ...args], { timeout, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err === null) resolve({ stdout, stderr });
+      else reject(new ApiError(`metro update failed: ${(stderr || err.message).trim().slice(-OUTPUT_TAIL)}`, 502));
+    });
+  });
+}
+
+let cached: { at: number; check: UpdateCheck } | null = null;
+
+function parseCheck(raw: string): UpdateCheck {
+  let body: unknown;
+  try {
+    body = JSON.parse(raw.trim().split('\n').at(-1) ?? '');
+  } catch {
+    throw new ApiError('metro update --check returned no report', 502);
+  }
+  if (!isRecord(body) || typeof body.current !== 'string' || typeof body.latest !== 'string')
+    throw new ApiError('metro update --check returned an unexpected report', 502);
+  return { current: body.current, latest: body.latest, newer: body.newer === true };
+}
+
+async function check(bin: string, now = Date.now()): Promise<UpdateCheck> {
+  if (cached !== null && now - cached.at < CHECK_TTL_MS) return cached.check;
+  const out = await runCli(bin, ['update', '--check'], CHECK_TIMEOUT_MS);
+  cached = { at: now, check: parseCheck(out.stdout) };
+  return cached.check;
+}
+
+async function apply(bin: string, deps: UpdateApiDeps): Promise<UpdateResult> {
+  const before = await check(bin);
+  if (!before.newer) return { updated: false, version: before.current, restarting: false };
+  const out = await runCli(bin, ['update'], UPDATE_TIMEOUT_MS);
+  cached = null;
+  log.info({ from: before.current, to: before.latest, output: out.stderr.trim().slice(-OUTPUT_TAIL) }, 'update-api: metro updated, restarting');
+  setTimeout(() => {
+    deps.restart();
+  }, RESTART_DELAY_MS).unref();
+  return { updated: true, version: before.latest, restarting: true };
+}
+
+function binOrThrow(deps: UpdateApiDeps): string {
+  const bin = (deps.cliBin ?? cliBinFromEnv)();
+  if (bin === '')
+    throw new ApiError('this daemon was not started by metro serve, so it cannot update itself: run metro update on the machine', 400);
+  return bin;
+}
+
+export function handleUpdateRequest(req: IncomingMessage, res: ServerResponse, deps: UpdateApiDeps): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET', 'POST'] }, admin: ['POST'], label: 'update-api' }, async () => {
+    const bin = binOrThrow(deps);
+    if (req.method === 'GET') return { ...(await check(bin)), running: METRO_VERSION };
+    return apply(bin, deps);
+  });
+}

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import './boot/boot.js';

package/runtime/node_modules/@metro-labs/daemon/src/stations/attach-browser.ts

@@ -0,0 +1,102 @@
+import { SignInError, parseMailbox } from '@metro-labs/core/stations/oauth';
+import { StationAttachError } from './attach.js';
+import type { AttachOutcome, DriverHooks, StartedAttach, StepInput } from './attach-driver.js';
+
+const OUTLOOK_PROMPT =
+  'Sign in with Microsoft in a new tab, with the mailbox this agent should read. This page updates on its own once you are done.';
+const GMAIL_PROMPT =
+  'Sign in with Google in a new tab, with the mailbox this agent should read. This page updates on its own once you are done.';
+const DEVICE_PROMPT =
+  'Open the Microsoft sign-in page, type this code, and sign in with the mailbox this agent should read.';
+const OTHER_ATTEMPT = 'This sign-in link belongs to another attempt. Start again from the Channels page.';
+const BROWSER_TTL_MS = 15 * 60_000;
+
+interface BrowserLogin {
+  state: string;
+  authorizeUrl: string;
+  finish: (code: string, state: string) => Promise<AttachOutcome>;
+}
+
+interface BrowserAttach {
+  provider: string;
+  prompt: string;
+  failure: (body: Record<string, unknown>) => string;
+  device?: () => Promise<void>;
+  cancel?: () => Promise<void>;
+}
+
+const text = (v: unknown): string => (typeof v === 'string' ? v.trim() : '');
+
+const said = (err: unknown, fallback: string): string => (err instanceof SignInError && err.message !== '' ? err.message : fallback);
+
+function refused(err: unknown, provider: string): StationAttachError {
+  return new StationAttachError(said(err, `${provider} refused to start the sign-in`), 400);
+}
+
+function browserAttach(login: BrowserLogin, hooks: DriverHooks, how: BrowserAttach): StartedAttach {
+  const finish = async (input: StepInput): Promise<void> => {
+    const state = text(input.state);
+    if (state !== login.state) throw new StationAttachError(OTHER_ATTEMPT, 400);
+    const error = text(input.error);
+    if (error !== '') {
+      hooks.fail(how.failure({ error, error_description: text(input.errorDescription) }));
+      return;
+    }
+    const code = text(input.code);
+    if (code === '') throw new StationAttachError(`${how.provider} did not send a sign-in code back`, 400);
+    try {
+      hooks.done(await login.finish(code, state));
+    } catch (err) {
+      hooks.fail(said(err, `Metro could not finish the ${how.provider} sign-in.`));
+    }
+  };
+  const device = how.device;
+  return {
+    prompt: { step: 'browser', prompt: how.prompt, authorizeUrl: login.authorizeUrl },
+    expiresAt: Date.now() + BROWSER_TTL_MS,
+    driver: {
+      cancel: () => how.cancel?.() ?? Promise.resolve(),
+      submit: (input) => (input.mode === 'device' && device !== undefined ? device() : finish(input)),
+    },
+  };
+}
+
+export async function startOutlook(input: Record<string, unknown>, hooks: DriverHooks): Promise<StartedAttach> {
+  const { OutlookBrowserLogin, OutlookLogin: DeviceLogin, failureOf } = await import('@metro-labs/outlook/login');
+  const { browser, mailbox } = (() => {
+    try {
+      const wanted = parseMailbox(input.mailbox);
+      return { browser: new OutlookBrowserLogin({ mailbox: wanted }), mailbox: wanted };
+    } catch (err) {
+      throw refused(err, 'Microsoft');
+    }
+  })();
+  let device: InstanceType<typeof DeviceLogin> | null = null;
+  const toDevice = async (): Promise<void> => {
+    if (device !== null) return;
+    const login = new DeviceLogin({ onDone: hooks.done, onFailed: hooks.fail }, { mailbox });
+    const code = await login.start().catch((err: unknown) => {
+      throw refused(err, 'Microsoft');
+    });
+    device = login;
+    hooks.prompt({ step: 'device', prompt: DEVICE_PROMPT, userCode: code.userCode, verificationUri: code.verificationUri });
+  };
+  return browserAttach(browser, hooks, {
+    provider: 'Microsoft',
+    prompt: OUTLOOK_PROMPT,
+    failure: (body) => failureOf(body),
+    device: toDevice,
+    cancel: () => device?.cancel() ?? Promise.resolve(),
+  });
+}
+
+export async function startGmail(input: Record<string, unknown>, hooks: DriverHooks): Promise<StartedAttach> {
+  const { GmailBrowserLogin, failureOf } = await import('@metro-labs/gmail/login');
+  let login;
+  try {
+    login = new GmailBrowserLogin({ clientId: input.clientId, clientSecret: input.clientSecret, mailbox: input.mailbox });
+  } catch (err) {
+    throw refused(err, 'Google');
+  }
+  return browserAttach(login, hooks, { provider: 'Google', prompt: GMAIL_PROMPT, failure: failureOf });
+}

package/runtime/node_modules/@metro-labs/daemon/src/stations/attach-driver.ts

@@ -0,0 +1,42 @@
+export type AttachStep = 'code' | 'password' | 'scan' | 'pair' | 'device' | 'browser';
+
+export interface AttachPrompt {
+  step: AttachStep;
+  prompt: string;
+  qr?: string;
+  pairingCode?: string;
+  userCode?: string;
+  verificationUri?: string;
+  authorizeUrl?: string;
+}
+
+export interface AttachOutcome {
+  config: Record<string, unknown>;
+  identity: Record<string, string>;
+}
+
+export interface DriverHooks {
+  prompt: (p: AttachPrompt) => void;
+  done: (o: AttachOutcome) => void;
+  fail: (message: string) => void;
+}
+
+export interface StepInput {
+  code?: unknown;
+  password?: unknown;
+  state?: unknown;
+  mode?: unknown;
+  error?: unknown;
+  errorDescription?: unknown;
+}
+
+export interface AttachDriver {
+  submit: (input: StepInput) => Promise<void>;
+  cancel: () => Promise<void>;
+}
+
+export interface StartedAttach {
+  driver: AttachDriver;
+  prompt: AttachPrompt;
+  expiresAt?: number;
+}

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

@@ -1,4 +1,5 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, open, rm, writeFile } from 'node:fs/promises';
+import { assertAttachmentSize } from '@metro-labs/core/stations/attachments';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -98,3 +99,30 @@ export async function writeInlineTemp(
 
 export const removeInlineTemp = (dir: string): Promise<void> =>
   rm(dir, { recursive: true, force: true });
+
+export async function streamToTemp(
+  body: ReadableStream<Uint8Array>,
+  name: string | undefined,
+): Promise<InlineTemp & { bytes: number }> {
+  const dir = await mkdtemp(join(tmpdir(), INLINE_TEMP_PREFIX));
+  const path = join(dir, safeFileName(name));
+  const handle = await open(path, 'wx', 0o600);
+  const reader = body.getReader();
+  let bytes = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytes += value.length;
+      assertAttachmentSize(bytes);
+      await handle.write(value);
+    }
+  } catch (err) {
+    await reader.cancel().catch(() => undefined);
+    await handle.close();
+    await removeInlineTemp(dir);
+    throw err;
+  }
+  await handle.close();
+  return { dir, path, bytes };
+}

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

@@ -1,39 +1,11 @@
 import { StationAttachError } from './attach.js';
+import type { DriverHooks, StartedAttach } from './attach-driver.js';
+import { startGmail, startOutlook } from './attach-browser.js';
 
-export const INTERACTIVE_STATIONS = ['telegram', 'whatsapp'] as const;
+export const INTERACTIVE_STATIONS = ['telegram', 'whatsapp', 'outlook', 'gmail'] as const;
 
 export type InteractiveStation = (typeof INTERACTIVE_STATIONS)[number];
 
-export type AttachStep = 'code' | 'password' | 'scan' | 'pair';
-
-export interface AttachPrompt {
-  step: AttachStep;
-  prompt: string;
-  qr?: string;
-  pairingCode?: string;
-}
-
-export interface AttachOutcome {
-  config: Record<string, unknown>;
-  identity: Record<string, string>;
-}
-
-export interface DriverHooks {
-  prompt: (p: AttachPrompt) => void;
-  done: (o: AttachOutcome) => void;
-  fail: (message: string) => void;
-}
-
-export interface AttachDriver {
-  submit: (input: { code?: unknown; password?: unknown }) => Promise<void>;
-  cancel: () => Promise<void>;
-}
-
-export interface StartedAttach {
-  driver: AttachDriver;
-  prompt: AttachPrompt;
-}
-
 const CODE_PROMPT =
   'Telegram sent a login code to that number. Enter it here.';
 const PASSWORD_PROMPT =
@@ -155,6 +127,8 @@ export async function startInteractiveAttach(
   input: Record<string, unknown>,
   hooks: DriverHooks,
 ): Promise<StartedAttach> {
+  if (station === 'outlook') return startOutlook(input, hooks);
+  if (station === 'gmail') return startGmail(input, hooks);
   return station === 'telegram'
     ? startTelegramUser(input, hooks)
     : startWhatsapp(input, hooks);