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

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

@@ -1,103 +1,7 @@
-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';
+import { runClientTrain } from '@metro-labs/core/stations/train-boot';
+import { accounts, loadAccounts } from './accounts.js';
+import { createClient } from './client.js';
+import { startInbound } from './inbound.js';
+import { makeHandleCall } from './actions.js';
 
-readCalls('telegram', 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[${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[${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: no accounts booted, exiting\n');
-  process.exit(2);
-}
-process.stderr.write(
-  `telegram 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[${acct.cfg.id}] account loop failed: ${errMsg(err)}\n`,
-    );
-  });
+runClientTrain({ station: 'telegram', accounts, loadAccounts, createClient, startInbound, makeHandleCall });

package/runtime/node_modules/@metro-labs/{telegram-user → telegram}/src/login.ts

@@ -1,19 +1,19 @@
 import { TelegramClient } from '@mtcute/bun';
 
-export class TelegramUserLoginError extends Error {}
+export class TelegramLoginError extends Error {}
 
-export interface TelegramUserCredentials {
+export interface TelegramCredentials {
   apiId: number;
   apiHash: string;
   phone: string;
 }
 
-export interface TelegramUserSignedIn {
+export interface TelegramSignedIn {
   config: { session: string; apiId: number; apiHash: string };
   identity: { userId: string; displayName: string };
 }
 
-export type TelegramUserStep = 'code' | 'password';
+export type TelegramStep = 'code' | 'password';
 
 const PHONE_RE = /^[0-9]{6,15}$/;
 const API_HASH_RE = /^[a-f0-9]{32}$/i;
@@ -48,21 +48,21 @@ export function validateCredentials(raw: {
   apiId: unknown;
   apiHash: unknown;
   phone: unknown;
-}): TelegramUserCredentials {
+}): TelegramCredentials {
   const apiId = Number(raw.apiId);
   if (!Number.isInteger(apiId) || apiId <= 0)
-    throw new TelegramUserLoginError(
+    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 TelegramUserLoginError(
+    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 TelegramUserLoginError(
+    throw new TelegramLoginError(
       'phone must be an international number, digits only',
     );
   return { apiId, apiHash, phone };
@@ -84,12 +84,12 @@ interface UserLike {
   displayName: string;
 }
 
-export class TelegramUserLogin {
+export class TelegramLogin {
   private tg: TelegramClient;
   private phoneCodeHash = '';
   private closed = false;
 
-  constructor(private creds: TelegramUserCredentials) {
+  constructor(private creds: TelegramCredentials) {
     this.tg = new TelegramClient({
       apiId: creds.apiId,
       apiHash: creds.apiHash,
@@ -97,25 +97,25 @@ export class TelegramUserLogin {
     });
   }
 
-  async requestCode(): Promise<{ step: TelegramUserStep; length: number }> {
+  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 TelegramUserLoginError(readableAuthError(err));
+        throw new TelegramLoginError(readableAuthError(err));
       });
     if (!isSentCode(sent))
-      throw new TelegramUserLoginError(
+      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<TelegramUserSignedIn | 'password'> {
+  async submitCode(raw: string): Promise<TelegramSignedIn | 'password'> {
     const phoneCode = raw.replace(/[^0-9]/g, '');
     if (phoneCode === '')
-      throw new TelegramUserLoginError('enter the login code Telegram sent you');
+      throw new TelegramLoginError('enter the login code Telegram sent you');
     try {
       const user = await this.tg.signIn({
         phone: this.creds.phone,
@@ -125,24 +125,24 @@ export class TelegramUserLogin {
       return await this.exportFor(user);
     } catch (err) {
       if (needsPassword(err)) return 'password';
-      throw new TelegramUserLoginError(readableAuthError(err));
+      throw new TelegramLoginError(readableAuthError(err));
     }
   }
 
-  async submitPassword(password: string): Promise<TelegramUserSignedIn> {
+  async submitPassword(password: string): Promise<TelegramSignedIn> {
     if (password === '')
-      throw new TelegramUserLoginError(
+      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 TelegramUserLoginError(readableAuthError(err));
+      throw new TelegramLoginError(readableAuthError(err));
     }
   }
 
-  private async exportFor(user: UserLike): Promise<TelegramUserSignedIn> {
+  private async exportFor(user: UserLike): Promise<TelegramSignedIn> {
     const session = await this.tg.exportSession();
     await this.close();
     return {

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

@@ -1,166 +1,79 @@
-import { tg, tgForm, targetOf } from './accounts.js';
-import { emit, mintId, respond, SELF_URI } from './wire.js';
-import { appendFile } from '@metro-labs/mcp/stations/attachments';
+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 function emitOutbound(
-  accountId: string,
-  line: string,
-  messageId: string,
-  text: string,
-  replyTo?: string,
-): void {
-  emit({
-    kind: 'outbound',
-    id: mintId(),
-    ts: new Date().toISOString(),
-    station: 'telegram',
-    line,
-    from: SELF_URI,
-    to: line,
-    message_id: messageId,
-    text,
-    reply_to: replyTo,
-    ...(replyTo ? { event: { type: 'reply', replyTo } } : {}),
-    account: accountId,
-    payload: { account: accountId },
-  });
+export interface CanonicalAttachment {
+  kind?: string;
+  path?: string;
+  mime?: string;
+  name?: string;
 }
 
-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 },
-  });
+const srcOf = (att: CanonicalAttachment): string => att.path ?? '';
+
+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);
 }
 
-interface MediaArgs {
-  line: string;
-  path: string;
-  caption?: string;
-  replyTo?: string;
-  parseMode?: string;
-  account?: string;
-  name?: string;
+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 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 interface OutgoingMedia {
+  media: InputMediaLike;
+  kind: string;
 }
 
-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 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' };
 }
 
-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' },
-};
+interface SendMediaTarget {
+  client: UserClient;
+  chatId: number;
+  replyTo?: number;
+}
 
-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 interface SentMedia {
+  message: Message;
+  delivered: string[];
 }
 
-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}]`,
-  );
+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

@@ -1,47 +1,75 @@
-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;
-}
+import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
+import type { UserClient } from './client.js';
 
-export interface TgChatMember {
-  user: TgUser;
+export interface RawUserMember {
+  user: {
+    id: number;
+    username?: string | null;
+    displayName?: string;
+    isBot?: boolean;
+  };
   status: string;
+  title?: string | null;
 }
 
-export function mapTgMember(m: TgChatMember): MetroMember {
+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;
-  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);
+  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;
 }
 
-const BOT_LIMIT_REASON =
-  'Telegram Bot API cannot enumerate full membership; returning administrators only.';
+export function restrictedMemberList(reason: string): MemberList {
+  return { members: [], capability: { supported: false, complete: false, reason } };
+}
 
-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 } : {}),
-    },
-  };
+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);
 }
 
-export function inaccessibleMemberList(reason: string): MemberList {
-  return { members: [], capability: { supported: false, complete: false, reason } };
+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/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-user → telegram}/src/reactions.ts

@@ -1,7 +1,7 @@
 import type { tl } from '@mtcute/bun';
 import { getBarePeerId, getMarkedPeerId } from '@mtcute/bun';
-import { errMsg } from '@metro-labs/mcp/log';
-import { emit } from './wire.js';
+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';
 
@@ -160,7 +160,7 @@ export function subscribeReactions(client: UserClient): void {
       handleUpdate(client, update);
     } catch (e) {
       process.stderr.write(
-        `telegram-user[${accountId}] reaction normalize failed: ${errMsg(e)}\n`,
+        `telegram[${accountId}] reaction normalize failed: ${errMsg(e)}\n`,
       );
     }
   });