@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.130

package/dist/monitor.js

@@ -1,194 +0,0 @@
-/** Read-only HTTP monitor endpoints. `/api/state` (snapshot) + `/api/tail` (SSE). */
-/** Mounted on the webhook server. Bearer auth via METRO_MONITOR_TOKEN (503 when unset). */
-import { timingSafeEqual } from 'node:crypto';
-import { watch } from 'node:fs';
-import pkg from '../package.json' with { type: 'json' };
-import { errMsg, log } from './log.js';
-import { HISTORY_FILE, historySize, passesMode, readClaims, readEntriesFrom, } from './broker.js';
-import { readBotIds } from './cache.js';
-import { readHistory } from './history.js';
-import { asLine } from './stations/index.js';
-const HISTORY_LIMIT = 100;
-function authorized(req) {
-    const token = process.env.METRO_MONITOR_TOKEN;
-    if (!token)
-        return { ok: false, status: 503, msg: 'monitor endpoints not configured (METRO_MONITOR_TOKEN unset)' };
-    const header = req.headers['authorization'];
-    const value = Array.isArray(header) ? header[0] : header;
-    if (!value || !value.startsWith('Bearer '))
-        return { ok: false, status: 401, msg: 'unauthorized' };
-    const given = Buffer.from(value.slice('Bearer '.length));
-    const want = Buffer.from(token);
-    if (given.length !== want.length || !timingSafeEqual(given, want)) {
-        return { ok: false, status: 401, msg: 'unauthorized' };
-    }
-    return { ok: true };
-}
-/** Hosts that serve `/api/*`. webhook.metro.box stays scoped to /wh/*. */
-const MONITOR_HOSTS = new Set(['monitor.metro.box', 'localhost', '127.0.0.1']);
-function monitorHostAllowed(req) {
-    const raw = req.headers[':authority'] ?? req.headers.host;
-    if (!raw)
-        return true;
-    return MONITOR_HOSTS.has(raw.split(':')[0].toLowerCase());
-}
-export function handleMonitorRequest(req, res) {
-    const url = req.url ?? '';
-    if (!url.startsWith('/api/'))
-        return false;
-    if (!monitorHostAllowed(req))
-        return false; // let outer router 404 it
-    const [pathOnly, queryString = ''] = url.split('?', 2);
-    if (req.method !== 'GET') {
-        res.writeHead(405, { 'content-type': 'application/json' });
-        res.end(JSON.stringify({ error: 'method not allowed' }));
-        return true;
-    }
-    const auth = authorized(req);
-    if (!auth.ok) {
-        res.writeHead(auth.status, { 'content-type': 'application/json' });
-        res.end(JSON.stringify({ error: auth.msg }));
-        return true;
-    }
-    const query = new URLSearchParams(queryString);
-    if (pathOnly === '/api/state') {
-        handleState(res, query);
-        return true;
-    }
-    if (pathOnly === '/api/tail') {
-        handleTail(req, res, query).catch(err => {
-            log.warn({ err: errMsg(err) }, 'monitor: tail handler error');
-            try {
-                if (!res.headersSent)
-                    res.writeHead(500).end();
-                else
-                    res.end();
-            }
-            catch { /* ignore */ }
-        });
-        return true;
-    }
-    res.writeHead(404, { 'content-type': 'application/json' });
-    res.end(JSON.stringify({ error: 'not found' }));
-    return true;
-}
-function parseNonNegInt(raw) {
-    if (raw === null)
-        return null;
-    const n = Number(raw);
-    if (!Number.isFinite(n) || n < 0 || !Number.isInteger(n))
-        return null;
-    return n;
-}
-function handleState(res, query) {
-    const before = parseNonNegInt(query.get('before'));
-    const limitRaw = parseNonNegInt(query.get('limit'));
-    /** Page mode: skip `before` newest entries, return next `limit` (default HISTORY_LIMIT, capped at 500). */
-    if (before !== null) {
-        const limit = Math.min(limitRaw ?? HISTORY_LIMIT, 500);
-        const page = readHistory({ limit, skip: before });
-        res.writeHead(200, { 'content-type': 'application/json' });
-        res.end(JSON.stringify({ recent_history: page }));
-        return;
-    }
-    /** `readHistory` is newest-first — what the activity feed expects. */
-    const limit = Math.min(limitRaw ?? HISTORY_LIMIT, 500);
-    const recent = readHistory({ limit });
-    const claims = readClaims();
-    const linesSet = new Set();
-    for (const e of recent)
-        linesSet.add(e.line);
-    for (const line of Object.keys(claims))
-        linesSet.add(line);
-    res.writeHead(200, { 'content-type': 'application/json' });
-    res.end(JSON.stringify({
-        claims,
-        lines: [...linesSet],
-        recent_history: recent,
-        bot_ids: readBotIds(),
-        version: pkg.version,
-    }));
-}
-/** Mirrors `cli/tail.ts:resolveMode` but operates on URLSearchParams. */
-function resolveQueryMode(query, self) {
-    const strict = query.get('strict') === 'true' || query.get('mode') === 'strict';
-    const unclaimed = query.get('unclaimed') === 'true' || query.get('mode') === 'unclaimed';
-    const all = query.get('all') === 'true' || query.get('mode') === 'all';
-    if ([strict, unclaimed, all].filter(Boolean).length > 1)
-        return 'all';
-    if (strict && self)
-        return 'mine-only';
-    if (unclaimed)
-        return 'unclaimed';
-    if (all || !self)
-        return 'all';
-    return 'mine-or-unclaimed';
-}
-async function handleTail(req, res, query) {
-    const asParam = query.get('as');
-    const self = asParam ? asLine(asParam) : null;
-    const mode = resolveQueryMode(query, self);
-    const chatFilter = query.get('chat');
-    const stationFilter = query.get('station');
-    const includeWebhooks = query.get('include_webhooks') === 'true';
-    res.writeHead(200, {
-        'content-type': 'text/event-stream',
-        'cache-control': 'no-cache, no-transform',
-        'connection': 'keep-alive',
-        /** Bearer auth already gates us; CORS can be permissive. */
-        'access-control-allow-origin': '*',
-        /** Cloudflare/proxies buffer SSE without this hint. */
-        'x-accel-buffering': 'no',
-    });
-    /** `since=tail` (default) starts at EOF; `since=0` replays the full file. */
-    const since = query.get('since');
-    let offset = since === '0' ? 0 : historySize();
-    if (since && since !== '0' && since !== 'tail') {
-        const n = Number(since);
-        if (Number.isFinite(n) && n >= 0)
-            offset = n;
-    }
-    /** 4 KiB padding so Cloudflare's HTTP/2 buffer flushes (else holds 30+ s on free tier). */
-    res.write(`: metro monitor tail (mode=${mode}${self ? `, as=${self}` : ''})\n`);
-    res.write(`: ${'-'.repeat(4096)}\n\n`);
-    const drain = () => {
-        const claims = readClaims();
-        for (const { entry, offset: next } of readEntriesFrom(offset)) {
-            offset = next;
-            if (chatFilter && entry.line !== chatFilter)
-                continue;
-            if (stationFilter && entry.station !== stationFilter)
-                continue;
-            if (!passesMode(entry, mode, self, claims, { includeWebhooks }))
-                continue;
-            res.write(`id: ${entry.id}\n`);
-            res.write('event: history\n');
-            res.write(`data: ${JSON.stringify(entry)}\n\n`);
-        }
-    };
-    drain();
-    /** fs.watch coalesces on macOS — poll every 1s as a backstop. */
-    let watcher = null;
-    try {
-        watcher = watch(HISTORY_FILE, () => drain());
-    }
-    catch { /* file may not exist yet */ }
-    const poll = setInterval(drain, 1_000);
-    const keepalive = setInterval(() => res.write(': keepalive\n\n'), 25_000);
-    const cleanup = () => {
-        clearInterval(poll);
-        clearInterval(keepalive);
-        if (watcher) {
-            try {
-                watcher.close();
-            }
-            catch { /* ignore */ }
-        }
-        try {
-            res.end();
-        }
-        catch { /* ignore */ }
-    };
-    req.on('close', cleanup);
-    req.on('error', cleanup);
-}

