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

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

@@ -0,0 +1,70 @@
+import type { TelegramClient } from '@mtcute/bun';
+import {
+  assertImage,
+  fieldsOf,
+  parseProfileChange,
+  type ProfileApplied,
+  type ProfileChange,
+} from '@metro-labs/core/stations/profile';
+import { respond, type StationHandler } from '@metro-labs/core/stations/station-runtime';
+import { str } from '@metro-labs/core/str';
+import { makeProfileCache, nonEmpty, type ProfileCache, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountFor } from './accounts.js';
+import type { UserClient } from './client.js';
+
+const BIO_MAX = 70;
+
+export async function applyProfile(tg: TelegramClient, change: ProfileChange): Promise<void> {
+  if (change.name !== undefined || change.bio !== undefined)
+    await tg.updateProfile({
+      ...(change.name === undefined ? {} : { firstName: change.name }),
+      ...(change.bio === undefined ? {} : { bio: change.bio.slice(0, BIO_MAX) }),
+    });
+  if (change.avatar !== undefined) {
+    assertImage(change.avatar);
+    await tg.setMyProfilePhoto({ type: 'photo', media: `file:${change.avatar.path}` });
+  }
+}
+
+export function makeSetProfile(clientFor: (accountId: string) => UserClient): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const change = parseProfileChange(args);
+    await applyProfile(clientFor(accountId).tg, change);
+    const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
+    respond(id, { result });
+  };
+}
+
+const senders = new Map<string, ProfileCache<SenderProfile>>();
+
+function sendersOf(client: UserClient): ProfileCache<SenderProfile> {
+  const held = senders.get(client.account.id);
+  if (held !== undefined) return held;
+  const made = makeProfileCache<SenderProfile>(
+    async (user) => {
+      const full = await client.tg.getFullUser(Number(user));
+      const handle = nonEmpty(full.username);
+      const display = nonEmpty([full.firstName, full.lastName].filter((part) => typeof part === 'string').join(' '));
+      return {
+        id: user,
+        ...(handle === undefined ? {} : { name: `@${handle}` }),
+        ...(display === undefined ? {} : { display_name: display }),
+        ...(nonEmpty(full.bio) === undefined ? {} : { about: nonEmpty(full.bio) }),
+      };
+    },
+    { onError: (user, err) => process.stderr.write(`telegram[${client.account.id}] could not read the profile of ${user}: ${err instanceof Error ? err.message : String(err)}\n`) },
+  );
+  senders.set(client.account.id, made);
+  return made;
+}
+
+export function makeReadProfile(clientFor: (accountId: string) => UserClient): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const user = str(args.user) ?? '';
+    if (!/^\d+$/.test(user)) throw new TrainError('telegram_user_required', 'profile needs the numeric Telegram id of the person', { retryable: false });
+    respond(id, { result: (await sendersOf(clientFor(accountId)).get(user)) ?? { id: user } });
+  };
+}

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

