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

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

@@ -0,0 +1,275 @@
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
+import {
+  makeStation,
+  respond,
+  type CallMsg,
+  type StationHandler,
+} from '@metro-labs/core/stations/station-runtime';
+import { accountFor, accounts, targetOf } from './accounts.js';
+import type { UserClient } from './client.js';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
+import {
+  sendAttachments,
+  type CanonicalAttachment,
+} from './media-actions.js';
+import { ChannelDirectory } from '@metro-labs/core/stations/channel-directory';
+import { fetchChannels } from './channels.js';
+import { clampLimit, shapeHistory } from './history.js';
+import { makeReadProfile, makeSetProfile } from './profile.js';
+import { fetchMembers, isRestricted, restrictedMemberList } from './members.js';
+import {
+  groupAddMembers,
+  groupCreate,
+  groupInviteLink,
+  groupRemoveMembers,
+} from './group.js';
+
+type Args = Record<string, unknown>;
+
+interface Resolved {
+  accountId: string;
+  client: UserClient;
+  chatId: number;
+  topicId?: number;
+}
+
+type ClientFor = (accountId: string) => UserClient;
+
+function str(v: unknown): string | undefined {
+  return typeof v === 'string' ? v : undefined;
+}
+
+function lineOfArgs(args: Args): string {
+  const line = str(args.line);
+  if (!line) throw new TrainError('bad_request', 'missing line');
+  return line;
+}
+
+function resolve(args: Args, clientFor: ClientFor): Resolved {
+  const line = lineOfArgs(args);
+  const target = targetOf(line);
+  if (!target) throw new TrainError('bad_request', `bad line '${line}'`);
+  const accountId = accountFor({ account: str(args.account), line });
+  return {
+    accountId,
+    client: clientFor(accountId),
+    chatId: target.chatId,
+    ...(target.topicId !== undefined ? { topicId: target.topicId } : {}),
+  };
+}
+
+async function guard<T>(run: () => Promise<T>): Promise<T> {
+  try {
+    return await run();
+  } catch (e) {
+    const msg = errMsg(e);
+    if (/FLOOD_WAIT|SLOWMODE_WAIT/i.test(msg))
+      throw new TrainError('rate_limited', msg);
+    throw new TrainError('telegram_call', msg);
+  }
+}
+
+function attachmentsOf(args: Args): CanonicalAttachment[] {
+  const raw = args.attachments;
+  return Array.isArray(raw) ? (raw as CanonicalAttachment[]) : [];
+}
+
+function makeSend(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, chatId, topicId } = resolve(args, clientFor);
+    const text = str(args.text) ?? '';
+    const replyTo = str(args.replyTo);
+    const explicitReplyTo = replyTo ? Number(replyTo) : undefined;
+    const replyParam = explicitReplyTo ?? topicId;
+    const attachments = attachmentsOf(args);
+    if (attachments.length) {
+      const sent = await guard(() =>
+        sendAttachments({ client, chatId, replyTo: replyParam }, attachments, text),
+      );
+      respond(id, {
+        result: {
+          messageId: String(sent.message.id),
+          account: accountId,
+          attachments: sent.delivered,
+        },
+      });
+      return;
+    }
+    const peer = await guard(() => client.tg.resolvePeer(chatId));
+    const sent = await guard(() =>
+      client.tg.sendText(
+        peer,
+        text,
+        replyParam !== undefined ? { replyTo: replyParam } : undefined,
+      ),
+    );
+    respond(id, {
+      result: { messageId: String(sent.id), account: accountId },
+    });
+  };
+}
+
+function makeReact(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, chatId } = resolve(args, clientFor);
+    const message = Number(str(args.messageId));
+    const raw = str(args.emoji);
+    const emoji = raw === undefined || raw === '' ? null : raw;
+    await guard(() =>
+      client.tg.sendReaction({ chatId, message, emoji }),
+    );
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
+function makeEdit(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, chatId } = resolve(args, clientFor);
+    const message = Number(str(args.messageId));
+    const text = str(args.text) ?? '';
+    await guard(() => client.tg.editMessage({ chatId, message, text }));
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
+function makeDelete(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, chatId } = resolve(args, clientFor);
+    const message = Number(str(args.messageId));
+    await guard(() =>
+      client.tg.deleteMessagesById(chatId, [message], { revoke: true }),
+    );
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
+function makeRead(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, chatId } = resolve(args, clientFor);
+    const limit = clampLimit(args.limit);
+    const before = str(args.before);
+    const beforeId = before ? Number(before) : undefined;
+    const offset =
+      beforeId !== undefined && Number.isFinite(beforeId)
+        ? { offset: { id: beforeId, date: 0 } }
+        : {};
+    const page = await guard(() =>
+      client.tg.getHistory(chatId, { limit, ...offset }),
+    );
+    respond(id, { result: shapeHistory(accountId, chatId, page) });
+  };
+}
+
+function makeListChannels(clientFor: ClientFor): StationHandler {
+  const directories = new WeakMap<UserClient, ChannelDirectory>();
+  return async (id, args) => {
+    const account = str(args.account);
+    if (!account) throw new TrainError('bad_request', 'missing account');
+    const accountId = accountFor({ account });
+    const client = clientFor(accountId);
+    const directory = directories.get(client) ?? new ChannelDirectory();
+    directories.set(client, directory);
+    const result = await directory.list(accountId, args, () =>
+      guard(() => fetchChannels(accountId, client.tg)),
+    );
+    respond(id, { result });
+  };
+}
+
+function makeListMembers(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { client, chatId } = resolve(args, clientFor);
+    const limit = typeof args.limit === 'number' ? args.limit : undefined;
+    try {
+      respond(id, { result: await fetchMembers(client, chatId, limit) });
+    } catch (e) {
+      const msg = errMsg(e);
+      if (isRestricted(msg)) {
+        respond(id, { result: restrictedMemberList(msg) });
+        return;
+      }
+      throw e;
+    }
+  };
+}
+
+function makeGroupCreate(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const client = clientFor(accountId);
+    respond(id, {
+      result: await guard(() => groupCreate(client, accountId, args)),
+    });
+  };
+}
+
+function makeGroupAdd(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { client, chatId } = resolve(args, clientFor);
+    const line = lineOfArgs(args);
+    respond(id, {
+      result: await guard(() => groupAddMembers(client, chatId, line, args)),
+    });
+  };
+}
+
+function makeGroupRemove(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { client, chatId } = resolve(args, clientFor);
+    const line = lineOfArgs(args);
+    respond(id, {
+      result: await guard(() => groupRemoveMembers(client, chatId, line, args)),
+    });
+  };
+}
+
+function makeGroupInvite(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { client, chatId } = resolve(args, clientFor);
+    const line = lineOfArgs(args);
+    respond(id, {
+      result: await guard(() => groupInviteLink(client, chatId, line)),
+    });
+  };
+}
+
+function makeAccounts(clientFor: ClientFor): StationHandler {
+  return (id) => {
+    const list = [...accounts.values()].map((a) => {
+      const me = clientFor(a.id).self();
+      const username = me?.username ?? null;
+      return {
+        id: a.id,
+        handle: username === null ? me?.phone ?? null : `@${username}`,
+        url: username === null ? null : `https://t.me/${username}`,
+      };
+    });
+    respond(id, { result: { accounts: list } });
+    return Promise.resolve();
+  };
+}
+
+export function makeHandleCall(
+  clientFor: ClientFor,
+): (msg: CallMsg) => Promise<void> {
+  return makeStation({
+    handlers: {
+      accounts: makeAccounts(clientFor),
+      send: makeSend(clientFor),
+      react: makeReact(clientFor),
+      edit: makeEdit(clientFor),
+      delete: makeDelete(clientFor),
+      read: makeRead(clientFor),
+      listChannels: makeListChannels(clientFor),
+      listMembers: makeListMembers(clientFor),
+      groupCreate: makeGroupCreate(clientFor),
+      groupAddMembers: makeGroupAdd(clientFor),
+      groupRemoveMembers: makeGroupRemove(clientFor),
+      groupInviteLink: makeGroupInvite(clientFor),
+      set_profile: makeSetProfile(clientFor),
+      profile: makeReadProfile(clientFor),
+    },
+    normalize: messagingAliases(),
+  });
+}

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

