@stage-labs/metro 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/dispatcher.js

@@ -7,17 +7,29 @@ import { fileURLToPath } from 'node:url';
 import pkg from '../package.json' with { type: 'json' };
 import { DiscordStation } from './stations/discord.js';
 import { TelegramStation } from './stations/telegram.js';
-import { asLine } from './stations/index.js';
+import { WebhookStation } from './stations/webhook.js';
+import { asLine, Line } from './stations/index.js';
 import { CodexRC } from './codex-rc.js';
 import { startIpcServer, stopIpcServer } from './ipc.js';
-import { agentSelf, appendHistory, mintId } from './history.js';
+import { agentSelf, appendHistory, mintId, selfLine } from './history.js';
 import { noteSeen, saveBotId } from './cache.js';
 import { errMsg, log } from './log.js';
 import { acquireLock, configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
+import { setCodexSessionId } from './stations/codex.js';
+import { noteAgentFromLine } from './registry.js';
+import { listEndpoints } from './webhooks.js';
+import { loadTunnelConfig, Tunnel } from './tunnel.js';
 loadMetroEnv();
 const platforms = configuredPlatforms();
-requireConfiguredPlatform(platforms);
+const endpoints = listEndpoints();
+requireConfiguredPlatform(platforms, endpoints.length > 0);
 acquireLock(join(STATE_DIR, '.tail-lock'));
+// Fail fast if launched from Claude Code without a logged-in account.
+const self = agentSelf();
+log.info({ self, line: selfLine() }, 'agent identity');
+const seedSelf = () => { const l = selfLine(); if (l)
+    noteAgentFromLine(l); };
+seedSelf();
 const AGENTS_MD = join(STATE_DIR, 'AGENTS.md');
 try {
     copyFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'docs', 'agents.md'), AGENTS_MD);
@@ -31,40 +43,31 @@ process.stdout.on('error', err => {
         log.warn({ err: errMsg(err) }, 'stdout error');
 });
 const codexRc = process.env.METRO_CODEX_RC ? new CodexRC(process.env.METRO_CODEX_RC, pkg.version) : null;
+codexRc?.onThread(id => { setCodexSessionId(id); seedSelf(); });
 codexRc?.start();
 const discord = new DiscordStation();
 const telegram = new TelegramStation();