@@ -0,0 +1,167 @@
+import type { tl } from '@mtcute/bun';
+import { getBarePeerId, getMarkedPeerId } from '@mtcute/bun';
+import { errMsg } from '@metro-labs/core/log';
+import { emit } from '@metro-labs/core/stations/station-runtime';
+import { reactionEnvelope } from './format.js';
+import type { UserClient } from './client.js';
+
+interface SeenReaction {
+  reactorId: number;
+  emoji: string;
+}
+
+type CountMap = Map<string, number>;
+
+interface SeenState {
+  recent: SeenReaction[];
+  counts: CountMap;
+}
+
+const SEEN_BY_KEY_MAX = 5000;
+const seenByKey = new Map<string, SeenState>();
+
+function emojiOf(reaction: tl.TypeReaction): string | undefined {
+  if (reaction._ === 'reactionEmoji') return reaction.emoticon;
+  if (reaction._ === 'reactionCustomEmoji')
+    return `custom:${String(reaction.documentId)}`;
+  if (reaction._ === 'reactionPaid') return '⭐';
+  return undefined;
+}
+
+function recentOf(reactions: tl.TypeMessageReactions): SeenReaction[] {
+  const recent = reactions.recentReactions ?? [];
+  const out: SeenReaction[] = [];
+  for (const r of recent) {
+    if (r.my === true) continue;
+    const emoji = emojiOf(r.reaction);
+    if (emoji === undefined) continue;
+    out.push({ reactorId: getBarePeerId(r.peerId), emoji });
+  }
+  return out;
+}
+
+function countsOf(reactions: tl.TypeMessageReactions): CountMap {
+  const out: CountMap = new Map();
+  for (const r of reactions.results) {
+    const emoji = emojiOf(r.reaction);
+    if (emoji === undefined) continue;
+    const count = r.chosenOrder === undefined ? r.count : r.count - 1;
+    if (count > 0) out.set(emoji, count);
+  }
+  return out;
+}
+
+function has(list: SeenReaction[], item: SeenReaction): boolean {
+  return list.some(
+    (r) => r.reactorId === item.reactorId && r.emoji === item.emoji,
+  );
+}
+
+interface DiffResult {
+  added: SeenReaction[];
+  removed: SeenReaction[];
+}
+
+function diffRecent(prev: SeenReaction[], next: SeenReaction[]): DiffResult {
+  return {
+    added: next.filter((n) => !has(prev, n)),
+    removed: prev.filter((p) => !has(next, p)),
+  };
+}
+
+function diffCounts(
+  prev: CountMap,
+  next: CountMap,
+  reactorId: number,
+): DiffResult {
+  const added: SeenReaction[] = [];
+  const removed: SeenReaction[] = [];
+  const emojis = new Set([...prev.keys(), ...next.keys()]);
+  for (const emoji of emojis) {
+    const before = prev.get(emoji) ?? 0;
+    const after = next.get(emoji) ?? 0;
+    if (after > before) added.push({ reactorId, emoji });
+    else if (after < before) removed.push({ reactorId, emoji });
+  }
+  return { added, removed };
+}
+
+interface ReactionContext {
+  accountId: string;
+  chatId: number;
+  messageId: number;
+  isPrivate: boolean;
+}
+
+function emitDiff(ctx: ReactionContext, change: DiffResult): void {
+  const base = {
+    accountId: ctx.accountId,
+    chatId: ctx.chatId,
+    messageId: ctx.messageId,
+    date: new Date(),
+    isPrivate: ctx.isPrivate,
+  };
+  for (const a of change.added)
+    emit(reactionEnvelope({ ...base, emoji: a.emoji, senderId: a.reactorId }));
+  for (const r of change.removed)
+    emit(
+      reactionEnvelope({
+        ...base,
+        emoji: r.emoji,
+        senderId: r.reactorId,
+        removed: true,
+      }),
+    );
+}
+
+function computeChange(
+  update: tl.RawUpdateMessageReactions,
+  prev: SeenState,
+  next: SeenState,
+  isPrivate: boolean,
+): DiffResult {
+  if (next.recent.length > 0 || prev.recent.length > 0)
+    return diffRecent(prev.recent, next.recent);
+  if (!isPrivate) return { added: [], removed: [] };
+  return diffCounts(prev.counts, next.counts, getBarePeerId(update.peer));
+}
+
+function handleUpdate(
+  client: UserClient,
+  update: tl.RawUpdateMessageReactions,
+): void {
+  const chatId = getMarkedPeerId(update.peer);
+  const isPrivate = update.peer._ === 'peerUser';
+  const key = `${chatId}:${update.msgId}`;
+  const next: SeenState = {
+    recent: recentOf(update.reactions),
+    counts: countsOf(update.reactions),
+  };
+  const prev = seenByKey.get(key) ?? { recent: [], counts: new Map() };
+  const change = computeChange(update, prev, next, isPrivate);
+  seenByKey.set(key, next);
+  if (seenByKey.size > SEEN_BY_KEY_MAX) {
+    const oldest = seenByKey.keys().next().value;
+    if (oldest !== undefined) seenByKey.delete(oldest);
+  }
+  if (change.added.length === 0 && change.removed.length === 0) return;
+  emitDiff(
+    { accountId: client.account.id, chatId, messageId: update.msgId, isPrivate },
+    change,
+  );
+}
+
+export function subscribeReactions(client: UserClient): void {
+  const accountId = client.account.id;
+  client.tg.onRawUpdate.add((info) => {
+    const { update } = info;
+    if (update._ !== 'updateMessageReactions') return;
+    try {
+      handleUpdate(client, update);
+    } catch (e) {
+      process.stderr.write(
+        `telegram[${accountId}] reaction normalize failed: ${errMsg(e)}\n`,
+      );
+    }
+  });
+}

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

