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

package/runtime/node_modules/@metro-labs/telegram/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 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 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" });
+      return true;
+    }
+    return false;
+  },
+});

package/runtime/node_modules/@metro-labs/telegram/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 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 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 };
+}

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

@@ -0,0 +1,172 @@
+import { errMsg } from '@metro-labs/mcp/log';
+import { accounts, lineOf } from './accounts.js';
+import { mintId, SELF_URI } from './wire.js';
+import { mediaRefOf, saveTelegramMedia } from './attachments.js';
+import type { TgMsg, TgReaction, TgReactionCount } from './types.js';
+
+export type { TgMsg, TgReaction, TgReactionCount };
+
+function lineForMsg(
+  accountId: string,
+  m: TgMsg,
+): { line: string; topicId?: number } {
+  const topicId = m.is_topic_message ? m.message_thread_id : undefined;
+  return { line: lineOf(accountId, m.chat.id, topicId), topicId };
+}
+
+function stickerTag(s: NonNullable<TgMsg['sticker']>): string {
+  const set = s.set_name ? ` · ${s.set_name}` : '';
+  return `[sticker${s.emoji ? ` ${s.emoji}` : ''}${set}]`;
+}
+
+const TAG_EXTRACTORS: ((m: TgMsg) => string | null)[] = [
+  (m) => (m.photo?.length ? '[image]' : null),
+  (m) => (m.voice ? '[voice]' : null),
+  (m) => (m.audio ? `[audio: ${m.audio.file_name ?? 'audio'}]` : null),
+  (m) => (m.video ? `[video: ${m.video.file_name ?? 'video'}]` : null),
+  (m) => (m.animation ? `[gif: ${m.animation.file_name ?? 'gif'}]` : null),
+  (m) => (m.sticker ? stickerTag(m.sticker) : null),
+  (m) =>
+    m.document && !m.animation
+      ? `[file: ${m.document.file_name ?? 'doc'}]`
+      : null,
+  (m) =>
+    m.location
+      ? `[location: ${m.location.latitude}, ${m.location.longitude}]`
+      : null,
+  (m) => (m.dice ? `[dice ${m.dice.emoji} = ${m.dice.value}]` : null),
+];
+
+function projectText(m: TgMsg): string {
+  const tags = TAG_EXTRACTORS.map((f) => f(m)).filter(
+    (t): t is string => t !== null,
+  );
+  return [m.text ?? m.caption, ...tags].filter(Boolean).join(' ');
+}
+
+export function envelope(accountId: string, m: TgMsg): Record<string, unknown> {
+  const { line } = lineForMsg(accountId, m);
+  return {
+    kind: 'inbound',
+    id: mintId(),
+    ts: new Date(m.date * 1000).toISOString(),
+    station: 'telegram',
+    line,
+    line_name: m.chat.title ?? m.chat.first_name ?? undefined,
+    from: `metro://telegram/${accountId}/user/${m.from?.id ?? 'unknown'}`,
+    from_name: m.from?.username ? `@${m.from.username}` : m.from?.first_name,
+    from_display_name: m.from?.first_name,
+    message_id: String(m.message_id),
+    text: projectText(m),
+    payload: m,
+    is_private: m.chat.type === 'private',
+  };
+}
+
+export function reactionEnvelope(
+  accountId: string,
+  r: TgReaction,
+): Record<string, unknown> | null {
+  if (r.user?.is_bot) return null;
+  const newEmojis = r.new_reaction
+    .filter((x) => x.type === 'emoji')
+    .map((x) => x.emoji ?? '');
+  const oldEmojis = r.old_reaction
+    .filter((x) => x.type === 'emoji')
+    .map((x) => x.emoji ?? '');
+  const added = newEmojis.filter((e) => !oldEmojis.includes(e));
+  if (!added.length) return null;
+  return {
+    kind: 'react',
+    id: mintId(),
+    ts: new Date(r.date * 1000).toISOString(),
+    station: 'telegram',
+    line: lineOf(accountId, r.chat.id),
+    from: `metro://telegram/${accountId}/user/${r.user?.id ?? 'unknown'}`,
+    from_name: r.user?.username ? `@${r.user.username}` : r.user?.first_name,
+    from_display_name: r.user?.first_name,
+    message_id: String(r.message_id),
+    emoji: added[0],
+    event: { type: 'react', emoji: added[0], targetId: String(r.message_id) },
+    is_private: r.chat.type === 'private',
+    payload: r,
+  };
+}
+
+export function reactionCountEnvelope(
+  accountId: string,
+  rc: TgReactionCount,
+): Record<string, unknown> | null {
+  const emojiReactions = rc.reactions.filter(
+    (r) => r.type.type === 'emoji' && r.type.emoji,
+  );
+  if (!emojiReactions.length) return null;
+  const top = emojiReactions.reduce((a, b) =>
+    b.total_count > a.total_count ? b : a,
+  );
+  const emoji = top.type.emoji ?? '';
+  if (!emoji) return null;
+  return {
+    kind: 'react',
+    id: mintId(),
+    ts: new Date(rc.date * 1000).toISOString(),
+    station: 'telegram',
+    line: lineOf(accountId, rc.chat.id),
+    from: `metro://telegram/${accountId}/user/unknown`,
+    message_id: String(rc.message_id),
+    emoji,
+    event: { type: 'react', emoji, targetId: String(rc.message_id) },
+    is_private: rc.chat.type === 'private',
+    payload: rc,
+  };
+}
+
+export function emitInbound(
+  emit: (e: unknown) => void,
+  accountId: string,
+  e: Record<string, unknown>,
+): void {
+  const owner = accounts.get(accountId)?.cfg.owner;
+  const payload = {
+    ...(e.payload as Record<string, unknown> | undefined),
+    account: accountId,
+  };
+  emit({ ...e, ...(owner ? { to: owner } : {}), account: accountId, payload });
+}
+
+export function saveMediaAndEmit(
+  emit: (e: unknown) => void,
+  accountId: string,
+  m: TgMsg,
+  sourceEnvId: string,
+): void {
+  const ref = mediaRefOf(m);
+  if (!ref) return;
+  const line = lineForMsg(accountId, m).line;
+  void saveTelegramMedia(accountId, ref, String(m.message_id), 0)
+    .then((saved) => {
+      emitInbound(emit, accountId, {
+        kind: 'inbound',
+        id: mintId(),
+        ts: new Date().toISOString(),
+        station: 'telegram',
+        line,
+        from: SELF_URI || `metro://telegram/${accountId}/self`,
+        text: `📎 saved: ${saved.path}`,
+        payload: {
+          contentType: 'attachmentSaved',
+          attachmentFor: sourceEnvId,
+          index: 0,
+          attachmentPath: saved.path,
+          localPath: saved.path,
+          mime: saved.mime,
+          name: saved.name,
+        },
+      });
+    })
+    .catch((err: unknown) =>
+      process.stderr.write(
+        `telegram media save failed: ${errMsg(err)}\n`,
+      ),
+    );
+}

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

