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

package/runtime/node_modules/@metro-labs/telegram-bot/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-bot',
+    line,
+    line_name: m.chat.title ?? m.chat.first_name ?? undefined,
+    from: `metro://telegram-bot/${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-bot',
+    line: lineOf(accountId, r.chat.id),
+    from: `metro://telegram-bot/${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-bot',
+    line: lineOf(accountId, rc.chat.id),
+    from: `metro://telegram-bot/${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-bot',
+        line,
+        from: SELF_URI || `metro://telegram-bot/${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-bot media save failed: ${errMsg(err)}\n`,
+      ),
+    );
+}

package/runtime/node_modules/@metro-labs/telegram-bot/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-bot', 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-bot[${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-bot[${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-bot: no accounts booted, exiting\n');
+  process.exit(2);
+}
+process.stderr.write(
+  `telegram-bot 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-bot[${acct.cfg.id}] account loop failed: ${errMsg(err)}\n`,
+    );
+  });

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

@@ -0,0 +1,166 @@
+import { tg, tgForm, targetOf } from './accounts.js';
+import { emit, mintId, respond, SELF_URI } from './wire.js';
+import { appendFile } from '@metro-labs/mcp/stations/attachments';
+
+export function emitOutbound(
+  accountId: string,
+  line: string,
+  messageId: string,
+  text: string,
+  replyTo?: string,
+): void {
+  emit({
+    kind: 'outbound',
+    id: mintId(),
+    ts: new Date().toISOString(),
+    station: 'telegram-bot',
+    line,
+    from: SELF_URI,
+    to: line,
+    message_id: messageId,
+    text,
+    reply_to: replyTo,
+    ...(replyTo ? { event: { type: 'reply', replyTo } } : {}),
+    account: accountId,
+    payload: { account: accountId },
+  });
+}
+
+export function finishSend(
+  id: string,
+  accountId: string,
+  line: string,
+  messageId: string,
+  label: string,
+  replyTo?: string,
+  extra?: Record<string, unknown>,
+): void {
+  emitOutbound(accountId, line, messageId, label, replyTo);
+  respond(id, {
+    result: { messageId, account: accountId, ...extra },
+  });
+}
+
+interface MediaArgs {
+  line: string;
+  path: string;
+  caption?: string;
+  replyTo?: string;
+  parseMode?: string;
+  account?: string;
+  name?: string;
+}
+
+export async function sendMedia(
+  method: string,
+  fieldName: string,
+  args: Record<string, unknown>,
+): Promise<{ accountId: string; message_id: number }> {
+  const {
+    line,
+    path,
+    caption,
+    replyTo,
+    parseMode,
+    account,
+    name: fileName,
+  } = args as unknown as MediaArgs;
+  const { accountId, chatId, topicId } = targetOf(line, account);
+  const form = new FormData();
+  form.append('chat_id', String(chatId));
+  if (topicId !== undefined) form.append('message_thread_id', String(topicId));
+  if (caption) form.append('caption', caption);
+  if (parseMode) form.append('parse_mode', parseMode);
+  if (replyTo)
+    form.append(
+      'reply_parameters',
+      JSON.stringify({ message_id: Number(replyTo) }),
+    );
+  const name = fileName ?? path.split('/').pop() ?? fieldName;
+  await appendFile(form, fieldName, path, name);
+  const r = await tgForm<{ message_id: number }>(accountId, method, form);
+  return { accountId, message_id: r.message_id };
+}
+
+export async function media(
+  id: string,
+  method: string,
+  field: string,
+  label: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { accountId, message_id } = await sendMedia(method, field, args);
+  const line = (args as { line: string }).line;
+  finishSend(
+    id,
+    accountId,
+    line,
+    String(message_id),
+    label,
+    args.replyTo as string | undefined,
+  );
+}
+
+export const MEDIA_METHOD_FIELD: Record<
+  string,
+  { method: string; field: string }
+> = {
+  image: { method: 'sendPhoto', field: 'photo' },
+  voice: { method: 'sendVoice', field: 'voice' },
+  audio: { method: 'sendAudio', field: 'audio' },
+  video: { method: 'sendVideo', field: 'video' },
+  document: { method: 'sendDocument', field: 'document' },
+};
+
+export async function sendDice(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const {
+    line,
+    emoji = '\U0001F3B2',
+    account,
+  } = args as { line: string; emoji?: string; account?: string };
+  const { accountId, chatId, topicId } = targetOf(line, account);
+  const body: Record<string, unknown> = { chat_id: chatId, emoji };
+  if (topicId !== undefined) body.message_thread_id = topicId;
+  const r = await tg<{ message_id: number; dice?: { value: number } }>(
+    accountId,
+    'sendDice',
+    body,
+  );
+  finishSend(
+    id,
+    accountId,
+    line,
+    String(r.message_id),
+    `[dice ${emoji} = ${r.dice?.value ?? '?'}]`,
+    undefined,
+    { value: r.dice?.value },
+  );
+}
+
+export async function sendLocation(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, latitude, longitude, account } = args as {
+    line: string;
+    latitude: number;
+    longitude: number;
+    account?: string;
+  };
+  const { accountId, chatId } = targetOf(line, account);
+  const r = await tg<{ message_id: number }>(accountId, 'sendLocation', {
+    chat_id: chatId,
+    latitude,
+    longitude,
+  });
+  finishSend(
+    id,
+    accountId,
+    line,
+    String(r.message_id),
+    `[location: ${latitude}, ${longitude}]`,
+  );
+}

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

