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

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

@@ -0,0 +1,80 @@
+import type { InputMediaLike, Message } from '@mtcute/bun';
+import { InputMedia } from '@mtcute/bun';
+import { isImageMime, isImageExt } from '@metro-labs/core/stations/attachments';
+import type { UserClient } from './client.js';
+
+export interface CanonicalAttachment {
+  kind?: string;
+  path?: string;
+  url?: string;
+  mime?: string;
+  name?: string;
+}
+
+const srcOf = (att: CanonicalAttachment): string => att.path ?? att.url ?? '';
+
+function isImage(att: CanonicalAttachment): boolean {
+  if (att.kind === 'image') return true;
+  if (att.mime !== undefined) return isImageMime(att.mime);
+  const src = srcOf(att);
+  return src !== '' && isImageExt(src);
+}
+
+function fileRef(att: CanonicalAttachment): string {
+  const src = srcOf(att);
+  if (src === '' || /^https?:\/\//i.test(src)) return src;
+  return src.startsWith('file:') ? src : `file:${src}`;
+}
+
+export interface OutgoingMedia {
+  media: InputMediaLike;
+  kind: string;
+}
+
+export function buildInputMedia(
+  att: CanonicalAttachment,
+  caption: string | undefined,
+): OutgoingMedia {
+  const file = fileRef(att);
+  const params = {
+    ...(caption ? { caption } : {}),
+    ...(att.name ? { fileName: att.name } : {}),
+  };
+  return isImage(att)
+    ? { media: InputMedia.photo(file, params), kind: 'image' }
+    : { media: InputMedia.document(file, params), kind: 'file' };
+}
+
+interface SendMediaTarget {
+  client: UserClient;
+  chatId: number;
+  replyTo?: number;
+}
+
+export interface SentMedia {
+  message: Message;
+  delivered: string[];
+}
+
+export async function sendAttachments(
+  target: SendMediaTarget,
+  attachments: CanonicalAttachment[],
+  text: string,
+): Promise<SentMedia> {
+  const { client, chatId, replyTo } = target;
+  const peer = await client.tg.resolvePeer(chatId);
+  let last: Message | undefined;
+  const delivered: string[] = [];
+  for (let i = 0; i < attachments.length; i++) {
+    const att = attachments[i];
+    if (!att || srcOf(att) === '') continue;
+    const caption = i === 0 ? text : undefined;
+    const out = buildInputMedia(att, caption);
+    last = await client.tg.sendMedia(peer, out.media, {
+      ...(replyTo !== undefined ? { replyTo } : {}),
+    });
+    delivered.push(out.kind);
+  }
+  if (!last) throw new Error('no attachments were sent');
+  return { message: last, delivered };
+}

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

@@ -0,0 +1,75 @@
+import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
+import type { UserClient } from './client.js';
+
+export interface RawUserMember {
+  user: {
+    id: number;
+    username?: string | null;
+    displayName?: string;
+    isBot?: boolean;
+  };
+  status: string;
+  title?: string | null;
+}
+
+const PAGE = 200;
+const HARD_CAP = 2000;
+
+export function mapUserMember(m: RawUserMember): MetroMember {
+  const u = m.user;
+  const member: MetroMember = { id: String(u.id) };
+  if (u.username) member.name = u.username;
+  if (u.displayName) member.display_name = u.displayName;
+  if (m.title) member.roles = [m.title];
+  member.is_admin = m.status === 'creator' || m.status === 'admin';
+  member.is_bot = Boolean(u.isBot);
+  return member;
+}
+
+export function restrictedMemberList(reason: string): MemberList {
+  return { members: [], capability: { supported: false, complete: false, reason } };
+}
+
+const RESTRICTED_RE =
+  /ADMIN|PRIVATE|CHAT_ADMIN_REQUIRED|not (a )?participant|permission|not enough rights/i;
+
+export function isRestricted(msg: string): boolean {
+  return RESTRICTED_RE.test(msg);
+}
+
+type Chunk = RawUserMember[] & { total?: number };
+
+export async function fetchMembers(
+  client: UserClient,
+  chatId: number,
+  limit?: number,
+): Promise<MemberList> {
+  const target = Math.min(Math.max(1, limit ?? PAGE), HARD_CAP);
+  const collected: RawUserMember[] = [];
+  let total = 0;
+  for (let offset = 0; collected.length < target; ) {
+    const want = Math.min(PAGE, target - collected.length);
+    const getChatMembers = (
+      client.tg as unknown as {
+        getChatMembers: (
+          id: number,
+          p: { offset: number; limit: number },
+        ) => Promise<Chunk>;
+      }
+    ).getChatMembers;
+    const chunk = await getChatMembers.call(client.tg, chatId, {
+      offset,
+      limit: want,
+    });
+    total = chunk.total ?? collected.length + chunk.length;
+    if (!chunk.length) break;
+    collected.push(...chunk);
+    offset += chunk.length;
+    if (collected.length >= total || chunk.length < want) break;
+  }
+  const members = collected.map(mapUserMember);
+  return {
+    members,
+    capability: { supported: true, complete: members.length >= total, total },
+  };
+}

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

@@ -0,0 +1,22 @@
+import type { Normalized } from '@metro-labs/core/stations/messaging-normalize';
+
+type Args = Record<string, unknown>;
+
+export function normalizeTelegramUser(action: string, env: Args): Normalized {
+  if (action === 'reply') {
+    return {
+      action: 'send',
+      args: {
+        line: env.line,
+        text: env.text,
+        replyTo: env.replyTo,
+        account: env.account,
+        attachments: env.attachments,
+      },
+    };
+  }
+  if (action === 'unreact') {
+    return { action: 'react', args: { ...env, emoji: '' } };
+  }
+  return { action, args: env };
+}

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 './wire.js';
+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,27 @@
+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,
+  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/src/wire.ts

@@ -0,0 +1 @@
+export { emit, mintId } from '@metro-labs/core/stations/station-runtime';

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.2",
+    "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,119 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import {
+  makeAccountStore,
+  resolveAccountId,
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
+
+const ACCOUNTS_FILE =
+  process.env.TELEGRAM_BOT_ACCOUNTS_FILE ??
+  join(homedir(), '.metro', 'telegram-bot-accounts.json');
+
+export interface AccountConfig {
+  id: string;
+  token: string;
+}
+
+export const { loadAccounts } = makeAccountStore<AccountConfig>({
+  prefix: 'telegram-bot',
+  file: ACCOUNTS_FILE,
+  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;
+  username?: string;
+}
+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 };
+}