package/dist/paths.js

@@ -1,68 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { log } from './log.js';
-export const STATE_DIR = process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
-mkdirSync(STATE_DIR, { recursive: true });
-const CONFIG_DIR = process.env.METRO_CONFIG_DIR ?? join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'metro');
-export const CONFIG_ENV_FILE = join(CONFIG_DIR, '.env');
-const LINE_RE = /^\s*([A-Za-z_]\w*)\s*=\s*(.*?)\s*$/;
-const QUOTED_RE = /^(['"])(.*)\1$/;
-export function readDotenv(path) {
-    if (!existsSync(path))
-        return {};
-    const out = {};
-    for (const line of readFileSync(path, 'utf8').split('\n')) {
-        const m = line.match(LINE_RE);
-        if (m)
-            out[m[1]] = m[2].replace(QUOTED_RE, '$2');
-    }
-    return out;
-}
-export function writeDotenv(path, env) {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, Object.entries(env).map(([k, v]) => `${k}=${v}`).join('\n') + '\n');
-    chmodSync(path, 0o600);
-}
-/** Precedence: process.env > cwd/.env > $METRO_CONFIG_DIR/.env. First-set wins. */
-export function loadMetroEnv() {
-    for (const path of [join(process.cwd(), '.env'), CONFIG_ENV_FILE]) {
-        for (const [k, v] of Object.entries(readDotenv(path))) {
-            if (process.env[k] === undefined)
-                process.env[k] = v;
-        }
-    }
-}
-export function configuredPlatforms() {
-    return { telegram: !!process.env.TELEGRAM_BOT_TOKEN, discord: !!process.env.DISCORD_BOT_TOKEN };
-}
-export function requireConfiguredPlatform(p, hasWebhooks) {
-    if (p.telegram || p.discord || hasWebhooks)
-        return;
-    log.fatal('no inputs configured — run `metro setup telegram <token>`, `metro setup discord <token>`, or `metro webhook add <label>`');
-    process.exit(2);
-}
-/** Singleton pidfile. Exits if another instance owns it; reclaims stale locks. */
-export function acquireLock(lockFile) {
-    if (existsSync(lockFile)) {
-        const pid = Number(readFileSync(lockFile, 'utf8').trim());
-        try {
-            if (Number.isInteger(pid) && pid > 0) {
-                process.kill(pid, 0);
-                log.info({ pid }, 'another `metro` is running; exiting');
-                process.exit(0);
-            }
-        }
-        catch { /* stale */ }
-        try {
-            unlinkSync(lockFile);
-        }
-        catch { /* ignore */ }
-    }
-    writeFileSync(lockFile, String(process.pid));
-    process.on('exit', () => { try {
-        if (readFileSync(lockFile, 'utf8').trim() === String(process.pid))
-            unlinkSync(lockFile);
-    }
-    catch { /* ignore */ } });
-}

package/dist/registry.js

@@ -1,48 +0,0 @@
-/** Append-only registry of `(station, user-id, sessions[])` tuples metro has seen. */
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { STATE_DIR } from './paths.js';
-import { Line } from './stations/index.js';
-import { errMsg, log } from './log.js';
-const REGISTRY_FILE = join(STATE_DIR, 'user-registry.json');
-function readRegistry() {
-    if (!existsSync(REGISTRY_FILE))
-        return {};
-    try {
-        return JSON.parse(readFileSync(REGISTRY_FILE, 'utf8'));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'user-registry: malformed, resetting');
-        return {};
-    }
-}
-function record(station, userId, sessionId) {
-    const reg = readRegistry();
-    const rows = (reg[station] ??= []);
-    let row = rows.find(r => r.userId === userId);
-    if (!row) {
-        row = { userId, sessions: [], lastSeen: '' };
-        rows.push(row);
-    }
-    if (sessionId && !row.sessions.includes(sessionId))
-        row.sessions.push(sessionId);
-    row.lastSeen = new Date().toISOString();
-    try {
-        writeFileSync(REGISTRY_FILE, JSON.stringify(reg, null, 2));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'user-registry: write failed');
-    }
-}
-/** Scan a line URI for `(station, userId, sessionId)` and record it. No-op on non-user or participant URIs. */
-export function noteUserFromLine(line) {
-    const station = Line.station(line);
-    if (station !== 'claude' && station !== 'codex')
-        return;
-    const p = station === 'claude' ? Line.parseClaude(line) : Line.parseCodex(line);
-    if (p)
-        record(station, p.userId, p.sessionId);
-}
-export function listUsers(station) {
-    return readRegistry()[station] ?? [];
-}

