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

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

@@ -0,0 +1,212 @@
+import type { StationTool } from '@metro-labs/mcp/stations/types';
+import {
+  str,
+  createChannel,
+  setChannelMetadata,
+  xmtpSendAttachments,
+} from './tools-handlers.js';
+
+export { xmtpSendAttachments };
+
+const lineProp = {
+  type: 'string',
+  description:
+    'The metro:// line (from the inbound <channel> tag). The station is derived from it.',
+} as const;
+
+export const XMTP_TOOLS: StationTool[] = [
+  {
+    name: 'create_channel',
+    description:
+      'Create a new XMTP group conversation (channel). Args: addresses (required, array of ' +
+      'Ethereum 0x addresses to add as members), name (required, the group name), labels? ' +
+      '(optional string[] status labels applied after creation), account? ' +
+      '(defaults to your only XMTP account). Calls the daemon xmtp `newGroup`, then ' +
+      '`updateChannelMeta` if labels ' +
+      'are given. Returns the new metro:// line and convId. This is an xmtp-only operation. ' +
+      'NOTE: there is no add-members verb on the daemon, so members must be supplied at ' +
+      'creation time.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        addresses: {
+          type: 'array',
+          description: 'Ethereum 0x addresses to add as group members.',
+          items: { type: 'string' },
+        },
+        name: { type: 'string', description: 'The group/channel name.' },
+        labels: {
+          type: 'array',
+          description: 'Optional status labels to apply after creation.',
+          items: { type: 'string' },
+        },
+        account: {
+          type: 'string',
+          description:
+            'XMTP account to create under. Omit when you have only one.',
+        },
+      },
+      required: ['addresses', 'name'],
+    },
+    handle: (a, ctx) => createChannel(a, ctx),
+  },
+  {
+    name: 'ask',
+    description:
+      'Ask a question as a poll in an XMTP conversation (mirrors Claude AskUserQuestion). ' +
+      'Single-question form: question (required), options? (string[]), header?, multiSelect?, ' +
+      'open? (true => free-text answer, options optional). Multi-question form: questions ' +
+      '(array of {question, options?, header?, multiSelect?, open?}). Args: line (required) + ' +
+      'the above. xmtp-only (the daemon `ask` action). Returns the poll messageId + pollId.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: lineProp,
+        question: {
+          type: 'string',
+          description: 'The question text (single-question form).',
+        },
+        options: {
+          type: 'array',
+          description: 'Answer options for a single question.',
+          items: { type: 'string' },
+        },
+        header: {
+          type: 'string',
+          description: 'Optional header/title for the poll.',
+        },
+        multiSelect: {
+          type: 'boolean',
+          description: 'Allow selecting multiple options.',
+        },
+        open: {
+          type: 'boolean',
+          description: 'Free-text answer (options optional).',
+        },
+        questions: {
+          type: 'array',
+          description:
+            'Multiple questions (multi-question form). Each is {question, options?, header?, multiSelect?, open?}.',
+          items: { type: 'object' },
+        },
+      },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('ask requires `line`');
+      const args: Record<string, unknown> = { line };
+      for (const k of [
+        'question',
+        'options',
+        'header',
+        'multiSelect',
+        'open',
+        'questions',
+      ] as const) {
+        if (a[k] !== undefined) args[k] = a[k];
+      }
+      if (a.question === undefined && a.questions === undefined) {
+        return ctx.err(
+          'ask requires `question` (single) or `questions` (multi)',
+        );
+      }
+      return ctx.okJson(await ctx.call('ask', args));
+    },
+  },
+  {
+    name: 'dm',
+    description:
+      'Open (or reuse) a 1:1 XMTP DM with an Ethereum address. Args: address (required, 0x...), ' +
+      'account? (defaults to your only XMTP account). Returns the new metro:// line and ' +
+      'convId. xmtp-only ' +
+      '(daemon `newDm`). Use this instead of create_channel when there is a single recipient.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        address: {
+          type: 'string',
+          description: 'Recipient Ethereum 0x address.',
+        },
+        account: {
+          type: 'string',
+          description: 'XMTP account to DM from. Omit when you have only one.',
+        },
+      },
+      required: ['address'],
+    },
+    async handle(a, ctx) {
+      const address = str(a.address);
+      if (!address) return ctx.err('dm requires `address`');
+      const dmArgs: Record<string, unknown> = { address };
+      if (a.account) dmArgs.account = str(a.account);
+      return ctx.okJson(await ctx.call('newDm', dmArgs));
+    },
+  },
+  {
+    name: 'group_info',
+    description:
+      "Read an XMTP channel's current metadata + membership. Args: line (required). Returns " +
+      '{line, id, account, version (dm|group), name, memberCount, labels, github, preview, ' +
+      'members:[{inboxId, address}]}. xmtp-only (daemon `groupInfo`). Use before ' +
+      'set_channel_metadata/add_members to see current state.',
+    inputSchema: {
+      type: 'object',
+      properties: { line: lineProp },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('group_info requires `line`');
+      return ctx.okJson(await ctx.call('groupInfo', { line }));
+    },
+  },
+  {
+    name: 'close_channel',
+    description:
+      'Archive/close an XMTP group (removes members). Args: line (required). xmtp-only ' +
+      '(daemon `closeGroup`). Irreversible-ish: members are removed from the group.',
+    inputSchema: {
+      type: 'object',
+      properties: { line: lineProp },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('close_channel requires `line`');
+      return ctx.okJson(await ctx.call('closeGroup', { line }));
+    },
+  },
+  {
+    name: 'set_channel_metadata',
+    description:
+      "Update an existing channel's metadata. Args: line (required, the metro:// line), and " +
+      'any of labels? (string[]), github? (url), preview? (url), name? (string). All provided ' +
+      'fields are applied together in one atomic updateChannelMeta daemon call (a single ' +
+      'appData merge plus name update). xmtp-only ' +
+      '(channel metadata lives on xmtp groups). Returns the updated channel info.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: lineProp,
+        labels: {
+          type: 'array',
+          description: 'Status labels to set.',
+          items: { type: 'string' },
+        },
+        github: {
+          type: 'string',
+          description: 'Linked GitHub URL ("" to clear).',
+        },
+        preview: {
+          type: 'string',
+          description: 'Linked preview URL ("" to clear).',
+        },
+        name: { type: 'string', description: 'New channel name.' },
+      },
+      required: ['line'],
+    },
+    handle: (a, ctx) => setChannelMetadata(a, ctx),
+  },
+];
+

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,39 @@
+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)',
+  );
+}

