@stage-labs/metro 0.1.0-beta.7 → 0.1.0-beta.71

package/runtime/node_modules/@metro-labs/xmtp/src/transcribe.ts

@@ -0,0 +1,90 @@
+import { errMsg } from '@metro-labs/mcp/log';
+import { mintId, SELF_URI } from './wire.js';
+
+type EmitInbound = (accountId: string, e: Record<string, unknown>) => void;
+
+const WHISPER_BIN = process.env.METRO_WHISPER_BIN ?? 'whisper-cli';
+const WHISPER_MODEL =
+  process.env.METRO_WHISPER_MODEL ??
+  `${process.env.HOME}/.cache/whisper-cpp/ggml-base.bin`;
+const FFMPEG_BIN = process.env.METRO_FFMPEG_BIN ?? 'ffmpeg';
+
+export async function transcribeAndEmit(
+  audio: Uint8Array,
+  line: string,
+  accountId: string,
+  sourceMsgId: string,
+  emitInbound: EmitInbound,
+): Promise<void> {
+  const {
+    existsSync: ex,
+    readFileSync: rf,
+    writeFileSync: wf,
+    unlinkSync,
+    mkdtempSync,
+  } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const path = await import('node:path');
+  const j = (...parts: string[]): string => path.join(...parts);
+  const { spawn } = await import('node:child_process');
+  if (!ex(WHISPER_MODEL)) return;
+  const dir = mkdtempSync(j(tmpdir(), 'xmtp-tx-'));
+  const inFile = j(dir, 'in.m4a');
+  const wav = j(dir, 'in.wav');
+  const out = j(dir, 'in');
+  const run = (bin: string, args: string[]): Promise<void> =>
+    new Promise((res, rej) => {
+      const p = spawn(bin, args, { stdio: 'ignore' });
+      p.on('error', rej);
+      p.on('exit', (c) => {
+        if (c === 0) res();
+        else rej(new Error(`${bin} ${String(c)}`));
+      });
+    });
+  try {
+    wf(inFile, audio);
+    await run(FFMPEG_BIN, [
+      '-y',
+      '-i',
+      inFile,
+      '-ar',
+      '16000',
+      '-ac',
+      '1',
+      wav,
+    ]);
+    await run(WHISPER_BIN, [
+      '-m',
+      WHISPER_MODEL,
+      '-f',
+      wav,
+      '--output-txt',
+      '-of',
+      out,
+    ]);
+    const text = rf(`${out}.txt`, 'utf8').trim();
+    if (!text) return;
+    emitInbound(accountId, {
+      id: mintId(),
+      ts: new Date().toISOString(),
+      station: 'xmtp',
+      line,
+      from: SELF_URI,
+      text: `🎙️ ${text}`,
+      payload: {
+        contentType: 'transcript',
+        transcribeFor: sourceMsgId,
+        transcript: text,
+      },
+    });
+  } catch (err) {
+    process.stderr.write(`xmtp transcribe failed: ${errMsg(err)}\n`);
+  } finally {
+    for (const f of [inFile, wav, `${out}.txt`]) {
+      try {
+        unlinkSync(f);
+      } catch {
+      }
+    }
+  }
+}

package/runtime/node_modules/@metro-labs/xmtp/src/verify.ts