@@ -0,0 +1,87 @@
+import type { Message } from '@mtcute/bun';
+import { FileLocation } from '@mtcute/bun';
+import {
+  saveBufferToCache,
+  type SavedAttachment,
+} from '@metro-labs/core/stations/attachments';
+import type { UserClient } from './client.js';
+
+type Media = NonNullable<Message['media']>;
+export type DownloadableMedia = Media & FileLocation;
+
+export function isDownloadable(media: Media): media is DownloadableMedia {
+  return media instanceof FileLocation;
+}
+
+interface MediaMeta {
+  mime?: string;
+  name?: string;
+}
+
+function fallbackMime(media: DownloadableMedia): string | undefined {
+  const type = (media as { type?: unknown }).type;
+  if (type === 'photo') return 'image/jpeg';
+  if (type === 'sticker') return 'image/webp';
+  return undefined;
+}
+
+function metaOf(media: DownloadableMedia): MediaMeta {
+  const withMime = media as { mimeType?: unknown };
+  const withName = media as { fileName?: unknown };
+  const mime =
+    (typeof withMime.mimeType === 'string' ? withMime.mimeType : undefined) ??
+    fallbackMime(media);
+  const name =
+    typeof withName.fileName === 'string' ? withName.fileName : undefined;
+  return {
+    ...(mime ? { mime } : {}),
+    ...(name ? { name } : {}),
+  };
+}
+
+export interface PendingDescriptor {
+  kind: string;
+  name?: string;
+}
+
+const KIND_BY_TYPE: Record<string, string> = {
+  photo: 'image',
+  sticker: 'image',
+  voice: 'audio',
+  audio: 'audio',
+  video: 'video',
+  video_note: 'video',
+  animation: 'video',
+};
+
+function mediaType(media: DownloadableMedia): string {
+  const type = (media as { type?: unknown }).type;
+  return typeof type === 'string' ? type : '';
+}
+
+function kindOf(media: DownloadableMedia, mime: string | undefined): string {
+  const byType = KIND_BY_TYPE[mediaType(media)];
+  if (byType) return byType;
+  if (mime?.startsWith('image/')) return 'image';
+  if (mime?.startsWith('audio/')) return 'audio';
+  if (mime?.startsWith('video/')) return 'video';
+  return 'file';
+}
+
+export function pendingDescriptorOf(media: DownloadableMedia): PendingDescriptor {
+  const meta = metaOf(media);
+  return {
+    kind: kindOf(media, meta.mime),
+    ...(meta.name ? { name: meta.name } : {}),
+  };
+}
+
+export async function downloadMedia(
+  client: UserClient,
+  media: DownloadableMedia,
+  messageId: string,
+  index = 0,
+): Promise<SavedAttachment> {
+  const buf = await client.tg.downloadAsBuffer(media);
+  return saveBufferToCache(buf, messageId, index, metaOf(media));
+}

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