@@ -0,0 +1,47 @@
+import type { MemberList, MetroMember } from '@metro-labs/mcp/stations/types';
+
+export interface TgUser {
+  id: number;
+  username?: string;
+  first_name?: string;
+  last_name?: string;
+  is_bot?: boolean;
+}
+
+export interface TgChatMember {
+  user: TgUser;
+  status: string;
+}
+
+export function mapTgMember(m: TgChatMember): MetroMember {
+  const u = m.user;
+  const member: MetroMember = { id: String(u.id) };
+  if (u.username) member.name = u.username;
+  const display = [u.first_name, u.last_name].filter(Boolean).join(' ');
+  if (display) member.display_name = display;
+  member.is_admin = m.status === 'creator' || m.status === 'administrator';
+  member.is_bot = Boolean(u.is_bot);
+  return member;
+}
+
+const BOT_LIMIT_REASON =
+  'Telegram Bot API cannot enumerate full membership; returning administrators only.';
+
+export function adminMemberList(
+  admins: TgChatMember[],
+  total: number | null,
+): MemberList {
+  return {
+    members: admins.map(mapTgMember),
+    capability: {
+      supported: true,
+      complete: false,
+      reason: BOT_LIMIT_REASON,
+      ...(total != null ? { total } : {}),
+    },
+  };
+}
+
+export function inaccessibleMemberList(reason: string): MemberList {
+  return { members: [], capability: { supported: false, complete: false, reason } };
+}

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

@@ -0,0 +1,17 @@
+import type { Station, Verb } from '@metro-labs/mcp/stations/types';
+
+export const telegramBotStation: Station = {
+  name: 'telegram-bot',
+  hasAccounts: true,
+  hasTrain: true,
+  messageVerbs: new Set<Verb>([
+    'send',
+    'reply',
+    'react',
+    'unreact',
+    'edit',
+    'delete',
+  ]),
+  attachmentMode: 'canonical',
+  tools: [],
+};

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

@@ -0,0 +1,48 @@
+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;
+  }[];
+}

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

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

package/runtime/runtime.json

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

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

@@ -1,81 +0,0 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import {
-  makeAccountStore,
-  resolveAccountId,
-  type Die,
-} from '@metro-labs/mcp/stations/account-store';
-import type { UserAccount } from './types.js';
-
-const ACCOUNTS_FILE =
-  process.env.TELEGRAM_USER_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'telegram-user-accounts.json');
-
-const isSignedInt = (s: string): boolean => /^-?\d+$/.test(s);
-const isTopic = (s: string): boolean => /^\d+$/.test(s);
-
-function validateAccount(a: UserAccount, seen: Set<string>, die: Die): void {
-  if (!a.id) die('account missing id');
-  if (!a.session || typeof a.session !== 'string')
-    die(`account '${a.id}' missing session`);
-  if (!Number.isInteger(a.apiId) || (a.apiId ?? 0) <= 0)
-    die(`account '${a.id}' missing apiId`);
-  if (!a.apiHash || typeof a.apiHash !== 'string')
-    die(`account '${a.id}' missing apiHash`);
-  if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-  seen.add(a.id);
-}
-
-export const { loadAccounts } = makeAccountStore<UserAccount>({
-  prefix: 'telegram-user',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['TELEGRAM_USER_ONLY_ACCOUNTS', 'TELEGRAM_USER_ACCOUNTS'],
-  validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) validateAccount(a, seen, die);
-  },
-});
-
-export const accounts = new Map<string, UserAccount>();
-
-export function accountFor(args: { account?: string; line?: string }): string {
-  return resolveAccountId(accounts, args, (line) => targetOf(line)?.accountId);
-}
-
-export function lineOf(
-  accountId: string,
-  chatId: number | string,
-  topicId?: number,
-): string {
-  const tail = topicId !== undefined ? `${chatId}/${topicId}` : `${chatId}`;
-  return `metro://telegram-user/${accountId}/${tail}`;
-}
-
-interface Target {
-  accountId: string;
-  chatId: number;
-  topicId?: number;
-}
-
-function splitScoped(path: string[]): { accountId: string; rest: string[] } {
-  const first = path[0];
-  if (path.length >= 2 && first !== undefined && !isSignedInt(first))
-    return { accountId: first, rest: path.slice(1) };
-  return { accountId: 'default', rest: path };
-}
-
-export function targetOf(line: string): Target | undefined {
-  const prefix = 'metro://telegram-user/';
-  if (!line.startsWith(prefix)) return undefined;
-  const path = line.slice(prefix.length).split('/').filter(Boolean);
-  const { accountId, rest } = splitScoped(path);
-  const [chatId, topicId] = rest;
-  if (rest.length < 1 || rest.length > 2 || chatId === undefined) return undefined;
-  if (!isSignedInt(chatId)) return undefined;
-  if (topicId !== undefined && !isTopic(topicId)) return undefined;
-  return {
-    accountId,
-    chatId: Number(chatId),
-    ...(topicId !== undefined ? { topicId: Number(topicId) } : {}),
-  };
-}