@@ -0,0 +1,84 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { Client, type ClientOptions, type Signer } from '@xmtp/node-sdk';
+import { expandHome, signerFor, XMTP_ENV } from './identity.js';
+
+export class XmtpVerifyError extends Error {}
+
+export interface XmtpVerified {
+  inboxId: string;
+  address: string;
+  installationId: string;
+  dbPath: string;
+}
+
+interface RegisteredClient {
+  inboxId: string;
+  installationId: string;
+  isRegistered: boolean;
+}
+
+export type CreateXmtpClient = (
+  signer: Signer,
+  dbPath: string,
+) => Promise<RegisteredClient>;
+
+const openInbox: CreateXmtpClient = (signer, dbPath) => {
+  const options: ClientOptions = { env: XMTP_ENV, dbPath };
+  return Client.create(signer, options);
+};
+
+const reason = (err: unknown): string =>
+  err instanceof Error && err.message !== '' ? err.message : 'no reason given';
+
+export async function verifyXmtpKey(
+  privateKey: string,
+  dbPath: string,
+  create: CreateXmtpClient = openInbox,
+): Promise<XmtpVerified> {
+  let signer: Signer;
+  let address: string;
+  try {
+    ({ signer, address } = signerFor(privateKey));
+  } catch {
+    throw new XmtpVerifyError('that is not a usable XMTP private key');
+  }
+  const resolved = expandHome(dbPath);
+  mkdirSync(dirname(resolved), { recursive: true });
+  const client = await create(signer, resolved).catch((err: unknown) => {
+    throw new XmtpVerifyError(
+      `XMTP would not open an inbox for that key: ${reason(err)}`,
+    );
+  });
+  if (!client.isRegistered)
+    throw new XmtpVerifyError('XMTP did not register an inbox for that key');
+  if (client.inboxId === '')
+    throw new XmtpVerifyError('XMTP returned no inbox id for that key');
+  return {
+    inboxId: client.inboxId,
+    address,
+    installationId: client.installationId,
+    dbPath: resolved,
+  };
+}
+
+async function runCli(): Promise<void> {
+  let out: Record<string, unknown>;
+  try {
+    const input = JSON.parse(readFileSync(0, 'utf8')) as {
+      privateKey?: unknown;
+      dbPath?: unknown;
+    };
+    if (typeof input.privateKey !== 'string' || typeof input.dbPath !== 'string')
+      throw new XmtpVerifyError('xmtp verify needs a privateKey and a dbPath');
+    out = { ok: true, ...(await verifyXmtpKey(input.privateKey, input.dbPath)) };
+  } catch (err) {
+    out = { ok: false, error: reason(err) };
+  }
+  writeFileSync(1, `${JSON.stringify(out)}\n`);
+}
+
+if (import.meta.main) {
+  await runCli();
+  process.exit(0);
+}

package/runtime/node_modules/@metro-labs/xmtp/src/wire.ts

@@ -0,0 +1,53 @@
+export { emit, respond, mintId } from '@metro-labs/mcp/stations/station-runtime';
+
+export const SELF_URI = process.env.METRO_SELF_URI ?? '';
+
+const UID_MAP_MAX = 5000;
+const uidToXmtp = new Map<string, string>();
+
+const INBOX_ETH_CACHE_MAX = 5000;
+export const inboxEthCache = new Map<string, string>();
+
+export function cacheInboxEth(inboxId: string, eth: string): void {
+  inboxEthCache.set(inboxId, eth);
+  if (inboxEthCache.size > INBOX_ETH_CACHE_MAX) {
+    const oldest = inboxEthCache.keys().next().value;
+    if (oldest !== undefined) inboxEthCache.delete(oldest);
+  }
+}
+
+export function rememberUid(
+  uid: string | undefined,
+  xmtpId: string | undefined,
+): void {
+  if (!uid || !xmtpId || !uid.startsWith('msg_')) return;
+  uidToXmtp.set(uid, xmtpId);
+  if (uidToXmtp.size > UID_MAP_MAX) {
+    const oldest = uidToXmtp.keys().next().value;
+    if (oldest !== undefined) uidToXmtp.delete(oldest);
+  }
+}
+
+export function resolveMsgId(rawId: string): string {
+  if (!rawId.startsWith('msg_')) return rawId;
+  const mapped = uidToXmtp.get(rawId);
+  if (mapped) return mapped;
+  throw new Error(
+    `could not resolve universal id ${rawId} to an xmtp message id ` +
+      '(not seen by this train; pass the raw xmtp message_id)',
+  );
+}
+
+const SENT_MAX = 5000;
+const sentIds = new Set<string>();
+
+export function rememberSent(xmtpId: string | undefined): void {
+  if (!xmtpId) return;
+  sentIds.add(xmtpId);
+  if (sentIds.size > SENT_MAX) {
+    const oldest = sentIds.values().next().value;
+    if (oldest !== undefined) sentIds.delete(oldest);
+  }
+}
+
+export const sentByMe = (xmtpId: string): boolean => sentIds.has(xmtpId);

