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

package/runtime/node_modules/@metro-labs/telegram/src/types.ts

@@ -1,48 +1,7 @@
-export interface TgMsg {
-  message_id: number;
-  date: number;
-  chat: { id: number; type: string; title?: string; first_name?: string };
-  from?: {
-    id: number;
-    username?: string;
-    first_name?: string;
-    is_bot?: boolean;
-  };
-  text?: string;
-  caption?: string;
-  message_thread_id?: number;
-  is_topic_message?: boolean;
-  photo?: { file_id: string; file_size?: number }[];
-  document?: { file_name?: string; file_id?: string; mime_type?: string };
-  voice?: { file_id?: string; duration?: number; mime_type?: string };
-  audio?: { file_id?: string; file_name?: string; mime_type?: string };
-  video?: { file_id?: string; file_name?: string; mime_type?: string };
-  animation?: { file_id?: string; file_name?: string; mime_type?: string };
-  sticker?: { file_id?: string; emoji?: string; set_name?: string };
-  location?: { latitude: number; longitude: number };
-  dice?: { emoji: string; value: number };
-}
-
-export interface TgReaction {
-  chat: { id: number; type: string };
-  message_id: number;
-  user?: {
-    id: number;
-    username?: string;
-    first_name?: string;
-    is_bot?: boolean;
-  };
-  date: number;
-  old_reaction: { type: string; emoji?: string }[];
-  new_reaction: { type: string; emoji?: string }[];
-}
-
-export interface TgReactionCount {
-  chat: { id: number; type: string };
-  message_id: number;
-  date: number;
-  reactions: {
-    type: { type: string; emoji?: string };
-    total_count: number;
-  }[];
+export interface UserAccount {
+  id: string;
+  session: string;
+  apiId?: number;
+  apiHash?: string;
+  owner?: string;
 }

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

@@ -1,3 +1 @@
-export { emit, respond, mintId } from '@metro-labs/mcp/stations/station-runtime';
-
-export const SELF_URI = process.env.METRO_SELF_URI ?? '';
+export { emit, mintId } from '@metro-labs/mcp/stations/station-runtime';

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

@@ -1,28 +1,25 @@
 {
-  "name": "@metro-labs/telegram-user",
+  "name": "@metro-labs/telegram-bot",
   "version": "0.1.0",
   "private": true,
   "type": "module",
   "exports": {
     ".": "./src/station.ts",
     "./train": "./src/index.ts",
-    "./login": "./src/login.ts"
+    "./verify": "./src/verify.ts"
   },
   "scripts": {
     "build": "tsc",
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*",
-    "@mtcute/bun": "0.30.1"
+    "@metro-labs/mcp": "workspace:*"
   },
   "devDependencies": {
     "@stage-labs/config": "0.1.0-beta.2",
-    "@types/qrcode-terminal": "^0.12.2",
     "eslint": "^10.3.0",
     "knip": "^6.15.0",
     "madge": "^8.0.0",
-    "qrcode-terminal": "^0.12.0",
     "typescript": "^5"
   }
 }

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

@@ -0,0 +1,120 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import {
+  makeAccountStore,
+  resolveAccountId,
+} from '@metro-labs/mcp/stations/account-store';
+import { Line } from '@metro-labs/mcp/lines';
+
+const ACCOUNTS_FILE =
+  process.env.TELEGRAM_BOT_ACCOUNTS_FILE ??
+  join(homedir(), '.metro', 'telegram-bot-accounts.json');
+
+export interface AccountConfig {
+  id: string;
+  token: string;
+  owner?: string;
+}
+
+export const { loadAccounts } = makeAccountStore<AccountConfig>({
+  prefix: 'telegram-bot',
+  file: ACCOUNTS_FILE,
+  allowlistEnv: ['TELEGRAM_BOT_ONLY_ACCOUNTS', 'TELEGRAM_BOT_ACCOUNTS'],
+  validate(raw, die) {
+    const seenId = new Set<string>();
+    const seenTok = new Set<string>();
+    for (const a of raw) {
+      if (!a.id) die('account missing id');
+      if (!a.token || typeof a.token !== 'string')
+        die(`account '${a.id}' missing token`);
+      if (seenId.has(a.id)) die(`duplicate account id '${a.id}'`);
+      if (seenTok.has(a.token))
+        die(
+          `account '${a.id}' reuses a token used by another account (409 on getUpdates)`,
+        );
+      seenId.add(a.id);
+      seenTok.add(a.token);
+    }
+  },
+});
+
+export interface Account {
+  cfg: AccountConfig;
+  api: string;
+  fileApi: string;
+  offset: number;
+}
+export const accounts = new Map<string, Account>();
+
+export async function tg<T>(
+  accountId: string,
+  method: string,
+  body: unknown,
+  timeoutMs = 30_000,
+): Promise<T> {
+  const acct = accounts.get(accountId);
+  if (!acct) throw new Error(`unknown account '${accountId}'`);
+  const res = await fetch(`${acct.api}/${method}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const json = (await res.json()) as {
+    ok: boolean;
+    description?: string;
+    result?: T;
+  };
+  if (!json.ok)
+    throw new Error(`telegram-bot ${method}: ${json.description ?? 'unknown'}`);
+  return json.result as T;
+}
+
+export async function tgForm<T>(
+  accountId: string,
+  method: string,
+  form: FormData,
+  timeoutMs = 60_000,
+): Promise<T> {
+  const acct = accounts.get(accountId);
+  if (!acct) throw new Error(`unknown account '${accountId}'`);
+  const res = await fetch(`${acct.api}/${method}`, {
+    method: 'POST',
+    body: form,
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const json = (await res.json()) as {
+    ok: boolean;
+    description?: string;
+    result?: T;
+  };
+  if (!json.ok)
+    throw new Error(`telegram-bot ${method}: ${json.description ?? 'unknown'}`);
+  return json.result as T;
+}
+
+export function accountFor(args: { account?: string; line?: string }): string {
+  return resolveAccountId(
+    accounts,
+    args,
+    (line) => Line.parseTelegram(line)?.accountId,
+  );
+}
+
+export function lineOf(
+  accountId: string,
+  chatId: number | string,
+  topicId?: number,
+): string {
+  const tail = topicId !== undefined ? `${chatId}/${topicId}` : `${chatId}`;
+  return `metro://telegram-bot/${accountId}/${tail}`;
+}
+
+export function targetOf(
+  line: string,
+  accountOverride?: string,
+): { accountId: string; chatId: number; topicId?: number } {
+  const parsed = Line.parseTelegram(line);
+  if (!parsed) throw new Error(`bad telegram-bot line: ${line}`);
+  return { ...parsed, accountId: accountOverride ?? parsed.accountId };
+}

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

@@ -0,0 +1,295 @@
+import { accountFor, accounts, tg, targetOf } from './accounts.js';
+import { respond } from './wire.js';
+import { errMsg } from '@metro-labs/mcp/log';
+import { normalizeTelegram } from '@metro-labs/mcp/stations/messaging-normalize';
+import {
+  adminMemberList,
+  inaccessibleMemberList,
+  type TgChatMember,
+} from './members.js';
+import {
+  makeStation,
+  type CallMsg,
+  type StationHandler,
+} from '@metro-labs/mcp/stations/station-runtime';
+import { mediaKindOf } from './attachments.js';
+import { assertContentLength } from '@metro-labs/mcp/stations/attachments';
+import {
+  emitOutbound,
+  finishSend,
+  media,
+  MEDIA_METHOD_FIELD,
+  sendDice,
+  sendLocation,
+  sendMedia,
+} from './media-actions.js';
+
+
+
+
+export type { CallMsg };
+
+const meCache = new Map<string, { id: number; username: string | null }>();
+async function getMe(
+  accountId: string,
+): Promise<{ id: number; username: string | null } | null> {
+  const cached = meCache.get(accountId);
+  if (cached) return cached;
+  try {
+    const me = await tg<{ id: number; username?: string }>(
+      accountId,
+      'getMe',
+      {},
+      10_000,
+    );
+    const v = { id: me.id, username: me.username ?? null };
+    meCache.set(accountId, v);
+    return v;
+  } catch {
+    return null;
+  }
+}
+
+async function listAccounts(id: string): Promise<void> {
+  const list = await Promise.all(
+    [...accounts.values()].map(async (a) => {
+      const me = await getMe(a.cfg.id);
+      const username = me?.username ?? null;
+      return {
+        id: a.cfg.id,
+        handle: username === null ? null : `@${username}`,
+        url: username === null ? null : `https://t.me/${username}`,
+        owner: a.cfg.owner ?? null,
+        botId: me?.id ?? null,
+        username,
+      };
+    }),
+  );
+  respond(id, { result: { accounts: list } });
+}
+
+interface SendArgs {
+  line: string;
+  text: string;
+  replyTo?: string;
+  parseMode?: string;
+  buttons?: { text: string; url: string }[][];
+  account?: string;
+  attachments?: {
+    kind?: string;
+    path?: string;
+    url?: string;
+    mime?: string;
+    name?: string;
+  }[];
+}
+
+
+type WireAttachment = NonNullable<SendArgs['attachments']>[number];
+
+const attachmentSrc = (att: WireAttachment): string | undefined =>
+  att.path ?? att.url;
+
+const attachmentKind = (att: WireAttachment): string =>
+  mediaKindOf(att.kind, att.mime, attachmentSrc(att) ?? att.name);
+
+async function sendOneAttachment(
+  a: SendArgs,
+  att: WireAttachment,
+  caption: string | undefined,
+): Promise<{ accountId: string; message_id: number; kind: string }> {
+  const kind = attachmentKind(att);
+  const mf = MEDIA_METHOD_FIELD[kind];
+  if (!mf) throw new Error(`telegram-bot cannot send a '${kind}' attachment`);
+  const sent = await sendMedia(mf.method, mf.field, {
+    line: a.line,
+    path: attachmentSrc(att),
+    caption,
+    replyTo: a.replyTo,
+    parseMode: a.parseMode,
+    account: a.account,
+    name: att.name,
+  });
+  return { ...sent, kind };
+}
+
+const captionLabel = (caption: string | undefined, kind: string): string =>
+  caption !== undefined && caption !== '' ? caption : `[${kind}]`;
+
+async function sendAttachments(id: string, a: SendArgs): Promise<void> {
+  const { line, text, replyTo, attachments = [] } = a;
+  let last: { accountId: string; message_id: number } | undefined;
+  const delivered: string[] = [];
+  for (let i = 0; i < attachments.length; i++) {
+    const att = attachments[i];
+    if (!att) continue;
+    const caption = i === 0 ? text : undefined;
+    const sent = await sendOneAttachment(a, att, caption);
+    last = sent;
+    delivered.push(sent.kind);
+    emitOutbound(
+      sent.accountId,
+      line,
+      String(sent.message_id),
+      captionLabel(caption, sent.kind),
+      replyTo,
+    );
+  }
+  if (!last) throw new Error('no attachments were sent');
+  respond(id, {
+    result: {
+      messageId: String(last.message_id),
+      account: last.accountId,
+      attachments: delivered,
+    },
+  });
+}
+
+async function send(id: string, args: Record<string, unknown>): Promise<void> {
+  const a = args as unknown as SendArgs;
+  if (a.attachments?.length) {
+    await sendAttachments(id, a);
+    return;
+  }
+  const { line, text, replyTo, parseMode, buttons, account } = a;
+  const { accountId, chatId, topicId } = targetOf(line, account);
+  const body: Record<string, unknown> = { chat_id: chatId, text };
+  if (topicId !== undefined) body.message_thread_id = topicId;
+  if (replyTo) body.reply_parameters = { message_id: Number(replyTo) };
+  if (parseMode) body.parse_mode = parseMode;
+  if (buttons) body.reply_markup = { inline_keyboard: buttons };
+  const sent = await tg<{ message_id: number }>(accountId, 'sendMessage', body);
+  finishSend(id, accountId, line, String(sent.message_id), text, replyTo);
+}
+
+async function react(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, emoji, account } = args as {
+    line: string;
+    messageId: string;
+    emoji: string;
+    account?: string;
+  };
+  const { accountId, chatId } = targetOf(line, account);
+  await tg(accountId, 'setMessageReaction', {
+    chat_id: chatId,
+    message_id: Number(messageId),
+    reaction: emoji ? [{ type: 'emoji', emoji }] : [],
+  });
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function edit(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, text, parseMode, account } = args as {
+    line: string;
+    messageId: string;
+    text: string;
+    parseMode?: string;
+    account?: string;
+  };
+  const { accountId, chatId } = targetOf(line, account);
+  await tg(accountId, 'editMessageText', {
+    chat_id: chatId,
+    message_id: Number(messageId),
+    text,
+    parse_mode: parseMode,
+  });
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function remove(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, account } = args as {
+    line: string;
+    messageId: string;
+    account?: string;
+  };
+  const { accountId, chatId } = targetOf(line, account);
+  await tg(accountId, 'deleteMessage', {
+    chat_id: chatId,
+    message_id: Number(messageId),
+  });
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+
+
+async function download(id: string, args: Record<string, unknown>): Promise<void> {
+  const {
+    fileId,
+    outDir = '/tmp',
+    account,
+  } = args as { fileId: string; outDir?: string; account?: string };
+  const accountId = accountFor({ account });
+  const acct = accounts.get(accountId);
+  if (!acct) throw new Error(`unknown account '${accountId}'`);
+  const meta = await tg<{ file_path: string }>(accountId, 'getFile', {
+    file_id: fileId,
+  });
+  const res = await fetch(`${acct.fileApi}/${meta.file_path}`, {
+    signal: AbortSignal.timeout(60_000),
+  });
+  if (!res.ok) throw new Error(`telegram-bot download ${res.status}`);
+  assertContentLength(res.headers.get('content-length'));
+  const data = await res.arrayBuffer();
+  const filename = meta.file_path.split('/').pop() ?? `${fileId}.bin`;
+  const path = `${outDir}/${Date.now()}-${filename}`;
+  await Bun.write(path, data);
+  respond(id, {
+    result: { path, fileSize: data.byteLength, account: accountId },
+  });
+}
+
+async function listMembers(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, chatId } = targetOf(line, account);
+  let admins: TgChatMember[];
+  try {
+    admins = await tg<TgChatMember[]>(accountId, 'getChatAdministrators', {
+      chat_id: chatId,
+    });
+  } catch (e) {
+    respond(id, { result: inaccessibleMemberList(errMsg(e)) });
+    return;
+  }
+  let total: number | null = null;
+  try {
+    total = await tg<number>(accountId, 'getChatMemberCount', {
+      chat_id: chatId,
+    });
+  } catch {
+    total = null;
+  }
+  respond(id, { result: adminMemberList(admins, total) });
+}
+
+const HANDLERS: Record<string, StationHandler> = {
+  accounts: (id) => listAccounts(id),
+  send,
+  react,
+  edit,
+  delete: remove,
+  listMembers,
+  send_photo: (id, args) =>
+    media(id, 'sendPhoto', 'photo', ((args.caption as string) ?? '') + ' [image]', args),
+  send_document: (id, args) =>
+    media(id, 'sendDocument', 'document', ((args.caption as string) ?? '') + ' [file]', args),
+  send_voice: (id, args) => media(id, 'sendVoice', 'voice', '[voice]', args),
+  send_sticker: (id, args) => media(id, 'sendSticker', 'sticker', '[sticker]', args),
+  send_dice: sendDice,
+  send_location: sendLocation,
+  download,
+};
+
+export const handleCall = makeStation({
+  handlers: HANDLERS,
+  normalize: normalizeTelegram,
+  preDispatch: (id, action) => {
+    if (action === 'read') {
+      respond(id, { error: "unsupported verb 'read' on telegram-bot" });
+      return true;
+    }
+    return false;
+  },
+});

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

@@ -0,0 +1,128 @@
+import {
+  saveBufferToCache,
+  assertContentLength,
+} from '@metro-labs/mcp/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
+import { tg, accounts } from './accounts.js';
+import type { TgMsg } from './types.js';
+
+export type { SavedAttachment };
+
+function isOggRef(mime: string | undefined, ref: string | undefined): boolean {
+  const ext = ref?.split('?')[0]?.split('.').pop()?.toLowerCase();
+  return mime === 'audio/ogg' || ext === 'ogg' || ext === 'oga';
+}
+
+function isVoiceRef(
+  kind: string | undefined,
+  mime: string | undefined,
+  ref: string | undefined,
+): boolean {
+  const isOgg = isOggRef(mime, ref);
+  if (kind === 'voice') return true;
+  if (kind === 'audio') return isOgg;
+  return !kind && isOgg;
+}
+
+export function mediaKindOf(
+  kind: string | undefined,
+  mime: string | undefined,
+  ref: string | undefined,
+): 'image' | 'voice' | 'audio' | 'video' | 'document' {
+  const m = mime ?? '';
+  if (kind === 'image' || m.startsWith('image/')) return 'image';
+  if (isVoiceRef(kind, mime, ref)) return 'voice';
+  if (kind === 'video' || m.startsWith('video/')) return 'video';
+  if (kind === 'audio' || m.startsWith('audio/')) return 'audio';
+  return 'document';
+}
+
+export interface TgMediaRef {
+  fileId: string;
+  name?: string;
+  mime?: string;
+}
+
+const MEDIA_EXTRACTORS: ((m: TgMsg) => TgMediaRef | null)[] = [
+  (m) => {
+    const largest = m.photo?.[m.photo.length - 1];
+    return largest ? { fileId: largest.file_id, mime: 'image/jpeg' } : null;
+  },
+  (m) =>
+    m.document?.file_id
+      ? {
+          fileId: m.document.file_id,
+          name: m.document.file_name,
+          mime: m.document.mime_type,
+        }
+      : null,
+  (m) =>
+    m.video?.file_id
+      ? {
+          fileId: m.video.file_id,
+          name: m.video.file_name,
+          mime: m.video.mime_type ?? 'video/mp4',
+        }
+      : null,
+  (m) =>
+    m.animation?.file_id
+      ? {
+          fileId: m.animation.file_id,
+          name: m.animation.file_name,
+          mime: m.animation.mime_type,
+        }
+      : null,
+  (m) =>
+    m.audio?.file_id
+      ? {
+          fileId: m.audio.file_id,
+          name: m.audio.file_name,
+          mime: m.audio.mime_type,
+        }
+      : null,
+  (m) =>
+    m.voice?.file_id
+      ? { fileId: m.voice.file_id, mime: m.voice.mime_type ?? 'audio/ogg' }
+      : null,
+  (m) =>
+    m.sticker?.file_id
+      ? { fileId: m.sticker.file_id, mime: 'image/webp' }
+      : null,
+];
+
+export function mediaRefOf(m: TgMsg): TgMediaRef | null {
+  for (const extract of MEDIA_EXTRACTORS) {
+    const ref = extract(m);
+    if (ref) return ref;
+  }
+  return null;
+}
+
+export async function saveTelegramMedia(
+  accountId: string,
+  ref: TgMediaRef,
+  messageId: string,
+  index = 0,
+): Promise<SavedAttachment> {
+  const file = await tg<{ file_path?: string }>(accountId, 'getFile', {
+    file_id: ref.fileId,
+  });
+  if (!file.file_path)
+    throw new Error(`telegram-bot getFile returned no file_path for ${ref.fileId}`);
+  const acct = accounts.get(accountId);
+  if (!acct) throw new Error(`unknown account '${accountId}'`);
+  const res = await fetch(`${acct.fileApi}/${file.file_path}`, {
+    signal: AbortSignal.timeout(60_000),
+  });
+  if (!res.ok)
+    throw new Error(
+      `telegram-bot file download ${res.status} for ${file.file_path}`,
+    );
+  assertContentLength(res.headers.get('content-length'));
+  const data = new Uint8Array(await res.arrayBuffer());
+  const saved = await saveBufferToCache(data, messageId, index, {
+    mime: ref.mime,
+    name: ref.name ?? file.file_path,
+  });
+  return { ...saved, name: ref.name };
+}