@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.210

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/send-files.ts

@@ -1,4 +1,5 @@
-import { appendFile } from '@metro-labs/mcp/stations/attachments';
+import { appendFile } from '@metro-labs/core/stations/attachments';
+import type { CanonicalAttachment } from '@metro-labs/core/stations/types';
 
 export interface OutgoingFile {
   path: string;
@@ -6,25 +7,23 @@ export interface OutgoingFile {
   kind: string;
 }
 
+type WireAttachment = CanonicalAttachment & { kind?: string };
+
 const basenameOf = (path: string, index: number): string =>
   path.split('/').pop() ?? `file-${index}`;
 
-export function outgoingFiles(
-  paths: string[],
-  names: string[] | undefined,
-  kinds: string[] | undefined,
-): OutgoingFile[] {
+export function outgoingFiles(attachments: unknown): OutgoingFile[] {
+  if (!Array.isArray(attachments)) return [];
   const out: OutgoingFile[] = [];
-  for (let i = 0; i < paths.length; i++) {
-    const path = paths[i];
-    if (path === undefined || path === '') continue;
-    const given = names?.[i];
+  (attachments as WireAttachment[]).forEach((a, i) => {
+    const path = a.path;
+    if (path === undefined || path === '') return;
     out.push({
       path,
-      name: given !== undefined && given !== '' ? given : basenameOf(path, i),
-      kind: kinds?.[i] ?? 'file',
+      name: a.name !== undefined && a.name !== '' ? a.name : basenameOf(path, i),
+      kind: a.kind ?? 'file',
     });
-  }
+  });
   return out;
 }
 

package/runtime/node_modules/@metro-labs/discord-bot/src/station.ts

@@ -0,0 +1,23 @@
+import type { GroupOp, Station, Verb } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
+
+export const discordBotStation: Station = {
+  name: 'discord-bot',
+  hasAccounts: true,
+  hasTrain: true,
+  messageVerbs: new Set<Verb>([
+    'send',
+    'reply',
+    'react',
+    'unreact',
+    'edit',
+    'delete',
+    'read',
+    'typing',
+  ]),
+  groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
+  attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  tools: [],
+};

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

@@ -0,0 +1,29 @@
+{
+  "name": "@metro-labs/http",
+  "version": "0.1.0",
+  "private": true,
+  "description": "How a metro server authenticates and answers a request: CORS, the JSON helpers, ApiError, the signed-identity header and the identity registry. Shared by the daemon and api.metro.box, never by a station.",
+  "type": "module",
+  "exports": {
+    "./cors": "./src/cors.ts",
+    "./api-http": "./src/api-http.ts",
+    "./api-error": "./src/api-error.ts",
+    "./return-to": "./src/return-to.ts",
+    "./mode-api": "./src/mode-api.ts",
+    "./workos-token": "./src/workos-token.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.2",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}

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

@@ -0,0 +1,135 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from './api-error.js';
+import { errMsg, log } from '@metro-labs/core/log';
+
+const BODY_MAX = 4 * 1024;
+
+export type Role = 'admin' | 'member';
+
+export interface ApiSession {
+  subject: string;
+  role: Role;
+}
+
+export type BearerSessions = (req: IncomingMessage) => Promise<ApiSession | null>;
+
+let bearerSessions: BearerSessions | null = null;
+
+export function setBearerSessions(fn: BearerSessions | null): void {
+  bearerSessions = fn;
+}
+
+export function requireAdmin(session: ApiSession): void {
+  if (session.role !== 'admin') throw new ApiError('this needs the admin role in your organization', 403);
+}
+
+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 function apiSession(req: IncomingMessage): Promise<ApiSession | null> {
+  return bearerSessions === null ? Promise.resolve(null) : bearerSessions(req);
+}
+
+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 interface SessionRoute {
+  methods: Readonly<Record<string, readonly string[]>>;
+  admin: boolean | readonly string[];
+  label: string;
+}
+
+const needsAdmin = (route: SessionRoute, method: string): boolean =>
+  route.admin === true || (Array.isArray(route.admin) && route.admin.includes(method));
+
+export function sessionRoute(
+  req: IncomingMessage,
+  res: ServerResponse,
+  route: SessionRoute,
+  handler: (session: ApiSession, path: string) => Promise<unknown>,
+): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const methods = Object.hasOwn(route.methods, path) ? route.methods[path] : undefined;
+  if (methods === undefined) return false;
+  const method = req.method ?? '';
+  if (method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (!methods.includes(method)) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  apiSession(req)
+    .then(async (session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      if (needsAdmin(route, method)) requireAdmin(session);
+      sendJson(req, res, 200, await handler(session, path));
+    })
+    .catch((err: unknown) => {
+      apiFailure(req, res, err, route.label);
+    });
+  return true;
+}
+
+export function bodyField(body: unknown, key: string): unknown {
+  return typeof body === 'object' && body !== null && !Array.isArray(body)
+    ? (body as Record<string, unknown>)[key]
+    : undefined;
+}
+
+export const stringOf = (value: unknown): string => (typeof value === 'string' ? value : '');

package/runtime/node_modules/@metro-labs/{mcp/src/daemon/session-api.ts → http/src/mode-api.ts}

@@ -1,11 +1,20 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { apiSession, cors, sendJson } from './api-http.js';
+import { cors, sendJson } from './api-http.js';
 
-const PATH = '/api/session';
+const PATH = '/api/mode';
 
-export function handleSessionApiRequest(
+export type DaemonMode = 'hosted' | 'local';
+
+export interface ModeInfo {
+  mode: DaemonMode;
+  owner: string | null;
+  version: string;
+}
+
+export function handleModeRequest(
   req: IncomingMessage,
   res: ServerResponse,
+  info: () => ModeInfo,
 ): boolean {
   const path = (req.url ?? '').split('?')[0] ?? '';
   if (path !== PATH) return false;
@@ -17,11 +26,6 @@ export function handleSessionApiRequest(
     sendJson(req, res, 405, { error: 'method not allowed' });
     return true;
   }
-  const session = apiSession(req);
-  if (!session) {
-    sendJson(req, res, 401, { error: 'unauthorized' });
-    return true;
-  }
-  sendJson(req, res, 200, { email: session.email });
+  sendJson(req, res, 200, info());
   return true;
 }

package/runtime/node_modules/@metro-labs/http/src/return-to.ts

@@ -0,0 +1,21 @@
+const PREVIEW = /^([a-z0-9-]+--)?metro-ui\.netlify\.app$/;
+
+export function allowedWebHost(host: string): boolean {
+  if (host === 'metro.box' || host === 'localhost' || host === '127.0.0.1')
+    return true;
+  return PREVIEW.test(host);
+}
+
+export function validateReturnTo(returnTo: string): boolean {
+  let url: URL;
+  try {
+    url = new URL(returnTo);
+  } catch {
+    return false;
+  }
+  const host = url.hostname;
+  if (url.protocol === 'http:' && (host === 'localhost' || host === '127.0.0.1'))
+    return true;
+  if (url.protocol !== 'https:') return false;
+  return allowedWebHost(host);
+}

package/runtime/node_modules/@metro-labs/http/src/workos-token.ts

@@ -0,0 +1,149 @@
+import type { IncomingMessage } from 'node:http';
+import { createPublicKey, verify, type JsonWebKey, type KeyObject } from 'node:crypto';
+
+const WORKOS_API = 'https://api.workos.com';
+const ORG_RE = /^org_[A-Za-z0-9]{10,64}$/;
+export const isOrganizationId = (value: string): boolean => ORG_RE.test(value);
+export const DEFAULT_CLIENT_ID = 'client_01M2TJJJ6RM9CT081QB4XZK3G2';
+const SKEW_S = 60;
+const REFETCH_COOLDOWN_MS = 60_000;
+const FETCH_MS = 10_000;
+
+export interface Session {
+  userId: string;
+  sessionId: string;
+  organization: string | null;
+  role: string | null;
+  expiresAt: number;
+}
+
+export interface KeyStore {
+  read: () => string | null;
+  write: (text: string) => void;
+}
+
+export const filled = (value: string | undefined): string | null => {
+  const text = value?.trim() ?? '';
+  return text === '' ? null : text;
+};
+
+export const clientId = (env: NodeJS.ProcessEnv = process.env): string => filled(env.WORKOS_CLIENT_ID) ?? DEFAULT_CLIENT_ID;
+export const workosBase = (env: NodeJS.ProcessEnv = process.env): string => filled(env.WORKOS_API_BASE) ?? WORKOS_API;
+export const jwksUrl = (id: string, base = WORKOS_API): string => `${base}/sso/jwks/${id}`;
+
+function jwksKeys(text: string): Map<string, KeyObject> {
+  const keys = new Map<string, KeyObject>();
+  const parsed: unknown = JSON.parse(text);
+  const list = typeof parsed === 'object' && parsed !== null ? (parsed as { keys?: unknown }).keys : undefined;
+  if (!Array.isArray(list)) return keys;
+  for (const jwk of list) {
+    if (typeof jwk !== 'object' || jwk === null) continue;
+    const { kid, kty } = jwk as { kid?: unknown; kty?: unknown };
+    if (typeof kid !== 'string' || kty !== 'RSA') continue;
+    try {
+      keys.set(kid, createPublicKey({ key: jwk as JsonWebKey, format: 'jwk' }));
+    } catch {
+      continue;
+    }
+  }
+  return keys;
+}
+
+export class SigningKeys {
+  private keys = new Map<string, KeyObject>();
+  private lastMiss = 0;
+  private loaded = false;
+
+  constructor(
+    private readonly url: string,
+    private readonly store?: KeyStore,
+  ) {}
+
+  private load(): void {
+    if (this.loaded) return;
+    this.loaded = true;
+    const cached = this.store?.read() ?? null;
+    if (cached !== null) this.keys = jwksKeys(cached);
+  }
+
+  private async refresh(now: number): Promise<void> {
+    if (now - this.lastMiss < REFETCH_COOLDOWN_MS) return;
+    const res = await fetch(this.url, { signal: AbortSignal.timeout(FETCH_MS) });
+    if (!res.ok) throw new Error(`the signing keys answered ${String(res.status)}`);
+    const text = await res.text();
+    const keys = jwksKeys(text);
+    if (keys.size === 0) throw new Error('the signing keys answered no RSA key');
+    this.keys = keys;
+    this.store?.write(text);
+  }
+
+  async keyFor(kid: string, now = Date.now()): Promise<KeyObject | null> {
+    this.load();
+    const held = this.keys.get(kid);
+    if (held !== undefined) return held;
+    await this.refresh(now);
+    const fetched = this.keys.get(kid);
+    if (fetched === undefined) this.lastMiss = now;
+    return fetched ?? null;
+  }
+}
+
+const b64url = (text: string): Buffer => Buffer.from(text.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+
+function jsonPart(text: string): Record<string, unknown> | null {
+  try {
+    const parsed: unknown = JSON.parse(b64url(text).toString('utf8'));
+    return typeof parsed === 'object' && parsed !== null ? (parsed as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+const str = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
+
+const issuedBy = (iss: unknown, issuer: string): boolean => typeof iss === 'string' && (iss === issuer || iss.startsWith(`${issuer}/`));
+
+function sessionOf(claims: Record<string, unknown>, issuer: string, now: number): Session | null {
+  const exp = typeof claims.exp === 'number' ? claims.exp : null;
+  const userId = str(claims.sub);
+  const sessionId = str(claims.sid);
+  if (!issuedBy(claims.iss, issuer) || exp === null || userId === null || sessionId === null) return null;
+  if (exp * 1000 < now - SKEW_S * 1000) return null;
+  return { userId, sessionId, organization: str(claims.org_id), role: str(claims.role), expiresAt: exp * 1000 };
+}
+
+interface Parts {
+  signed: string;
+  body: string;
+  signature: Buffer;
+  kid: string;
+}
+
+function parseToken(token: string): Parts | null {
+  const [head, body, sig] = token.split('.');
+  if (head === undefined || body === undefined || sig === undefined) return null;
+  const header = jsonPart(head);
+  const kid = str(header?.kid);
+  if (header?.alg !== 'RS256' || kid === null) return null;
+  return { signed: `${head}.${body}`, body, signature: b64url(sig), kid };
+}
+
+export async function verifyToken(token: string, keys: SigningKeys, issuer = WORKOS_API, now = Date.now()): Promise<Session | null> {
+  const parts = parseToken(token);
+  if (parts === null) return null;
+  const key = await keys.keyFor(parts.kid, now).catch(() => null);
+  if (key === null || !verify('sha256', Buffer.from(parts.signed), key, parts.signature)) return null;
+  const claims = jsonPart(parts.body);
+  return claims === null ? null : sessionOf(claims, issuer, now);
+}
+
+export function bearerToken(req: IncomingMessage): string | null {
+  const header = req.headers.authorization ?? '';
+  const [scheme, token] = header.trim().split(/\s+/);
+  return scheme?.toLowerCase() === 'bearer' && token?.includes('.') === true ? token : null;
+}
+
+export async function bearerSession(req: IncomingMessage, keys: SigningKeys, issuer = WORKOS_API): Promise<Session | null> {
+  const token = bearerToken(req);
+  return token === null ? null : verifyToken(token, keys, issuer);
+}

package/runtime/node_modules/@metro-labs/{telegram-user → outlook}/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@metro-labs/telegram-user",
+  "name": "@metro-labs/outlook",
   "version": "0.1.0",
   "private": true,
   "type": "module",
@@ -13,16 +13,13 @@
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*",
-    "@mtcute/bun": "0.30.1"
+    "@metro-labs/core": "workspace:*"
   },
   "devDependencies": {
     "@stage-labs/config": "0.1.0-beta.2",
-    "@types/qrcode-terminal": "^0.12.2",
     "eslint": "^10.3.0",
     "knip": "^6.15.0",
     "madge": "^8.0.0",
-    "qrcode-terminal": "^0.12.0",
     "typescript": "^5"
   }
 }

package/runtime/node_modules/@metro-labs/outlook/src/accounts.ts

@@ -0,0 +1,93 @@
+import { makeAccountStore, resolveAccountId, type Die } from '@metro-labs/core/stations/account-store';
+import { TrainError } from '@metro-labs/core/train-error';
+import { refreshTokens, type FetchLike } from './auth.js';
+import { conversationOfLine } from './format.js';
+import { loadState, saveState, type AccountState } from './state.js';
+
+const RENEW_BEFORE_MS = 5 * 60_000;
+
+export interface AccountConfig {
+  id: string;
+  accountEmail: string;
+  refreshToken: string;
+  accessToken?: string;
+  expiresAt?: number;
+  includeAutomated?: boolean;
+}
+
+function checkAccount(a: AccountConfig, die: Die): void {
+  if (typeof a.accountEmail !== 'string' || !a.accountEmail.includes('@')) die(`account '${a.id}' has no mailbox address`);
+  if (typeof a.refreshToken !== 'string' || a.refreshToken === '') die(`account '${a.id}' has no refresh token`);
+}
+
+export const { loadAccounts } = makeAccountStore<AccountConfig>({
+  prefix: 'outlook',
+  validate(raw, die) {
+    for (const a of raw) checkAccount(a, die);
+  },
+});
+
+export class Account {
+  readonly email: string;
+  readonly state: AccountState;
+  private refreshing: Promise<string> | null = null;
+
+  constructor(
+    readonly cfg: AccountConfig,
+    private readonly fetchImpl: FetchLike = (input, init) => fetch(input, init),
+  ) {
+    this.email = cfg.accountEmail.toLowerCase();
+    this.state = loadState(cfg.id, {
+      refreshToken: cfg.refreshToken,
+      accessToken: cfg.accessToken ?? '',
+      expiresAt: cfg.expiresAt ?? 0,
+    });
+  }
+
+  get id(): string {
+    return this.cfg.id;
+  }
+
+  save(): void {
+    saveState(this.cfg.id, this.state);
+  }
+
+  token(force = false): Promise<string> {
+    const fresh = this.state.accessToken !== '' && this.state.expiresAt - RENEW_BEFORE_MS > Date.now();
+    if (fresh && !force) return Promise.resolve(this.state.accessToken);
+    this.refreshing ??= this.renew().finally(() => {
+      this.refreshing = null;
+    });
+    return this.refreshing;
+  }
+
+  private async renew(): Promise<string> {
+    let tokens;
+    try {
+      tokens = await refreshTokens(this.state.refreshToken, this.fetchImpl);
+    } catch (err) {
+      throw new TrainError('outlook_signed_out', err instanceof Error ? err.message : String(err), { retryable: false });
+    }
+    Object.assign(this.state, tokens);
+    this.save();
+    return tokens.accessToken;
+  }
+
+  fetch(input: string, init?: RequestInit): Promise<Response> {
+    return this.fetchImpl(input, init);
+  }
+}
+
+export const accounts = new Map<string, Account>();
+
+export function accountFor(id: string): Account {
+  const acct = accounts.get(id);
+  if (!acct) throw new Error(`unknown account '${id}' (have: ${[...accounts.keys()].join(', ')})`);
+  return acct;
+}
+
+export function accountOf(args: { account?: unknown; line?: unknown }): Account {
+  const line = typeof args.line === 'string' && args.line !== '' ? args.line : undefined;
+  const account = typeof args.account === 'string' && args.account !== '' ? args.account : undefined;
+  return accountFor(resolveAccountId(accounts, { account, line }, (l) => conversationOfLine(l)?.accountId));
+}

package/runtime/node_modules/@metro-labs/outlook/src/actions.ts

@@ -0,0 +1,14 @@
+import { makeStation, respond } from '@metro-labs/core/stations/station-runtime';
+import { accounts } from './accounts.js';
+import { MAILBOX_URL } from './config.js';
+import { reply, send } from './outbound.js';
+import { read } from './query.js';
+
+function listAccounts(id: string): void {
+  const list = [...accounts.values()].map((a) => ({ id: a.id, handle: a.email, url: MAILBOX_URL, email: a.email }));
+  respond(id, { result: { accounts: list } });
+}
+
+export const handleCall = makeStation({
+  handlers: { accounts: listAccounts, send, reply, read },
+});

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

@@ -0,0 +1,97 @@
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import { assertAttachmentSize, kindOf, saveBufferToCache, type SavedAttachment } from '@metro-labs/core/stations/attachments';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { Account } from './accounts.js';
+import type { AttachmentMeta } from './format.js';
+import { graph, graphJson, messagePath } from './graph.js';
+
+export const MAX_FILE_BYTES = 3 * 1024 * 1024;
+
+const FILE_TYPE = '#microsoft.graph.fileAttachment';
+
+export interface GraphAttachment {
+  id: string;
+  name?: string;
+  contentType?: string;
+  size?: number;
+  isInline?: boolean;
+  '@odata.type'?: string;
+}
+
+export interface MailFile extends AttachmentMeta {
+  id: string;
+}
+
+export const metaOf = (f: MailFile): AttachmentMeta => ({
+  kind: f.kind,
+  name: f.name,
+  mime: f.mime,
+  ...(f.size === undefined ? {} : { size: f.size }),
+});
+
+export async function listFiles(acct: Account, messageId: string): Promise<MailFile[]> {
+  const body = await graphJson<{ value?: GraphAttachment[] }>(
+    acct,
+    `${messagePath(messageId)}/attachments?$select=id,name,contentType,size,isInline`,
+  );
+  return (body.value ?? [])
+    .filter((a) => a['@odata.type'] === undefined || a['@odata.type'] === FILE_TYPE)
+    .map((a) => {
+      const name = a.name ?? 'attachment';
+      const mime = a.contentType ?? 'application/octet-stream';
+      return { id: a.id, name, mime, kind: kindOf(mime, name), ...(typeof a.size === 'number' ? { size: a.size } : {}) };
+    });
+}
+
+const cacheKey = (messageId: string): string => createHash('sha256').update(messageId).digest('hex').slice(0, 16);
+
+export async function saveFile(acct: Account, messageId: string, file: MailFile, index: number): Promise<SavedAttachment> {
+  if (file.size !== undefined) assertAttachmentSize(file.size);
+  const res = await graph(acct, `${messagePath(messageId)}/attachments/${encodeURIComponent(file.id)}/$value`);
+  const data = new Uint8Array(await res.arrayBuffer());
+  return saveBufferToCache(data, cacheKey(messageId), index, { mime: file.mime, name: file.name });
+}
+
+export interface OutgoingFile {
+  path: string;
+  mime: string;
+  name: string;
+}
+
+export const filesOf = (raw: unknown): OutgoingFile[] =>
+  (Array.isArray(raw) ? raw : [])
+    .map((a) => (a ?? {}) as Record<string, unknown>)
+    .filter((a) => typeof a.path === 'string' && a.path !== '')
+    .map((a) => ({
+      path: String(a.path),
+      mime: typeof a.mime === 'string' && a.mime !== '' ? a.mime : 'application/octet-stream',
+      name: typeof a.name === 'string' && a.name !== '' ? a.name : 'file',
+    }));
+
+export async function assertSendable(files: OutgoingFile[]): Promise<void> {
+  for (const file of files) {
+    const { size } = await stat(file.path);
+    if (size > MAX_FILE_BYTES)
+      throw new TrainError(
+        'outlook_file_too_big',
+        `Metro sends Outlook files up to 3 MB for now; ${file.name} is ${(size / 1024 / 1024).toFixed(1)} MB, so share a link to it instead`,
+        { retryable: false },
+      );
+  }
+}
+
+export async function attachFile(acct: Account, draftId: string, file: OutgoingFile): Promise<string> {
+  const data = await readFile(file.path);
+  await graph(acct, `${messagePath(draftId)}/attachments`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      '@odata.type': FILE_TYPE,
+      name: file.name,
+      contentType: file.mime,
+      contentBytes: data.toString('base64'),
+    }),
+  });
+  return kindOf(file.mime, file.path);
+}