package/runtime/runtime.json

@@ -0,0 +1,3 @@
+{
+  "version": "0.1.0-beta.71"
+}

package/runtime/stations.json

@@ -0,0 +1,36 @@
+{
+  "core": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@noble/curves": "^1.9.7",
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3",
+    "viem": "2.52.2",
+    "ws": "^8.18.0",
+    "zod": "^3.23.8"
+  },
+  "stations": {
+    "xmtp": {
+      "@xmtp/content-type-primitives": "^3.0.1",
+      "@xmtp/content-type-reaction": "^2.0.2",
+      "@xmtp/content-type-remote-attachment": "^2.0.4",
+      "@xmtp/content-type-reply": "^2.0.3",
+      "@xmtp/content-type-wallet-send-calls": "^2.0.0",
+      "@xmtp/node-bindings": "1.9.1",
+      "@xmtp/node-sdk": "^6.0.0",
+      "viem": "^2.52.2"
+    },
+    "telegram-bot": {},
+    "telegram": {
+      "@mtcute/bun": "0.30.1"
+    },
+    "discord-bot": {
+      "@discordjs/voice": "^0.19.2",
+      "discord.js": "^14.26.4",
+      "prism-media": "^1.3.5"
+    },
+    "whatsapp": {
+      "baileys": "7.0.0-rc14"
+    },
+    "webhook": {}
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Stage Labs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,193 +0,0 @@
-# Metro
-
-> **A live JSON stream of Telegram + Discord messages for your local Claude Code / Codex session.**
-
-Metro is a small daemon you launch from inside your agent. It connects to Discord and Telegram, emits each inbound as one JSON line on stdout (which Claude Code's `Monitor` consumes natively, and Codex picks up via an app-server WebSocket push), and exposes a tiny CLI — `metro reply`, `metro send`, `metro edit`, `metro react`, `metro download`, `metro fetch` — for posting back. Cross-agent: any agent can ping any other via `metro send metro://claude/<topic>` and the daemon re-emits it on the stream.
-
-```
-[Claude Code session]
-
-$ metro &                              # backgrounded
-$ Monitor( … metro's stdout … )
-
->>> {"kind":"inbound","station":"discord","line":"metro://discord/123…","messageId":"9876",
-     "text":"@bot we got a 5xx spike from /v1/sync. Look?",
-     "payload":{"channelId":"123…","guildId":"456…","content":"<@…> we got a 5xx spike…",
-                "mentions":{"users":["<bot-id>"],"roles":[],"everyone":false},…}}
-
-  [I'd run git log + read services/sync.ts, then…]
-  Bash: metro reply metro://discord/123… 9876 "three deploys in the last 24h…"
-```
-
-The agent owns its own streaming, tool calls, and reply timing. Metro is the wire.
-
----
-
-## Quickstart
-
-```bash
-npm install -g @stage-labs/metro@beta    # or: bun add -g @stage-labs/metro@beta
-
-metro setup discord <token>              # https://discord.com/developers/applications
-metro setup telegram <token>             # https://t.me/BotFather
-metro doctor                             # verify
-metro                                    # run the daemon
-```
-
-Requires **Node ≥ 22 or Bun ≥ 1.3**. Metro doesn't launch Claude or Codex — you do, and the agent launches metro. See [`docs/agents.md`](docs/agents.md).
-
-In **Discord**: DM the bot, or `@<bot>` in any channel. In **Telegram**: DM, or `@<bot>` in a forum supergroup. Every inbound becomes one JSON line on `metro`'s stdout.
-
----
-
-## Architecture
-
-```
-Discord gateway ──┐
-Telegram poller ──┤
-                  │
-                  ├─▶ metro daemon ───▶ stdout (JSON events; Claude Code's Monitor reads here)
-                  │                ───▶ codex-rc WebSocket (Codex turn/start; opt-in)
-                  │                ◀── IPC Unix socket  (metro send to agent lines)
-                  │
-agent CLI calls ──┴── REST → Discord / Telegram   (metro reply / send / edit / react / download / fetch)
-```
-
-- **Inversion of control.** The agent (Claude Code, Codex) launches `metro`, not the other way around. Metro never spawns an agent process.
-- **Single daemon per machine.** Lockfile at `$METRO_STATE_DIR/.tail-lock` enforces singleton.
-- **Codex push (opt-in).** Set `METRO_CODEX_RC=ws://127.0.0.1:8421` and metro pushes each event via JSON-RPC `turn/start` to the Codex app-server. Codex's TUI must be attached with `--remote` to the same URL.
-- **Cross-agent notification.** `metro send metro://claude/<topic>` (or `metro://codex/<topic>`) routes through the daemon's IPC socket; the daemon re-emits on its stdout (and pushes to codex-rc), so the peer agent sees it.
-
----
-
-## Stations
-
-Each endpoint is a **station** with declared capabilities:
-
-| Station    | Kind  | Modalities    | Features                                              | Config                                                      |
-|------------|-------|---------------|-------------------------------------------------------|-------------------------------------------------------------|
-| `discord`  | chat  | text + image  | reply, send, edit, react, download, fetch             | `DISCORD_BOT_TOKEN` + Message Content Intent                |
-| `telegram` | chat  | text + image  | reply, send, edit, react, download                    | `TELEGRAM_BOT_TOKEN`                                        |
-| `claude`   | agent | text          | notify                                                | watches metro stdout via Claude Code's `Monitor`            |
-| `codex`    | agent | text          | notify                                                | set `METRO_CODEX_RC=ws://…` to push                         |
-
-Run `metro stations` to see live config status (`✓` configured, `✗` not, `·` informational).
-
-Behaviors worth knowing:
-- **No streaming / no edit machinery in metro.** The agent runs the show; metro is one-shot REST.
-- **No link previews.** Outgoing messages set `link_preview_options.is_disabled` on Telegram and `SUPPRESS_EMBEDS` on Discord.
-- **Image attachments inbound** — `[image]` placeholders surface inline in `text`; the agent calls `metro download` to materialize them. 20 MB cap.
-- **Rich content outbound.** `metro send` / `reply` accept `--image=<path>` (repeatable: albums of up to 10), `--document=<path>` (repeatable), `--voice=<path>` (single voice message — Telegram renders the voice bubble), and `--buttons='[[{"text":"…","url":"…"}]]'` for inline URL-button keyboards. `metro edit` accepts `--buttons` (pass `'[]'` to clear). 20 MB / file. URL buttons only for now — no callback/interactive components.
-- **Telegram non-forum groups are skipped.** No thread boundary to scope on.
-
----
-
-## Lines
-
-Every conversational scope is identified by a **Line** — a URI in the form `metro://<station>/<path>`:
-
-```
-metro://discord/1234567890123456789
-metro://telegram/-1001234567890                 # main chat / DM
-metro://telegram/-1001234567890/42              # forum topic 42
-metro://claude/deploys                          # agent notification sink
-metro://codex/ci
-```
-
-Anyone can post to a line via [`metro send`](#cli) — daemon required only for agent lines. Full grammar in [`docs/uri-scheme.md`](docs/uri-scheme.md).
-
----
-
-## CLI
-
-```
-metro                                       Run the daemon (emits JSON events on stdout).
-metro setup [telegram|discord <token>]      Save token, or show status.
-metro setup clear [telegram|discord|all]    Remove tokens.
-metro doctor                                Health check.
-metro stations                              List stations + capabilities.
-metro lines                                 List recently-seen conversations.
-metro send <line> <text> [--image=…]… [--document=…]… [--voice=…] [--buttons=…]
-                                            Post a fresh message; --image/--document repeat for albums.
-metro reply <line> <message_id> <text> [--image|--document|--voice|--buttons]
-                                            Threaded reply (same flags as send).
-metro edit <line> <message_id> <text> [--buttons=<json>]
-                                            Edit a previously-sent message (text + URL-button keyboard).
-metro react <line> <message_id> <emoji>     Set or clear ('') a reaction.
-metro download <line> <message_id> [--out=<dir>]
-                                            Download image attachments to disk.
-metro fetch <line> [--limit=N]              Recent-message lookback (Discord only).
-metro history [--limit=N] [--line=…] [--station=…] [--kind=…] [--from=…] [--text=…] [--since=…]
-                                            Universal message log (every inbound + outbound), newest first.
-metro update                                Upgrade in place.
-```
-
-All commands accept `--json`. `reply` / `send` / `edit` read multi-line `<text>` from stdin if no positional is given.
-
-**State files** in `$METRO_STATE_DIR` (default `~/.cache/metro`):
-- `AGENTS.md` — agent skill copied from the package on every start (so the path is stable across upgrades)
-- `history.jsonl` — universal message log (one JSON object per line; append-only). Read with `metro history`. Each entry carries `from` and `to` as universal participant URIs (`metro://<station>/user/<id>`, `metro://claude/<topic>`, `metro://codex/<topic>`) plus a `fromName` display field. The dispatcher auto-detects the consuming agent for `to` on inbound (`$CLAUDECODE` → `metro://claude/agent`; `$METRO_CODEX_RC`/`$CODEX_HOME` → `metro://codex/agent`).
-- `bot-ids.json` — `{discord: "<botUserId>", telegram: "<botUserId>"}` written by the daemon on startup (cached for the few historical lookups that still need a bot identity).
-- `lines.json` — line → last-seen / name cache (read by `metro lines`)
-- `.tail-lock` — dispatcher pid
-- `metro.sock` — daemon IPC socket
-- `telegram-offset.json` — last processed update id
-
----
-
-## Configuration
-
-| Variable | Default | Description |
-|---|---|---|
-| `TELEGRAM_BOT_TOKEN`, `DISCORD_BOT_TOKEN` | — | Bot tokens. `metro setup` writes them here. |
-| `METRO_CODEX_RC` | — | Codex app-server URL (`ws://…`, `wss://…`, `unix:///…`). When set, the daemon pushes each event via JSON-RPC `turn/start`. |
-| `METRO_CONFIG_DIR` | `~/.config/metro` | Where the global `.env` lives. |
-| `METRO_STATE_DIR` | `~/.cache/metro` | Lockfile, line cache, IPC socket, telegram offset. |
-| `METRO_LOG_LEVEL` | `info` | `trace` / `debug` / `info` / `warn` / `error` / `fatal`. |
-
-Precedence: process env → `./.env` → `$METRO_CONFIG_DIR/.env`. Logs go to stderr.
-
----
-
-## Develop
-
-```bash
-git clone https://github.com/bonustrack/metro && cd metro
-bun install && bun run build
-bun link                                 # makes `metro` resolve to this checkout
-METRO_LOG_LEVEL=debug metro
-
-bun run typecheck                        # ts
-bun run lint                             # eslint
-```
-
-Source map:
-
-- [`src/cli/`](src/cli/) — `metro` binary entry ([`index.ts`](src/cli/index.ts)) + admin commands ([`config.ts`](src/cli/config.ts): setup/doctor/update) + shared CLI primitives ([`util.ts`](src/cli/util.ts)).
-- [`src/dispatcher.ts`](src/dispatcher.ts) — the daemon: starts each chat station, emits events on stdout, listens on the IPC socket, optionally pushes to codex-rc.
-- [`src/stations/`](src/stations/) — Line URI scheme + ChatStation interface + listing ([`index.ts`](src/stations/index.ts)), the two chat-station impls (`discord.ts`, `telegram.ts`), plus the Telegram markdown→HTML helper ([`telegram-md.ts`](src/stations/telegram-md.ts)). Agent stations have no impl — they're notification sinks expressed only as URI prefixes.
-- [`src/codex-rc.ts`](src/codex-rc.ts) — Codex app-server WebSocket push client.
-- [`src/ipc.ts`](src/ipc.ts) — Unix-socket IPC between the daemon and one-shot CLI commands.
-- [`src/cache.ts`](src/cache.ts) — in-memory line cache with debounced flush to `lines.json`.
-- [`docs/uri-scheme.md`](docs/uri-scheme.md) specs the Line format; [`docs/agents.md`](docs/agents.md) is the in-context skill for agents.
-
-CI runs typecheck + lint + build on every PR via [`.github/workflows/ci.yml`](.github/workflows/ci.yml).
-
----
-
-## Caveats
-
-- **No allowlist.** Anyone who can DM/`@`-mention your bot can produce events. Run against bots you own.
-- **Telegram bot privacy is on by default**, which can block `@`-mentions in groups. Disable via [@BotFather](https://t.me/BotFather) → Bot Settings → Group Privacy, then kick + re-invite.
-- **Telegram non-forum groups are skipped.** No thread boundary to scope on. DMs and forum topics work normally.
-- **Telegram fetch isn't supported** (bot API doesn't expose history); `metro fetch` returns `[]` on Telegram lines.
-
----
-
-## Uninstall
-
-```bash
-metro setup clear
-rm -rf ~/.cache/metro
-npm uninstall -g @stage-labs/metro
-```

package/dist/cache.js

@@ -1,75 +0,0 @@
-/** Per-machine caches: seen lines (lines.json) + bot ids (bot-ids.json). */
-import { existsSync, readFileSync, writeFileSync } 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';
-const cacheFile = join(STATE_DIR, 'lines.json');
-const FLUSH_DELAY_MS = 5_000;
-let cache = null;
-let dirty = false;
-let flushTimer = null;
-function read() {
-    if (cache)
-        return cache;
-    if (!existsSync(cacheFile))
-        return cache = {};
-    try {
-        cache = JSON.parse(readFileSync(cacheFile, 'utf8'));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err), path: cacheFile }, 'lines cache read failed; treating as empty');
-        cache = {};
-    }
-    return cache;
-}
-function flush() {
-    if (!dirty || !cache)
-        return;
-    try {
-        writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
-        dirty = false;
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err), path: cacheFile }, 'lines cache write failed');
-    }
-}
-process.on('exit', flush);
-export function noteSeen(line, name) {
-    const c = read();
-    const entry = c[line] ??= { createdAt: new Date().toISOString() };
-    entry.lastSeenAt = new Date().toISOString();
-    if (name && entry.name !== name)
-        entry.name = name;
-    dirty = true;
-    if (!flushTimer)
-        flushTimer = setTimeout(() => { flushTimer = null; flush(); }, FLUSH_DELAY_MS);
-}
-export const listLines = () => Object.entries(read()).map(([line, entry]) => ({ line: line, entry }));
-/** Bot identity cache: `{discord: "<userId>", telegram: "<userId>"}`. Daemon writes after getMe(). */
-const botIdsFile = join(STATE_DIR, 'bot-ids.json');
-const readBotIds = () => {
-    try {
-        return existsSync(botIdsFile) ? JSON.parse(readFileSync(botIdsFile, 'utf8')) : {};
-    }
-    catch {
-        return {};
-    }
-};
-export function saveBotId(station, id) {
-    const cur = readBotIds();
-    if (cur[station] === id)
-        return;
-    cur[station] = id;
-    try {
-        writeFileSync(botIdsFile, JSON.stringify(cur, null, 2));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'bot-ids cache write failed');
-    }
-}
-/** Resolve the bot's URI for a station. Returns `metro://<station>/bot/<id>` or the placeholder. */
-export function botLine(station) {
-    const id = readBotIds()[station];
-    return id ? Line.bot(station, id) : `metro://${station}/bot`;
-}