package/runtime/runtime.json

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

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,78 +0,0 @@
-# Metro
-
-Chat with your Claude Code or Codex agent over Telegram and Discord.
-
-## Quickstart
-
-In your shell:
-
-```bash
-npm install -g @stage-labs/metro@beta    # or: bun add -g @stage-labs/metro@beta
-
-metro setup telegram <token>    # https://t.me/BotFather
-metro setup discord <token>     # https://discord.com/developers/applications
-
-metro setup skill                        # writes SKILL.md so Claude Code + Codex auto-onboard
-metro doctor                             # verify
-```
-
-> **Discord setup:** toggle **Message Content Intent** in Developer Portal → Bot → Privileged Gateway Intents.
-
-### Run with Claude Code
-
-```bash
-claude
-> Run metro in the background.
-```
-
-Then DM your bot. The bundled skill auto-triggers — the agent launches metro via Bash + Monitor, watches stdout, and replies.
-
-### Run with Codex
-
-Codex's `unified_exec` is poll-only ([#4751](https://github.com/openai/codex/issues/4751)) — there's no Monitor equivalent. Metro instead pushes each inbound into the agent's history via JSON-RPC. Two terminals plus a prompt — the TUI's `--remote` flag only accepts `ws://`, so daemon and TUI share one URL:
-
-```bash
-# Terminal 1 — daemon (must be running first)
-codex app-server --listen ws://127.0.0.1:8421
-
-# Terminal 2 — TUI attached to the daemon
-codex --remote ws://127.0.0.1:8421
-> Run metro in the background.
-```
-
-The agent launches `metro` (with `METRO_CODEX_RC=ws://127.0.0.1:8421` set) via its shell tool. Metro connects to the daemon and pushes each inbound as a `turn/start` on the active thread — the agent in terminal 2 reacts on its next turn. `codex remote-control` is stdio-only (no listener), so don't use it for this flow.
-
-Bare `codex` (no `--remote`) can't work with metro — the agent has no daemon to push to. The TUI must be attached to a running app-server.
-
-`METRO_CODEX_RC` accepts `ws://host:port` (required for use with the codex TUI) or `unix:///abs/path` (headless only — the daemon supports UDS but the TUI doesn't).
-
-## Config
-
-| Variable | Default | Description |
-|---|---|---|
-| `TELEGRAM_BOT_TOKEN`, `DISCORD_BOT_TOKEN` | — | Bot tokens. `metro setup` writes them here. |
-| `METRO_CONFIG_DIR` | `~/.config/metro` | Where the global `.env` lives. |
-| `METRO_STATE_DIR` | `~/.cache/metro` | Lockfile, attachment cache, default download dir. |
-| `METRO_LOG_LEVEL` | `info` | `trace` / `debug` / `info` / `warn` / `error` / `fatal`. |
-| `METRO_CODEX_RC` | — | Codex app-server URL (e.g. `ws://127.0.0.1:8421`). When set, metro pushes each inbound into the agent's history via JSON-RPC `turn/start` — the Codex equivalent of Claude Code's Monitor. Accepts `ws://host:port` (required for use with the codex TUI) or `unix:///abs/path` (headless only). See [Codex setup](#codex-setup). |
-
-Token precedence: process env → `./.env` → `$METRO_CONFIG_DIR/.env`. Logs to stderr.
-
-## Reference
-
-- `metro --help` — command surface
-- `metro doctor` — health check
-- [SKILL.md](skills/metro/SKILL.md) — agent-facing flow
-
-## Uninstall
-
-```bash
-metro setup clear; metro setup skill --clear
-rm -rf ~/.cache/metro/
-npm uninstall -g @stage-labs/metro
-```
-
-## Caveats
-
-- **No allowlist.** Anyone who can DM your bot or @-mention it can talk to your session. Run against bots you own.
-- **Latency.** Inbounds surface at the next agent decision boundary — sub-second on Claude Code, longer on Codex turns.

package/dist/channels/discord.js

@@ -1,148 +0,0 @@
-import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
-import { errMsg, log } from '../log.js';
-// Receive path: discord.js gateway, used by tail.ts only.
-// Send path: raw REST against discord.com/api — no gateway login required,
-// so cli.ts subcommands stay one-shot and fast.
-const API_BASE = 'https://discord.com/api/v10';
-function 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) {
-    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.ok) {
-        const text = await res.text().catch(() => '');
-        throw new Error(`discord ${method} ${path}: ${res.status} ${text}`);
-    }
-    // 204 No Content for typing/reactions/clear.
-    if (res.status === 204)
-        return undefined;
-    return (await res.json());
-}
-// ---------- Receive path (gateway, discord.js) -----------------------------
-let client = null;
-function getClient() {
-    if (client)
-        return client;
-    client = new Client({
-        intents: [
-            GatewayIntentBits.DirectMessages,
-            GatewayIntentBits.Guilds,
-            GatewayIntentBits.GuildMessages,
-            GatewayIntentBits.MessageContent,
-        ],
-        // DM channels arrive partial; without this messageCreate never fires.
-        partials: [Partials.Channel],
-    });
-    return client;
-}
-let onInboundHandler = () => { };
-export function onInbound(handler) {
-    onInboundHandler = handler;
-}
-export async function shutdownGateway() {
-    if (!client)
-        return;
-    await client.destroy();
-    client = null;
-}
-export async function startGateway() {
-    const c = getClient();
-    c.on(Events.MessageCreate, m => {
-        if (m.author.bot)
-            return;
-        // Guild messages: only forward when the bot is mentioned. DMs always pass.
-        // The bot's own @-mention is preserved in `m.content` — stripping it would
-        // lose mid-sentence position ("Wdyt @Metro is this good?" → "Wdyt is this
-        // good?") and silently drop bare-mention pings. The agent recognizes
-        // `<@bot_id>` and acts on the request as a whole.
-        if (m.guildId && c.user && !m.mentions.has(c.user.id))
-            return;
-        const tags = [...m.attachments.values()]
-            .map(a => {
-            if (a.contentType?.startsWith('image/'))
-                return '[image]';
-            if (a.contentType?.startsWith('audio/'))
-                return `[audio: ${a.name}]`;
-            return `[file: ${a.name}]`;
-        })
-            .join(' ');
-        const text = [m.content, tags].filter(Boolean).join(' ').trim();
-        if (!text)
-            return;
-        onInboundHandler({ channel_id: m.channelId, message_id: m.id, text });
-    });
-    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()));
-}
-export async function getMe() {
-    const me = await rest('GET', '/users/@me');
-    return { username: me.username };
-}
-export async function sendMessage(channelId, text) {
-    const sent = await rest('POST', `/channels/${channelId}/messages`, { content: text });
-    return sent.id;
-}
-export async function replyToMessage(channelId, messageId, text) {
-    const sent = await rest('POST', `/channels/${channelId}/messages`, {
-        content: text,
-        message_reference: { message_id: messageId, fail_if_not_exists: false },
-    });
-    return sent.id;
-}
-export async function editMessage(channelId, messageId, text) {
-    const sent = await rest('PATCH', `/channels/${channelId}/messages/${messageId}`, { content: text });
-    return sent.id;
-}
-export async function sendTyping(channelId) {
-    await rest('POST', `/channels/${channelId}/typing`);
-}
-export async function setReaction(channelId, messageId, emoji) {
-    if (emoji) {
-        await rest('PUT', `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`);
-        return;
-    }
-    // Clear only the bot's own reactions (matches Telegram's clear semantics).
-    const msg = await rest('GET', `/channels/${channelId}/messages/${messageId}`);
-    for (const r of msg.reactions ?? []) {
-        if (!r.me || !r.emoji.name)
-            continue;
-        await rest('DELETE', `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(r.emoji.name)}/@me`);
-    }
-}
-export async function fetchAttachments(channelId, messageId) {
-    const msg = await rest('GET', `/channels/${channelId}/messages/${messageId}`);
-    const out = [];
-    for (const a of msg.attachments) {
-        if (!a.content_type?.startsWith('image/'))
-            continue;
-        const res = await fetch(a.url, { signal: AbortSignal.timeout(30_000) });
-        if (!res.ok)
-            throw new Error(`discord: download ${a.url}: ${res.status}`);
-        out.push({ data: Buffer.from(await res.arrayBuffer()).toString('base64'), mime: a.content_type });
-    }
-    return out;
-}
-export async function fetchRecentMessages(channelId, limit) {
-    const n = Math.min(Math.max(limit, 1), 100);
-    const msgs = await rest('GET', `/channels/${channelId}/messages?limit=${n}`);
-    // Discord returns newest-first; reverse for chronological.
-    return [...msgs].reverse().map(m => ({
-        message_id: m.id,
-        author: m.author.username,
-        text: m.content,
-        timestamp: m.timestamp,
-    }));
-}