@@ -0,0 +1,58 @@
+import type { Chat, Dialog, TelegramClient } from '@mtcute/bun';
+import {
+  DIRECTORY_LIMIT,
+  type ChannelEntry,
+  type ChannelSnapshot,
+} from '@metro-labs/core/stations/channel-directory';
+import { lineOf } from './accounts.js';
+
+type DialogOptions = NonNullable<Parameters<TelegramClient['iterDialogs']>[0]>;
+type DialogPeer = Pick<Dialog['peer'], 'id' | 'type' | 'displayName'> &
+  Partial<Pick<Chat, 'chatType'>>;
+
+export interface DialogSource {
+  iterDialogs(params: DialogOptions): AsyncIterable<{ peer: DialogPeer }>;
+}
+
+const SCAN_TIMEOUT_MS = 30_000;
+const TIME_LIMIT_REASON = 'Telegram dialog scan reached its time limit; results are partial.';
+
+const SCANS: DialogOptions[] = [
+  { pinned: 'only', archived: 'exclude' },
+  { pinned: 'only', archived: 'only' },
+  { pinned: 'exclude', archived: 'keep' },
+];
+
+function channelOf(account: string, peer: DialogPeer): ChannelEntry {
+  return {
+    id: String(peer.id),
+    line: lineOf(account, peer.id),
+    ...(peer.displayName ? { name: peer.displayName } : {}),
+    kind: peer.type === 'user' ? 'direct' : peer.chatType === 'channel' ? 'channel' : 'group',
+  };
+}
+
+function partial(channels: ChannelEntry[], reason: string): ChannelSnapshot {
+  return { channels, capability: { supported: true, complete: false, source: 'remote', reason } };
+}
+
+export async function fetchChannels(account: string, source: DialogSource): Promise<ChannelSnapshot> {
+  const channels: ChannelEntry[] = [];
+  const deadline = Date.now() + SCAN_TIMEOUT_MS;
+  for (const scan of SCANS) {
+    if (Date.now() >= deadline) return partial(channels, TIME_LIMIT_REASON);
+    const dialogs = source.iterDialogs({
+      ...scan,
+      limit: DIRECTORY_LIMIT + 1 - channels.length,
+      chunkSize: 100,
+    });
+    for await (const dialog of dialogs) {
+      channels.push(channelOf(account, dialog.peer));
+      if (channels.length > DIRECTORY_LIMIT) {
+        return partial(channels, 'Telegram dialog scan reached the snapshot limit; results are partial.');
+      }
+      if (Date.now() >= deadline) return partial(channels, TIME_LIMIT_REASON);
+    }
+  }
+  return { channels, capability: { supported: true, complete: true, source: 'remote' } };
+}

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