@@ -0,0 +1,103 @@
+import { errMsg } from '@metro-labs/mcp/log';
+import { accounts, loadAccounts, tg, type Account } from './accounts.js';
+import { emit } from './wire.js';
+import {
+  emitInbound,
+  envelope,
+  reactionCountEnvelope,
+  reactionEnvelope,
+  saveMediaAndEmit,
+  type TgMsg,
+  type TgReaction,
+  type TgReactionCount,
+} from './format.js';
+import { readCalls } from '@metro-labs/mcp/trains/protocol';
+import { handleCall } from './actions.js';
+
+readCalls('telegram', handleCall);
+
+interface Update {
+  update_id: number;
+  message?: TgMsg;
+  message_reaction?: TgReaction;
+  message_reaction_count?: TgReactionCount;
+}
+
+function handleUpdate(id: string, u: Update): void {
+  if (u.message && !u.message.from?.is_bot) {
+    const env = envelope(id, u.message);
+    emitInbound(emit, id, env);
+    saveMediaAndEmit(emit, id, u.message, env.id as string);
+  }
+  if (u.message_reaction) {
+    const env = reactionEnvelope(id, u.message_reaction);
+    if (env) emitInbound(emit, id, env);
+  }
+  if (u.message_reaction_count) {
+    const env = reactionCountEnvelope(id, u.message_reaction_count);
+    if (env) emitInbound(emit, id, env);
+  }
+}
+
+async function runAccount(acct: Account): Promise<void> {
+  const { id } = acct.cfg;
+  try {
+    await tg(id, 'deleteWebhook', { drop_pending_updates: false });
+  } catch (err) {
+    process.stderr.write(
+      `telegram[${id}] deleteWebhook: ${errMsg(err)}\n`,
+    );
+  }
+
+  for (;;) {
+    try {
+      const updates = await tg<Update[]>(
+        id,
+        'getUpdates',
+        {
+          offset: acct.offset,
+          timeout: 25,
+          allowed_updates: [
+            'message',
+            'message_reaction',
+            'message_reaction_count',
+          ],
+        },
+        60_000,
+      );
+      for (const u of updates) {
+        acct.offset = u.update_id + 1;
+        handleUpdate(id, u);
+      }
+    } catch (err) {
+      process.stderr.write(
+        `telegram[${id}] poll error: ${errMsg(err)}\n`,
+      );
+      await new Promise((r) => setTimeout(r, 2_000));
+    }
+  }
+}
+
+const cfgs = loadAccounts();
+for (const cfg of cfgs) {
+  accounts.set(cfg.id, {
+    cfg,
+    api: `https://api.telegram.org/bot${cfg.token}`,
+    fileApi: `https://api.telegram.org/file/bot${cfg.token}`,
+    offset: 0,
+  });
+}
+if (accounts.size === 0) {
+  process.stderr.write('telegram: no accounts booted, exiting\n');
+  process.exit(2);
+}
+process.stderr.write(
+  `telegram train ready (multi) — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
+);
+
+for (const acct of accounts.values())
+  runAccount(acct).catch((err: unknown) => {
+    process.stderr.write(
+      `telegram[${acct.cfg.id}] account loop failed: ${errMsg(err)}\n`,
+    );
+  });