-function emit(event) {
-    const json = JSON.stringify(event);
+const webhook = new WebhookStation();
+const tunnelCfg = loadTunnelConfig();
+const tunnel = tunnelCfg ? new Tunnel(tunnelCfg, webhook.port()) : null;
+function emit(entry) {
+    const json = JSON.stringify(entry);
     process.stdout.write(json + '\n');
     codexRc?.push(json);
-    if ('lineName' in event)
-        noteSeen(event.line, event.lineName);
-    else
-        noteSeen(event.line);
-    if (event.type === 'inbound') {
-        appendHistory({
-            id: event.id, ts: event.ts, kind: 'inbound', station: event.station, line: event.line,
-            from: event.from, fromName: event.fromName, to: agentSelf(), text: event.text,
-            platformMessageId: event.messageId, attachments: event.attachmentNames,
-        });
-    }
-    else if (event.type === 'notification') {
-        appendHistory({
-            id: event.id, ts: event.ts, kind: 'notification',
-            station: event.line.replace(/^metro:\/\/([^/]+)\/.*$/, '$1'),
-            line: event.line, from: event.from ?? agentSelf(),
-            to: event.line, text: event.text,
-        });
-    }
+    noteSeen(entry.line, entry.lineName);
+    for (const l of [entry.line, entry.from, entry.to])
+        if (l)
+            noteAgentFromLine(l);
+    appendHistory(entry);
 }
-const onInbound = (m) => emit({ type: 'inbound', ...m, to: agentSelf() });
+const onInbound = (m) => emit({ ...m, kind: 'inbound', to: agentSelf() });
 const ipc = startIpcServer(async (req) => {
     if (req.op === 'notify') {
+        const line = asLine(req.line);
         emit({
-            type: 'notification', id: mintId(), ts: new Date().toISOString(),
-            line: asLine(req.line),
-            from: req.from ? asLine(req.from) : agentSelf(), text: req.text,
+            id: mintId(), ts: new Date().toISOString(), kind: 'notification',
+            station: Line.station(line) ?? '?', line,
+            from: req.from ? asLine(req.from) : agentSelf(), to: line, text: req.text,
         });
         return { ok: true };
     }
@@ -89,7 +92,13 @@ async function main() {
         saveBotId('telegram', String(me.id));
         log.info({ bot: `@${me.username}` }, 'telegram ready');
     }
-    log.info({ codexRc: !!codexRc }, 'dispatcher ready');
+    /** Start the HTTP receiver only when ≥1 endpoint is registered — no point binding a port nobody listens to. */
+    if (endpoints.length) {
+        webhook.onMessage(onInbound);
+        await webhook.start();
+        tunnel?.start();
+    }
+    log.info({ codexRc: !!codexRc, tunnel: !!tunnel }, 'dispatcher ready');
 }
 let shuttingDown = false;
 async function shutdown() {
@@ -98,15 +107,16 @@ async function shutdown() {
     shuttingDown = true;
     log.info('dispatcher shutting down');
     codexRc?.stop();
+    tunnel?.stop();
     await stopIpcServer(ipc).catch(() => { });
+    await webhook.stop().catch(() => { });
     if (platforms.discord)
         await discord.stop().catch(() => { });
     if (platforms.telegram)
         await telegram.stop().catch(() => { });
     process.exit(0);
 }
-process.stdin.on('end', shutdown);
-process.stdin.on('close', shutdown);
-process.on('SIGINT', shutdown);
-process.on('SIGTERM', shutdown);
+process.stdin.on('end', shutdown).on('close', shutdown);
+for (const sig of ['SIGINT', 'SIGTERM'])
+    process.on(sig, shutdown);
 await main();

package/dist/history.js

@@ -4,6 +4,9 @@ import { appendFileSync, existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { errMsg, log } from './log.js';
 import { STATE_DIR } from './paths.js';
+import { Line } from './stations/index.js';
+import { claudeAgentId, claudeSessionId } from './stations/claude.js';
+import { codexAgentId, codexSessionId } from './stations/codex.js';
 const FILE = join(STATE_DIR, 'history.jsonl');
 /** Mint a universal metro message ID. Short, prefixed, URL-safe. */
 export const mintId = () => `msg_${randomBytes(6).toString('base64url')}`;
@@ -60,25 +63,37 @@ function matches(e, f) {
 /** Find an entry by universal id OR platform message id. */
 export function lookupEntry(id) {
     const entries = readHistory({ limit: 5_000 });
-    return entries.find(e => e.id === id || e.platformMessageId === id);
+    return entries.find(e => e.id === id || e.messageId === id);
 }
 /** Look up the platform messageId for a universal `msg_*` id; returns the input unchanged otherwise. */
 export function resolvePlatformId(id) {
     if (!id.startsWith('msg_'))
         return id;
     const hit = lookupEntry(id);
-    if (hit?.platformMessageId)
-        return hit.platformMessageId;
+    if (hit?.messageId)
+        return hit.messageId;
     throw new Error(`unknown universal id: ${id} (run \`metro history --limit=50\` to see recent ids)`);
 }
-/** Resolve the current agent's identity URI. Precedence: METRO_FROM > runtime env > generic. */
+/** The current agent's **participant** URI for `from`/`to`. Precedence: METRO_FROM > runtime env > generic. */
 export function agentSelf() {
     const explicit = process.env.METRO_FROM;
     if (explicit)
         return explicit;
     if (process.env.CLAUDECODE)
-        return 'metro://claude/agent';
+        return Line.user('claude', claudeAgentId());
     if (process.env.METRO_CODEX_RC || process.env.CODEX_HOME)
-        return 'metro://codex/agent';
+        return Line.user('codex', codexAgentId());
     return 'metro://agent';
 }
+/** The current agent's **line** URI `<agent-id>/<session>`. Null until session is known (rc thread pending). */
+export function selfLine() {
+    if (process.env.CLAUDECODE) {
+        const s = claudeSessionId();
+        return s ? Line.claude(claudeAgentId(), s) : null;
+    }
+    if (process.env.METRO_CODEX_RC || process.env.CODEX_HOME) {
+        const s = codexSessionId();
+        return s ? Line.codex(codexAgentId(), s) : null;
+    }
+    return null;
+}

package/dist/ipc.js

@@ -12,7 +12,8 @@ export function startIpcServer(handler) {
         }
         catch { /* ignore */ }
     }
-    const server = createServer(socket => handleConnection(socket, handler));
+    /** allowHalfOpen: any `await` in the handler races Node's auto-end-on-client-FIN, dropping the response. */
+    const server = createServer({ allowHalfOpen: true }, s => handleConnection(s, handler));
     server.on('error', err => log.warn({ err: errMsg(err) }, 'ipc server error'));
     server.listen(SOCKET_PATH, () => log.debug({ path: SOCKET_PATH }, 'ipc socket listening'));
     return server;

package/dist/paths.js

@@ -36,10 +36,10 @@ export function loadMetroEnv() {
 export function configuredPlatforms() {
     return { telegram: !!process.env.TELEGRAM_BOT_TOKEN, discord: !!process.env.DISCORD_BOT_TOKEN };
 }
-export function requireConfiguredPlatform(p) {
-    if (p.telegram || p.discord)
+export function requireConfiguredPlatform(p, hasWebhooks) {
+    if (p.telegram || p.discord || hasWebhooks)
         return;
-    log.fatal('no platforms configured — run `metro setup telegram <token>` or `metro setup discord <token>`');
+    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. */

package/dist/registry.js

@@ -0,0 +1,48 @@
+/** Append-only registry of `(station, agent-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, 'agent-registry.json');
+function readRegistry() {
+    if (!existsSync(REGISTRY_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(REGISTRY_FILE, 'utf8'));
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err) }, 'agent-registry: malformed, resetting');
+        return {};
+    }
+}
+function record(station, agentId, sessionId) {
+    const reg = readRegistry();
+    const rows = (reg[station] ??= []);
+    let row = rows.find(r => r.agentId === agentId);
+    if (!row) {
+        row = { agentId, 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) }, 'agent-registry: write failed');
+    }
+}
+/** Scan a line URI for `(station, agentId, sessionId)` and record it. No-op on non-agent or participant URIs. */
+export function noteAgentFromLine(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.agentId, p.sessionId);
+}
+export function listAgents(station) {
+    return readRegistry()[station] ?? [];
+}

package/dist/stations/claude.js

@@ -0,0 +1,45 @@
+/** Resolve the Claude Code agent 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;
+    }
+}
+/** Agent-id for the line URI: `METRO_AGENT_ID` override, else the account id. */
+export function claudeAgentId() {
+    return process.env.METRO_AGENT_ID || claudeAccountId();
+}
+/** Session: `CLAUDE_CODE_SESSION_ID` (stable across `--resume`). Override: `METRO_AGENT_SESSION_ID`. */
+export function claudeSessionId() {
+    return process.env.METRO_AGENT_SESSION_ID || process.env.CLAUDE_CODE_SESSION_ID || null;
+}

package/dist/stations/codex.js

@@ -0,0 +1,68 @@
+/** Resolve the Codex agent 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;
+    }
+}
+/** Agent-id for the line URI: `METRO_AGENT_ID` override, else the account id. */
+export function codexAgentId() {
+    return process.env.METRO_AGENT_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_AGENT_SESSION_ID`. */
+export function codexSessionId() {
+    if (process.env.METRO_AGENT_SESSION_ID)
+        return process.env.METRO_AGENT_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

@@ -97,7 +97,7 @@ export class DiscordStation {
     }
     async start() {
         const c = this.getClient();
-        c.on(Events.MessageCreate, m => { void this.handleMessage(m, c); });
+        c.on(Events.MessageCreate, m => { void this.handleMessage(m); });
         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()));
@@ -170,29 +170,31 @@ export class DiscordStation {
             messageId: m.id, author: m.author.username, text: m.content, timestamp: m.timestamp,
         }));
     }
-    async handleMessage(m, c) {
+    async handleMessage(m) {
         if (m.author.bot)
             return;
-        const attachmentNames = [];
-        for (const a of m.attachments.values()) {
-            if (a.contentType?.startsWith('image/'))
-                attachmentNames.push('[image]');
-            else
-                attachmentNames.push(a.contentType?.startsWith('audio/') ? `[audio: ${a.name}]` : `[file: ${a.name}]`);
-        }
-        const text = m.content.trim();
-        if (!text && !attachmentNames.length)
+        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, bot: c.user?.username, channel: m.channelId, text: text.slice(0, 80) }, 'discord: inbound');
+        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, attachmentNames,
-            mentionsBot: !m.guildId || (c.user ? m.mentions.has(c.user.id) : false),
-            meta: { inGuild: !!m.guildId },
+            messageId: m.id, text, payload,
         });
     }
 }

package/dist/stations/index.js

@@ -1,13 +1,29 @@
 /** Line URI scheme + ChatStation interface + station listing. The whole station surface. */
+import { tryClaudeAccountId } from './claude.js';
+import { tryCodexAccountId } from './codex.js';
+import { listAgents } from '../registry.js';
+import { listEndpoints } from '../webhooks.js';
+import { loadTunnelConfig } from '../tunnel.js';
 export const asLine = (s) => s;
 const PREFIX = 'metro://';
 const build = (station, ...seg) => asLine(`${PREFIX}${station}/${seg.map(String).join('/')}`);
+/** Shared parser for `metro://{claude,codex}/<agentId>/<sessionId>`. Skips participant URIs (`/user/…`, `/bot/…`). */
+function parseAgent(line, station) {
+    const p = Line.parse(line);
+    if (p?.station !== station || p.path[0] === 'user' || p.path[0] === 'bot' || p.path.length < 2)
+        return null;
+    return { agentId: p.path[0], sessionId: p.path[1] };
+}
 /** URI helpers. Lives on a const that doubles as the `Line` type's value-side namespace. */
 export const Line = {
     discord: (channelId) => build('discord', channelId),
     telegram: (chatId, topicId) => topicId !== undefined ? build('telegram', chatId, topicId) : build('telegram', chatId),
-    claude: (topic) => build('claude', topic),
-    codex: (topic) => build('codex', topic),
+    /** `metro://claude/<orgId>/<sessionId>` — orgId from `claude auth status`, session from `CLAUDE_CODE_SESSION_ID`. */
+    claude: (orgId, sessionId) => build('claude', orgId, sessionId),
+    /** `metro://codex/<accountId>/<threadId>` — accountId from auth.json, thread from codex-rc handshake. */
+    codex: (accountId, threadId) => build('codex', accountId, threadId),
+    /** `metro://webhook/<endpoint-id>` — one HTTP receive endpoint, registered via `metro webhook add`. */
+    webhook: (endpointId) => build('webhook', endpointId),
     /** Participant URIs — `metro://<station>/user/<id>` and `metro://<station>/bot/<id>`. */
     user: (station, id) => build(station, 'user', id),
     bot: (station, id) => build(station, 'bot', id),
@@ -38,17 +54,49 @@ export const Line = {
         const topicId = Number(p.path[1]);
         return Number.isFinite(topicId) ? { chatId, topicId } : null;
     },
+    parseClaude: (line) => parseAgent(line, 'claude'),
+    parseCodex: (line) => parseAgent(line, 'codex'),
+    parseWebhook(line) {
+        const p = Line.parse(line);
+        return p?.station === 'webhook' && p.path.length === 1 ? p.path[0] : null;
+    },
     isAgent: (line) => {
         const s = Line.station(line);
         return s === 'claude' || s === 'codex';
     },
 };
-const AGENT_CAPS = { in: ['text'], out: [], features: ['notify'] };
+/** `out: ['text']` + `send` reflects the IPC notify path (`metro send metro://<station>/...` re-emits on stdout). */
+const AGENT_CAPS = { in: ['text'], out: ['text'], features: ['send', 'notify'] };
 const CHAT_CAPS = {
     in: ['text', 'image'],
     out: ['text'],
     features: ['reply', 'send', 'edit', 'react', 'download', 'fetch'],
 };
+const WEBHOOK_CAPS = { in: ['text'], out: [], features: [] };
+function seenSummary(station) {
+    const agents = listAgents(station);
+    if (!agents.length)
+        return '';
+    const sessions = agents.reduce((n, a) => n + a.sessions.length, 0);
+    return ` · seen ${agents.length} agent${agents.length === 1 ? '' : 's'}, ${sessions} session${sessions === 1 ? '' : 's'}`;
+}
+function claudeStationDetail() {
+    const seen = seenSummary('claude');
+    if (!process.env.CLAUDECODE)
+        return `launch metro from inside a Claude Code session${seen}`;
+    const orgId = tryClaudeAccountId();
+    return `${orgId ? `account: ${orgId}` : 'logged out — run `claude auth login`'}${seen}`;
+}
+function codexStationDetail() {
+    const rc = process.env.METRO_CODEX_RC;
+    const accountId = tryCodexAccountId();
+    const seen = seenSummary('codex');
+    const parts = [
+        accountId ? `account: ${accountId}` : (rc ? '(no Codex account — run `codex login`)' : null),
+        rc ? `push → ${rc}` : (!accountId ? 'set METRO_CODEX_RC=ws://… to push' : null),
+    ].filter(Boolean);
+    return `${parts.join(' · ')}${seen}`;
+}
 export const listStations = () => [
     {
         name: 'discord', kind: 'chat', capabilities: CHAT_CAPS,
@@ -60,14 +108,26 @@ export const listStations = () => [
     },
     {
         name: 'claude', kind: 'agent', capabilities: AGENT_CAPS,
-        configured: null, detail: 'stdout stream (watch via Claude Code Monitor)',
+        configured: !!process.env.CLAUDECODE,
+        detail: claudeStationDetail(),
     },
     {
         name: 'codex', kind: 'agent', capabilities: AGENT_CAPS,
-        configured: process.env.METRO_CODEX_RC ? true : null,
-        detail: process.env.METRO_CODEX_RC
-            ? `push → ${process.env.METRO_CODEX_RC}`
-            : 'set METRO_CODEX_RC=ws://… to push',
+        configured: !!(process.env.METRO_CODEX_RC || process.env.CODEX_HOME),
+        detail: codexStationDetail(),
+    },
+    {
+        name: 'webhook', kind: 'service', capabilities: WEBHOOK_CAPS,
+        configured: listEndpoints().length > 0,
+        detail: webhookStationDetail(),
     },
 ];
+function webhookStationDetail() {
+    const eps = listEndpoints();
+    const t = loadTunnelConfig();
+    const base = t ? `https://${t.hostname}` : `http://127.0.0.1:${Number(process.env.METRO_WEBHOOK_PORT) || 8420}`;
+    if (!eps.length)
+        return `no endpoints (run \`metro webhook add <label>\`)${t ? ` · tunnel → ${t.hostname}` : ''}`;
+    return `${eps.length} endpoint${eps.length === 1 ? '' : 's'} · base ${base}${t ? '' : ' (no tunnel — run `metro tunnel setup`)'}`;
+}
 export const fmtCapabilities = (c) => `in: ${c.in.join('+') || '–'} · out: ${c.out.join('+') || '–'} · features: ${c.features.join(', ') || '–'}`;

package/dist/stations/telegram.js

@@ -59,8 +59,6 @@ const CAPS = {
 export class TelegramStation {
     name = 'telegram';
     capabilities = CAPS;
-    botUsername = null;
-    botUserId = null;
     pollOffset = 0;
     pollAbort = null;
     messageHandler = () => { };
@@ -85,10 +83,7 @@ export class TelegramStation {
     }
     async stop() { this.pollAbort?.abort(); this.pollAbort = null; }
     async getMe() {
-        const me = await tg('getMe', {});
-        this.botUsername = me.username;
-        this.botUserId = me.id;
-        return me;
+        return tg('getMe', {});
     }
     async send(line, text, opts) {
         const { chatId, topicId } = targetOf(line);
@@ -196,15 +191,12 @@ export class TelegramStation {
         const m = u.message;
         if (!m?.chat?.id || typeof m.message_id !== 'number' || m.from?.is_bot)
             return;
-        const attachmentNames = attachmentTags(m);
-        const text = m.text ?? m.caption ?? '';
-        if (!text && !attachmentNames.length)
+        const text = [m.text ?? m.caption, ...attachmentTags(m)].filter(Boolean).join(' ');
+        if (!text)
             return;
         const topicId = m.is_topic_message ? m.message_thread_id : undefined;
         const fromName = m.from?.username ? `@${m.from.username}` : m.from?.first_name;
-        const fromUri = Line.user('telegram', m.from?.id ?? 'unknown');
-        const bot = this.botUsername ? `@${this.botUsername}` : undefined;
-        log.info({ from: fromName, bot, chat: m.chat.id, topic: topicId, text: text.slice(0, 80) }, 'telegram: inbound');
+        log.info({ from: fromName, chat: m.chat.id, topic: topicId, text: text.slice(0, 80) }, 'telegram: inbound');
         if (this.recent.size >= 50) {
             const first = this.recent.keys().next().value;
             if (first)
@@ -215,21 +207,7 @@ export class TelegramStation {
             id: mintId(), ts: new Date((m.date ?? Math.floor(Date.now() / 1000)) * 1000).toISOString(),
             station: 'telegram', line: Line.telegram(m.chat.id, topicId), messageId: String(m.message_id),
             lineName: topicId === undefined ? (m.chat.title ?? m.chat.first_name ?? undefined) : undefined,
-            from: fromUri, fromName, text, attachmentNames, mentionsBot: this.detectMentionsBot(m),
-            meta: { isPrivate: m.chat.type === 'private', inForum: !!m.chat.is_forum, isForumTopic: !!m.is_topic_message },
+            from: Line.user('telegram', m.from?.id ?? 'unknown'), fromName, text, payload: m,
         });
     }
-    detectMentionsBot(m) {
-        if (m.chat?.type === 'private')
-            return true;
-        const text = m.text ?? m.caption ?? '';
-        for (const e of m.entities ?? m.caption_entities ?? []) {
-            if (e.type === 'mention' && this.botUsername
-                && text.substring(e.offset, e.offset + e.length).toLowerCase() === `@${this.botUsername.toLowerCase()}`)
-                return true;
-            if (e.type === 'text_mention' && e.user?.id === this.botUserId)
-                return true;
-        }
-        return false;
-    }
 }