package/dist/stations/claude.js

@@ -1,45 +0,0 @@
-/** Resolve the Claude Code user identity (account id + session id). */
-import { execFileSync } from 'node:child_process';
-/** Short TTL so account switches via `claude auth login` propagate to the daemon within seconds. */
-const TTL_MS = 5_000;
-let cache = null;
-/** Stable per-Anthropic-account UUID. Same across devices for the same login. */
-export function claudeAccountId() {
-    if (cache && Date.now() - cache.at < TTL_MS)
-        return cache.id;
-    let raw;
-    try {
-        raw = execFileSync('claude', ['auth', 'status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-    }
-    catch (e) {
-        throw new Error(`metro: failed to run 'claude auth status --json' — is Claude Code installed and on PATH? (${e.message})`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        throw new Error(`metro: 'claude auth status --json' returned non-JSON: ${raw.slice(0, 200)}`);
-    }
-    if (!parsed.loggedIn || !parsed.orgId) {
-        throw new Error('metro: Claude Code is not logged in — run \'claude auth login\'');
-    }
-    cache = { id: parsed.orgId, at: Date.now() };
-    return parsed.orgId;
-}
-export function tryClaudeAccountId() {
-    try {
-        return claudeAccountId();
-    }
-    catch {
-        return null;
-    }
-}
-/** User-id for the line URI: `METRO_USER_ID` override, else the account id. */
-export function claudeUserId() {
-    return process.env.METRO_USER_ID || claudeAccountId();
-}
-/** Session: `CLAUDE_CODE_SESSION_ID` (stable across `--resume`). Override: `METRO_USER_SESSION_ID`. */
-export function claudeSessionId() {
-    return process.env.METRO_USER_SESSION_ID || process.env.CLAUDE_CODE_SESSION_ID || null;
-}

package/dist/stations/codex.js

@@ -1,68 +0,0 @@
-/** Resolve the Codex user identity (account id + session id). */
-import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { STATE_DIR } from '../paths.js';
-/** Short TTL so account switches via `codex login` propagate to the daemon within seconds. */
-const TTL_MS = 5_000;
-let cache = null;
-function authPath() {
-    return join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'auth.json');
-}
-export function codexAccountId() {
-    if (cache && Date.now() - cache.at < TTL_MS)
-        return cache.id;
-    const path = authPath();
-    let raw;
-    try {
-        raw = readFileSync(path, 'utf8');
-    }
-    catch (e) {
-        throw new Error(`metro: failed to read ${path} — is Codex logged in? (${e.message})`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        throw new Error(`metro: ${path} is not valid JSON`);
-    }
-    const id = parsed.tokens?.account_id;
-    if (!id) {
-        throw new Error(`metro: no Codex account_id in ${path} (auth_mode=${parsed.auth_mode ?? 'unknown'}) — sign in with 'codex login' (ChatGPT mode required)`);
-    }
-    cache = { id, at: Date.now() };
-    return id;
-}
-export function tryCodexAccountId() {
-    try {
-        return codexAccountId();
-    }
-    catch {
-        return null;
-    }
-}
-/** User-id for the line URI: `METRO_USER_ID` override, else the account id. */
-export function codexUserId() {
-    return process.env.METRO_USER_ID || codexAccountId();
-}
-const SESSION_FILE = join(STATE_DIR, 'stations', 'codex', 'session-id');
-/** Session: codex-rc thread id (daemon persists; CLIs read state file). Override: `METRO_USER_SESSION_ID`. */
-export function codexSessionId() {
-    if (process.env.METRO_USER_SESSION_ID)
-        return process.env.METRO_USER_SESSION_ID;
-    try {
-        return readFileSync(SESSION_FILE, 'utf8').trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Daemon-side: persist the rc thread id so CLI processes can read it. Best-effort. */
-export function setCodexSessionId(threadId) {
-    try {
-        mkdirSync(dirname(SESSION_FILE), { recursive: true });
-        writeFileSync(SESSION_FILE, threadId ?? '');
-    }
-    catch { /* CLI just won't have a session segment */ }
-}

package/dist/stations/discord.js

@@ -1,216 +0,0 @@
-/** Discord station: receive via discord.js gateway; send/edit/react/download/fetch via REST. */
-import { writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
-import { readFile } from 'node:fs/promises';
-import { basename } from 'node:path';
-import { errMsg, log } from '../log.js';
-import { mintId } from '../history.js';
-import { Line, } from './index.js';
-const API_BASE = 'https://discord.com/api/v10';
-const SUPPRESS_EMBEDS = 1 << 2;
-const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
-const token = () => {
-    const t = process.env.DISCORD_BOT_TOKEN;
-    if (!t)
-        throw new Error('DISCORD_BOT_TOKEN is not set');
-    return t;
-};
-async function rest(method, path, body, timeoutMs = 30_000, retriesLeft = 2) {
-    const res = await fetch(`${API_BASE}${path}`, {
-        method,
-        headers: {
-            'Authorization': `Bot ${token()}`,
-            'User-Agent': 'metro (https://github.com/bonustrack/metro, dev)',
-            ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
-        },
-        body: body !== undefined ? JSON.stringify(body) : undefined,
-        signal: AbortSignal.timeout(timeoutMs),
-    });
-    if (res.status === 429 && retriesLeft > 0) {
-        const retryAfter = Number(res.headers.get('retry-after')) || 1;
-        log.debug({ path, retryAfter }, 'discord 429; backing off');
-        await new Promise(r => setTimeout(r, Math.max(retryAfter * 1000, 250)));
-        return rest(method, path, body, timeoutMs, retriesLeft - 1);
-    }
-    if (!res.ok) {
-        const text = await res.text().catch(() => '');
-        throw new Error(`discord ${method} ${path}: ${res.status} ${text}`);
-    }
-    return res.status === 204 ? undefined : (await res.json());
-}
-/** Multipart upload (payload_json + files[N]). Same retry semantics as `rest`. */
-async function restMultipart(method, path, payload, files) {
-    const form = new FormData();
-    form.append('payload_json', JSON.stringify(payload));
-    for (const [i, f] of files.entries()) {
-        form.append(`files[${i}]`, new Blob([new Uint8Array(f.data)]), basename(f.path));
-    }
-    const res = await fetch(`${API_BASE}${path}`, {
-        method,
-        headers: {
-            'Authorization': `Bot ${token()}`,
-            'User-Agent': 'metro (https://github.com/bonustrack/metro, dev)',
-        },
-        body: form, signal: AbortSignal.timeout(60_000),
-    });
-    if (!res.ok) {
-        const t = await res.text().catch(() => '');
-        throw new Error(`discord ${method} ${path}: ${res.status} ${t}`);
-    }
-    return (await res.json());
-}
-const collectFiles = async (opts) => {
-    const paths = [...(opts?.images ?? []), ...(opts?.documents ?? []), ...(opts?.voice ? [opts.voice] : [])];
-    return Promise.all(paths.map(async (p) => ({ path: p, data: await readFile(p) })));
-};
-/** Convert button rows to Discord component arrays (URL buttons only — style=5). */
-const discordButtons = (rows) => rows.map(row => ({
-    type: 1, components: row.map(b => ({ type: 2, style: 5, label: b.text, url: b.url })),
-}));
-const channelOf = (line) => {
-    const id = Line.parseDiscord(line);
-    if (!id)
-        throw new Error(`not a discord line: ${line}`);
-    return id;
-};
-export class DiscordStation {
-    name = 'discord';
-    client = null;
-    messageHandler = () => { };
-    reactionHandler = () => { };
-    onMessage(handler) {
-        this.messageHandler = handler;
-    }
-    onReaction(handler) { this.reactionHandler = handler; }
-    getClient() {
-        return this.client ??= new Client({
-            intents: [
-                GatewayIntentBits.DirectMessages, GatewayIntentBits.Guilds,
-                GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent,
-                GatewayIntentBits.GuildMessageReactions, GatewayIntentBits.DirectMessageReactions,
-            ],
-            partials: [Partials.Channel, Partials.Message, Partials.Reaction],
-        });
-    }
-    async start() {
-        const c = this.getClient();
-        c.on(Events.MessageCreate, m => { void this.handleMessage(m); });
-        c.on(Events.MessageReactionAdd, (r, u) => { void this.handleReaction(r, u); });
-        c.on(Events.Error, err => log.error({ err: errMsg(err) }, 'discord error'));
-        await c.login(process.env.DISCORD_BOT_TOKEN);
-        await new Promise(r => c.once(Events.ClientReady, () => r()));
-    }
-    async stop() {
-        if (!this.client)
-            return;
-        await this.client.destroy();
-        this.client = null;
-    }
-    async getMe() {
-        return rest('GET', '/users/@me');
-    }
-    async send(line, text, opts) {
-        const payload = { content: text, flags: SUPPRESS_EMBEDS };
-        if (opts?.replyTo)
-            payload.message_reference = { message_id: opts.replyTo };
-        if (opts?.buttons?.length)
-            payload.components = discordButtons(opts.buttons);
-        const path = `/channels/${channelOf(line)}/messages`;
-        const files = await collectFiles(opts);
-        const sent = files.length
-            ? await restMultipart('POST', path, payload, files)
-            : await rest('POST', path, payload);
-        return sent.id;
-    }
-    async edit(line, messageId, text, opts) {
-        const payload = { content: text, flags: SUPPRESS_EMBEDS };
-        payload.components = opts?.buttons?.length ? discordButtons(opts.buttons) : [];
-        await rest('PATCH', `/channels/${channelOf(line)}/messages/${messageId}`, payload);
-    }
-    async react(line, messageId, emoji) {
-        const ch = channelOf(line);
-        if (!emoji) {
-            await rest('DELETE', `/channels/${ch}/messages/${messageId}/reactions/@me`);
-            return;
-        }
-        await rest('PUT', `/channels/${ch}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`);
-    }
-    async download(line, messageId, outDir) {
-        const ch = channelOf(line);
-        const msg = await rest('GET', `/channels/${ch}/messages/${messageId}`);
-        const out = [];
-        for (const [i, a] of (msg.attachments ?? []).entries()) {
-            if (!a.content_type?.startsWith('image/'))
-                continue;
-            if (a.size > MAX_ATTACHMENT_BYTES) {
-                log.warn({ size: a.size, name: a.filename }, 'discord: attachment too large; skipped');
-                continue;
-            }
-            try {
-                const res = await fetch(a.url, { signal: AbortSignal.timeout(30_000) });
-                if (!res.ok)
-                    throw new Error(`status ${res.status}`);
-                const buf = Buffer.from(await res.arrayBuffer());
-                const path = join(outDir, `${messageId}-${i}-${a.filename}`);
-                await writeFile(path, buf);
-                out.push({ path, mediaType: a.content_type });
-            }
-            catch (err) {
-                log.warn({ err: errMsg(err), url: a.url }, 'discord: attachment fetch failed');
-            }
-        }
-        return out;
-    }
-    async fetch(line, limit) {
-        const capped = Math.max(1, Math.min(100, limit | 0));
-        const msgs = await rest('GET', `/channels/${channelOf(line)}/messages?limit=${capped}`);
-        return [...msgs].reverse().map(m => ({
-            messageId: m.id, author: m.author.username, text: m.content, timestamp: m.timestamp,
-        }));
-    }
-    async handleReaction(r, u) {
-        if (u.bot)
-            return;
-        const emoji = r.emoji.name;
-        if (!emoji)
-            return;
-        const channelId = r.message.channelId;
-        const messageId = r.message.id;
-        const username = 'username' in u && u.username ? u.username : undefined;
-        log.info({ from: username, channel: channelId, emoji, messageId }, 'discord: reaction');
-        this.reactionHandler({
-            id: mintId(), ts: new Date().toISOString(),
-            station: 'discord', line: Line.discord(channelId),
-            from: Line.user('discord', u.id), fromName: username,
-            messageId, emoji, isPrivate: r.message.guildId === null,
-        });
-    }
-    async handleMessage(m) {
-        if (m.author.bot)
-            return;
-        const tags = [...m.attachments.values()].map(a => a.contentType?.startsWith('image/') ? '[image]'
-            : a.contentType?.startsWith('audio/') ? `[audio: ${a.name}]` : `[file: ${a.name}]`);
-        const text = [m.content.trim(), ...tags].filter(Boolean).join(' ');
-        if (!text)
-            return;
-        log.info({ from: m.author.username, channel: m.channelId, text: text.slice(0, 80) }, 'discord: inbound');
-        const lineName = m.channel && 'name' in m.channel
-            ? m.channel.name ?? undefined : undefined;
-        const payload = m.toJSON();
-        if (m.reference?.messageId) {
-            try {
-                payload.referencedMessage = (await m.fetchReference()).toJSON();
-            }
-            catch (err) {
-                log.debug({ err: errMsg(err) }, 'discord: fetchReference failed');
-            }
-        }
-        this.messageHandler({
-            id: mintId(), ts: new Date(m.createdTimestamp).toISOString(),
-            station: 'discord', line: Line.discord(m.channelId), lineName,
-            from: Line.user('discord', m.author.id), fromName: m.author.username,
-            messageId: m.id, text, payload, isPrivate: m.guildId === null,
-        });
-    }
-}