@@ -0,0 +1,77 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { TelegramClient } from '@mtcute/bun';
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
+import { ensureSecureDir } from '@metro-labs/core/secure-fs';
+import type { UserAccount } from './types.js';
+
+const STATE_DIR =
+  process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
+
+export interface Self {
+  username: string | null;
+  phone: string | null;
+}
+
+export interface UserClient {
+  account: UserAccount;
+  tg: TelegramClient;
+  self: () => Self | null;
+  connect: () => Promise<void>;
+  startUpdates: () => Promise<void>;
+  disconnect: () => Promise<void>;
+}
+
+function storagePath(accountId: string): string {
+  const dir = join(STATE_DIR, 'telegram');
+  ensureSecureDir(dir);
+  return join(dir, `${accountId}.session`);
+}
+
+export function createClient(account: UserAccount): UserClient {
+  const apiId = account.apiId ?? 0;
+  const { apiHash } = account;
+  if (!Number.isInteger(apiId) || apiId <= 0 || !apiHash)
+    throw new TrainError(
+      'telegram_auth',
+      `account '${account.id}' missing apiId/apiHash`,
+    );
+  const tg = new TelegramClient({
+    apiId,
+    apiHash,
+    storage: storagePath(account.id),
+  });
+
+  let me: Self | null = null;
+
+  const connect = async (): Promise<void> => {
+    try {
+      await tg.importSession(account.session);
+      await tg.connect();
+    } catch (e) {
+      throw new TrainError(
+        'telegram_auth',
+        `account '${account.id}' connect failed: ${errMsg(e)}`,
+      );
+    }
+    try {
+      const user = await tg.getMe();
+      me = { username: user.username ?? null, phone: user.phoneNumber ?? null };
+    } catch (e) {
+      process.stderr.write(
+        `telegram[${account.id}] identity unavailable: ${errMsg(e)}\n`,
+      );
+    }
+  };
+
+  const startUpdates = async (): Promise<void> => {
+    await tg.startUpdatesLoop();
+  };
+
+  const disconnect = async (): Promise<void> => {
+    await tg.disconnect();
+  };
+
+  return { account, tg, self: () => me, connect, startUpdates, disconnect };
+}

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

