@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.300

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

@@ -0,0 +1,128 @@
+import {
+  saveBufferToCache,
+  assertContentLength,
+} from '@metro-labs/core/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/core/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 };
+}

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

@@ -0,0 +1,3 @@
+import { accountFiles } from '@metro-labs/core/stations/account-files';
+
+export const channelFiles = accountFiles('TELEGRAM_BOT_STATE_DIR', 'telegram-bot-channels-');

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

@@ -0,0 +1,43 @@
+import { ChannelDirectory } from '@metro-labs/core/stations/channel-directory';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accounts, type Account } from './accounts.js';
+import { channelFiles } from './channel-files.js';
+import { ObservedChats } from './observed-chats.js';
+import type { TgUpdate } from './types.js';
+
+interface DiscoveryState {
+  book: ObservedChats;
+  directory: ChannelDirectory;
+}
+
+const states = new WeakMap<Account, DiscoveryState>();
+
+function stateFor(account: Account): DiscoveryState {
+  let state = states.get(account);
+  if (state === undefined) {
+    state = {
+      book: new ObservedChats(account.cfg.id, channelFiles.path(account.cfg.id)),
+      directory: new ChannelDirectory(),
+    };
+    states.set(account, state);
+  }
+  return state;
+}
+
+export const observedChatsFor = (account: Account): ObservedChats => stateFor(account).book;
+
+export function observeChannels(account: string, update: TgUpdate): void {
+  const known = accounts.get(account);
+  if (known !== undefined) observedChatsFor(known).observe(update);
+}
+
+export async function listChannels(id: string, args: Record<string, unknown>): Promise<void> {
+  if (typeof args.account !== 'string' || args.account.trim() === '')
+    throw new TrainError('bad_request', 'listChannels requires an explicit account');
+  const account = accounts.get(args.account);
+  if (account === undefined) throw new TrainError('bad_request', `unknown account '${args.account}'`);
+  const { directory, book } = stateFor(account);
+  const result = await directory.list(account.cfg.id, args, () => Promise.resolve(book.snapshot()));
+  respond(id, { result });
+}

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

@@ -0,0 +1,170 @@
+import { accounts, lineOf } from './accounts.js';
+import { reportAttachment } from '@metro-labs/core/stations/train-events';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
+import { mediaRefOf, saveTelegramMedia } from './attachments.js';
+import type { TgMsg, TgReaction, TgReactionCount, TgUser } 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(' ');
+}
+
+const botIdOf = (accountId: string): number | null => {
+  const token = accounts.get(accountId)?.cfg.token ?? '';
+  const id = Number(token.split(':')[0]);
+  return Number.isInteger(id) && id > 0 ? id : null;
+};
+
+function mentionsBot(m: TgMsg, botId: number | null, username: string | undefined): boolean {
+  const text = m.text ?? m.caption ?? '';
+  const handle = username === undefined ? null : `@${username.toLowerCase()}`;
+  return [...(m.entities ?? []), ...(m.caption_entities ?? [])].some((e) => {
+    if (e.type === 'text_mention') return botId !== null && e.user?.id === botId;
+    if (e.type !== 'mention' || handle === null) return false;
+    return text.slice(e.offset, e.offset + e.length).toLowerCase() === handle;
+  });
+}
+
+function addressing(accountId: string, m: TgMsg): Record<string, unknown> {
+  const botId = botIdOf(accountId);
+  const topicRoot = m.is_topic_message === true && m.reply_to_message?.message_id === m.message_thread_id;
+  const replied = topicRoot ? undefined : m.reply_to_message;
+  const replyTo = replied === undefined ? undefined : String(replied.message_id);
+  return {
+    ...(replyTo === undefined ? {} : { reply_to: replyTo, event: { type: 'reply', replyTo } }),
+    mentions_self: mentionsBot(m, botId, accounts.get(accountId)?.username),
+    reply_to_self: botId !== null && replied?.from?.id === botId,
+  };
+}
+
+export const fullName = (u: TgUser | undefined): string | undefined => {
+  const name = [u?.first_name, u?.last_name].filter((part) => typeof part === 'string' && part !== '').join(' ');
+  return name === '' ? undefined : name;
+};
+
+export function envelope(accountId: string, m: TgMsg): Record<string, unknown> {
+  const { line } = lineForMsg(accountId, m);
+  return {
+    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: fullName(m.from),
+    message_id: String(m.message_id),
+    text: projectText(m),
+    payload: m,
+    is_private: m.chat.type === 'private',
+    ...addressing(accountId, m),
+  };
+}
+
+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 {
+    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: fullName(r.user),
+    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 {
+    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 saveMediaAndEmit(
+  accountId: string,
+  m: TgMsg,
+  sourceEnvId: string,
+): void {
+  const ref = mediaRefOf(m);
+  if (!ref) return;
+  const line = lineForMsg(accountId, m).line;
+  reportAttachment(saveTelegramMedia(accountId, ref, String(m.message_id), 0), {
+    station: 'telegram-bot',
+    account: accountId,
+    line,
+    forId: sourceEnvId,
+    index: 0,
+  });
+}

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

@@ -0,0 +1,74 @@
+import { errMsg } from '@metro-labs/core/log';
+import { accounts, loadAccounts, tg, type Account } from './accounts.js';
+import { announceAccounts } from '@metro-labs/core/stations/train-boot';
+import { readCalls } from '@metro-labs/core/trains/protocol';
+import { handleCall } from './actions.js';
+import { handleUpdate } from './updates.js';
+import type { TgUpdate } from './types.js';
+
+readCalls('telegram-bot', handleCall);
+
+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`,
+    );
+  }
+  try {
+    const me = await tg<{ username?: string }>(id, 'getMe', {});
+    if (typeof me.username === 'string') acct.username = me.username;
+  } catch (err) {
+    process.stderr.write(`telegram-bot[${id}] getMe: ${errMsg(err)}\n`);
+  }
+
+  for (;;) {
+    try {
+      const updates = await tg<TgUpdate[]>(
+        id,
+        'getUpdates',
+        {
+          offset: acct.offset,
+          timeout: 25,
+          allowed_updates: [
+            'message',
+            'channel_post',
+            'my_chat_member',
+            '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,
+  });
+}
+announceAccounts('telegram-bot', accounts.keys());
+
+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,90 @@
+import { tg, targetOf } from './accounts.js';
+import { selfUri } from '@metro-labs/core/stations/train-events';
+import { emit, mintId, respond } from '@metro-labs/core/stations/station-runtime';
+import { appendFile } from '@metro-labs/core/stations/attachments';
+
+export function emitOutbound(
+  accountId: string,
+  line: string,
+  messageId: string,
+  text: string,
+  replyTo?: string,
+): void {
+  emit({
+    id: mintId(),
+    ts: new Date().toISOString(),
+    station: 'telegram-bot',
+    line,
+    from: selfUri(),
+    to: line,
+    message_id: messageId,
+    text,
+    reply_to: replyTo,
+    ...(replyTo ? { event: { type: 'reply', replyTo } } : {}),
+    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;
+  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,
+    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 (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 tg<{ message_id: number }>(accountId, method, form);
+  return { accountId, message_id: r.message_id };
+}
+
+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' },
+};

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

@@ -0,0 +1,47 @@
+import type { MemberList, MetroMember } from '@metro-labs/core/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 } };
+}