@@ -0,0 +1,28 @@
+import type { GroupOp, Station, Verb } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
+
+export const telegramStation: Station = {
+  name: 'telegram',
+  hasAccounts: true,
+  hasTrain: true,
+  messageVerbs: new Set<Verb>([
+    'send',
+    'reply',
+    'react',
+    'unreact',
+    'edit',
+    'delete',
+    'read',
+  ]),
+  groupOps: new Set<GroupOp>([
+    'create_group',
+    'add_members',
+    'remove_members',
+    'invite_link',
+  ]),
+  attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  discoversChannels: true,
+  tools: [],
+};

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

@@ -0,0 +1,6 @@
+export interface UserAccount {
+  id: string;
+  session: string;
+  apiId?: number;
+  apiHash?: string;
+}

package/runtime/node_modules/@metro-labs/telegram-bot/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@metro-labs/telegram-bot",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/station.ts",
+    "./train": "./src/index.ts",
+    "./verify": "./src/verify.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.3",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}

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

@@ -0,0 +1,86 @@
+import {
+  makeAccountStore,
+  resolveAccountId,
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
+
+export interface AccountConfig {
+  id: string;
+  token: string;
+}
+
+export const { loadAccounts } = makeAccountStore<AccountConfig>({
+  prefix: 'telegram-bot',
+  validate(raw, die) {
+    const seenTok = new Set<string>();
+    for (const a of raw) {
+      if (!a.token || typeof a.token !== 'string')
+        die(`account '${a.id}' missing token`);
+      if (seenTok.has(a.token))
+        die(
+          `account '${a.id}' reuses a token used by another account (409 on getUpdates)`,
+        );
+      seenTok.add(a.token);
+    }
+  },
+});
+
+export interface Account {
+  cfg: AccountConfig;
+  api: string;
+  fileApi: string;
+  offset: number;
+  username?: string;
+}
+export const accounts = new Map<string, Account>();
+
+export async function tg<T>(
+  accountId: string,
+  method: string,
+  body: unknown,
+  timeoutMs = body instanceof FormData ? 60_000 : 30_000,
+): Promise<T> {
+  const acct = accounts.get(accountId);
+  if (!acct) throw new Error(`unknown account '${accountId}'`);
+  const form = body instanceof FormData;
+  const res = await fetch(`${acct.api}/${method}`, {
+    method: 'POST',
+    ...(form ? {} : { headers: { 'Content-Type': 'application/json' } }),
+    body: form ? 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 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,242 @@
+import { accounts, tg, targetOf } from './accounts.js';
+import { errMsg } from '@metro-labs/core/log';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
+import {
+  adminMemberList,
+  inaccessibleMemberList,
+  type TgChatMember,
+} from './members.js';
+import { makeStation, respond, type CallMsg, type StationHandler } from '@metro-labs/core/stations/station-runtime';
+import { mediaKindOf } from './attachments.js';
+import {
+  emitOutbound,
+  finishSend,
+  MEDIA_METHOD_FIELD,
+  sendMedia,
+} from './media-actions.js';
+import { readProfile, setProfile } from './profile.js';
+import { listChannels } from './channels.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}`,
+        botId: me?.id ?? null,
+        username,
+      };
+    }),
+  );
+  respond(id, { result: { accounts: list } });
+}
+
+interface SendArgs {
+  line: string;
+  text: string;
+  replyTo?: string;
+  account?: string;
+  attachments?: {
+    kind?: string;
+    path?: string;
+    mime?: string;
+    name?: string;
+  }[];
+}
+
+
+type WireAttachment = NonNullable<SendArgs['attachments']>[number];
+
+const attachmentKind = (att: WireAttachment): string =>
+  mediaKindOf(att.kind, att.mime, att.path ?? 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: att.path,
+    caption,
+    replyTo: a.replyTo,
+    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, 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) };
+  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 typing(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, chatId, topicId } = targetOf(line, account);
+  const body: Record<string, unknown> = { chat_id: chatId, action: 'typing' };
+  if (topicId !== undefined) body.message_thread_id = topicId;
+  await tg(accountId, 'sendChatAction', body);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function edit(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, text, account } = args as {
+    line: string;
+    messageId: string;
+    text: string;
+    account?: string;
+  };
+  const { accountId, chatId } = targetOf(line, account);
+  await tg(accountId, 'editMessageText', {
+    chat_id: chatId,
+    message_id: Number(messageId),
+    text,
+  });
+  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 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,
+  typing,
+  edit,
+  delete: remove,
+  listMembers,
+  listChannels,
+  set_profile: setProfile,
+  profile: readProfile,
+};
+
+export const handleCall = makeStation({
+  handlers: HANDLERS,
+  normalize: messagingAliases(),
+});