@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.131

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

@@ -0,0 +1,166 @@
+import { TelegramClient } from '@mtcute/bun';
+
+export class TelegramLoginError extends Error {}
+
+export interface TelegramCredentials {
+  apiId: number;
+  apiHash: string;
+  phone: string;
+}
+
+export interface TelegramSignedIn {
+  config: { session: string; apiId: number; apiHash: string };
+  identity: { userId: string; displayName: string };
+}
+
+export type TelegramStep = 'code' | 'password';
+
+const PHONE_RE = /^[0-9]{6,15}$/;
+const API_HASH_RE = /^[a-f0-9]{32}$/i;
+
+export function rpcErrorText(err: unknown): string {
+  if (typeof err !== 'object' || err === null) return '';
+  const text = (err as { text?: unknown }).text;
+  return typeof text === 'string' ? text : '';
+}
+
+export function needsPassword(err: unknown): boolean {
+  return rpcErrorText(err) === 'SESSION_PASSWORD_NEEDED';
+}
+
+export function readableAuthError(err: unknown): string {
+  const text = rpcErrorText(err);
+  if (text.startsWith('PHONE_CODE_INVALID')) return 'that login code is not right';
+  if (text.startsWith('PHONE_CODE_EXPIRED'))
+    return 'that login code has expired, start again';
+  if (text.startsWith('PHONE_NUMBER_INVALID'))
+    return 'Telegram does not recognise that phone number';
+  if (text.startsWith('PHONE_NUMBER_BANNED'))
+    return 'Telegram has banned that phone number';
+  if (text.startsWith('PASSWORD_HASH_INVALID'))
+    return 'that two-step verification password is not right';
+  if (text.startsWith('FLOOD_WAIT'))
+    return 'Telegram is rate-limiting this number, try again later';
+  return text === '' ? 'Telegram refused the sign-in' : `Telegram said ${text}`;
+}
+
+export function validateCredentials(raw: {
+  apiId: unknown;
+  apiHash: unknown;
+  phone: unknown;
+}): TelegramCredentials {
+  const apiId = Number(raw.apiId);
+  if (!Number.isInteger(apiId) || apiId <= 0)
+    throw new TelegramLoginError(
+      'api id must be the integer from my.telegram.org',
+    );
+  const apiHash = typeof raw.apiHash === 'string' ? raw.apiHash.trim() : '';
+  if (!API_HASH_RE.test(apiHash))
+    throw new TelegramLoginError(
+      'api hash must be the 32-character hash from my.telegram.org',
+    );
+  const phone =
+    typeof raw.phone === 'string' ? raw.phone.replace(/[^0-9]/g, '') : '';
+  if (!PHONE_RE.test(phone))
+    throw new TelegramLoginError(
+      'phone must be an international number, digits only',
+    );
+  return { apiId, apiHash, phone };
+}
+
+interface SentCodeLike {
+  phoneCodeHash: string;
+  length: number;
+  type: string;
+}
+
+const isSentCode = (v: unknown): v is SentCodeLike =>
+  typeof v === 'object' &&
+  v !== null &&
+  typeof (v as { phoneCodeHash?: unknown }).phoneCodeHash === 'string';
+
+interface UserLike {
+  id: number;
+  displayName: string;
+}
+
+export class TelegramLogin {
+  private tg: TelegramClient;
+  private phoneCodeHash = '';
+  private closed = false;
+
+  constructor(private creds: TelegramCredentials) {
+    this.tg = new TelegramClient({
+      apiId: creds.apiId,
+      apiHash: creds.apiHash,
+      storage: ':memory:',
+    });
+  }
+
+  async requestCode(): Promise<{ step: TelegramStep; length: number }> {
+    await this.tg.connect();
+    const sent = await this.tg
+      .sendCode({ phone: this.creds.phone })
+      .catch((err: unknown) => {
+        throw new TelegramLoginError(readableAuthError(err));
+      });
+    if (!isSentCode(sent))
+      throw new TelegramLoginError(
+        'Telegram signed this number in without a code, which Metro cannot use',
+      );
+    this.phoneCodeHash = sent.phoneCodeHash;
+    return { step: 'code', length: sent.length };
+  }
+
+  async submitCode(raw: string): Promise<TelegramSignedIn | 'password'> {
+    const phoneCode = raw.replace(/[^0-9]/g, '');
+    if (phoneCode === '')
+      throw new TelegramLoginError('enter the login code Telegram sent you');
+    try {
+      const user = await this.tg.signIn({
+        phone: this.creds.phone,
+        phoneCodeHash: this.phoneCodeHash,
+        phoneCode,
+      });
+      return await this.exportFor(user);
+    } catch (err) {
+      if (needsPassword(err)) return 'password';
+      throw new TelegramLoginError(readableAuthError(err));
+    }
+  }
+
+  async submitPassword(password: string): Promise<TelegramSignedIn> {
+    if (password === '')
+      throw new TelegramLoginError(
+        'enter your Telegram two-step verification password',
+      );
+    try {
+      const user = await this.tg.checkPassword(password);
+      return await this.exportFor(user);
+    } catch (err) {
+      throw new TelegramLoginError(readableAuthError(err));
+    }
+  }
+
+  private async exportFor(user: UserLike): Promise<TelegramSignedIn> {
+    const session = await this.tg.exportSession();
+    await this.close();
+    return {
+      config: {
+        session,
+        apiId: this.creds.apiId,
+        apiHash: this.creds.apiHash,
+      },
+      identity: {
+        userId: String(user.id),
+        displayName: user.displayName,
+      },
+    };
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) return;
+    this.closed = true;
+    await this.tg.destroy().catch(() => undefined);
+  }
+}

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/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,24 @@
+import type { GroupOp, Station, Verb } from '@metro-labs/core/stations/types';
+
+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',
+  tools: [],
+};

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

@@ -0,0 +1,7 @@
+export interface UserAccount {
+  id: string;
+  session: string;
+  apiId?: number;
+  apiHash?: string;
+  owner?: 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,120 @@
+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;
+  owner?: 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 };
+}