@@ -0,0 +1,126 @@
+import type { Chat, Message, Peer, User } from '@mtcute/bun';
+import { lineOf } from './accounts.js';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
+import { isDownloadable, pendingDescriptorOf } from './attachments.js';
+
+const isUser = (peer: Peer): peer is User => peer.type === 'user';
+const isChat = (peer: Peer): peer is Chat => peer.type === 'chat';
+
+export function senderName(peer: Peer): string | undefined {
+  if (isUser(peer)) return peer.username ? `@${peer.username}` : peer.firstName;
+  return peer.title;
+}
+
+export function displayName(peer: Peer): string | undefined {
+  if (!isUser(peer)) return peer.title;
+  const name = [peer.firstName, peer.lastName].filter((part) => typeof part === 'string' && part !== '').join(' ');
+  return name === '' ? undefined : name;
+}
+
+function chatName(peer: Peer): string | undefined {
+  if (isChat(peer)) return peer.title;
+  if (isUser(peer)) return peer.username ? `@${peer.username}` : peer.firstName;
+  return undefined;
+}
+
+function topicOf(m: Message): number | undefined {
+  if (!m.isTopicMessage) return undefined;
+  const threadId = m.replyToMessage?.threadId;
+  return threadId ?? undefined;
+}
+
+function mediaTag(m: Message): string | undefined {
+  if (m.media === null) return undefined;
+  return `[${m.media.type}]`;
+}
+
+function projectText(m: Message): string {
+  const tag = mediaTag(m);
+  return [m.text, tag].filter(Boolean).join(' ');
+}
+
+export function isOwnEcho(m: Message): boolean {
+  if (m.isOutgoing) return true;
+  const { sender } = m;
+  return isUser(sender) && sender.isSelf;
+}
+
+function replyMeta(m: Message): Record<string, unknown> {
+  const replied = m.replyToMessage;
+  const target = replied?.id;
+  if (replied === null || typeof target !== 'number') return {};
+  if (m.isTopicMessage && target === replied.threadId) return {};
+  const id = String(target);
+  const sender = replied.sender;
+  return {
+    reply_to: id,
+    event: { type: 'reply', replyTo: id },
+    reply_to_self: sender?.type === 'user' && sender.isSelf,
+  };
+}
+
+export function envelope(
+  accountId: string,
+  m: Message,
+): Record<string, unknown> {
+  const topicId = topicOf(m);
+  const line = lineOf(accountId, m.chat.id, topicId);
+  const isPrivate = isUser(m.chat);
+  const { media } = m;
+  const attachments =
+    media !== null && isDownloadable(media)
+      ? [pendingDescriptorOf(media)]
+      : undefined;
+  return {
+    id: mintId(),
+    ts: m.date.toISOString(),
+    station: 'telegram',
+    line,
+    line_name: chatName(m.chat),
+    from: `metro://telegram/${accountId}/user/${m.sender.id}`,
+    from_name: senderName(m.sender),
+    from_display_name: displayName(m.sender),
+    message_id: String(m.id),
+    text: projectText(m),
+    is_private: isPrivate,
+    has_media: media !== null,
+    ...replyMeta(m),
+    payload: {
+      account: accountId,
+      message_id: String(m.id),
+      ...(attachments ? { attachments } : {}),
+    },
+  };
+}
+
+export interface ReactionInput {
+  accountId: string;
+  chatId: number;
+  messageId: number;
+  emoji: string;
+  senderId: number;
+  date: Date;
+  isPrivate: boolean;
+  senderName?: string;
+  removed?: boolean;
+}
+
+export function reactionEnvelope(r: ReactionInput): Record<string, unknown> {
+  return {
+    id: mintId(),
+    ts: r.date.toISOString(),
+    station: 'telegram',
+    line: lineOf(r.accountId, r.chatId),
+    from: `metro://telegram/${r.accountId}/user/${r.senderId}`,
+    from_name: r.senderName,
+    message_id: String(r.messageId),
+    emoji: r.emoji,
+    event: { type: 'react', emoji: r.emoji, targetId: String(r.messageId) },
+    is_private: r.isPrivate,
+    payload: {
+      account: r.accountId,
+      message_id: String(r.messageId),
+      removed: r.removed === true,
+    },
+  };
+}