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

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

@@ -0,0 +1,46 @@
+import { TrainError } from '@metro-labs/mcp/train-error';
+import { errMsg } from '@metro-labs/mcp/log';
+import { readCalls } from '@metro-labs/mcp/trains/protocol';
+import {
+  accounts,
+  loadAccounts,
+  accountFor,
+  lineOf,
+  targetOf,
+} from './accounts.js';
+import { createClient, type UserClient } from './client.js';
+import { startInbound } from './inbound.js';
+import { makeHandleCall } from './actions.js';
+
+const clients = new Map<string, UserClient>();
+
+function clientFor(accountId: string): UserClient {
+  let client = clients.get(accountId);
+  if (!client) {
+    const account = accounts.get(accountId);
+    if (!account)
+      throw new TrainError('not_implemented', `unknown account '${accountId}'`);
+    client = createClient(account);
+    clients.set(accountId, client);
+  }
+  return client;
+}
+
+const handleCall = makeHandleCall(clientFor);
+
+readCalls('telegram-user', handleCall);
+
+function boot(): void {
+  for (const cfg of loadAccounts()) accounts.set(cfg.id, cfg);
+  for (const id of accounts.keys())
+    startInbound(clientFor(id)).catch((err: unknown) => {
+      process.stderr.write(`telegram-user[${id}] inbound failed: ${errMsg(err)}\n`);
+    });
+  process.stderr.write(
+    `telegram-user train ready (inbound+outbound) — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
+  );
+}
+
+boot();
+
+export { clients, accounts, clientFor, accountFor, lineOf, targetOf };

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

@@ -0,0 +1,166 @@
+import { TelegramClient } from '@mtcute/bun';
+
+export class TelegramUserLoginError extends Error {}
+
+export interface TelegramUserCredentials {
+  apiId: number;
+  apiHash: string;
+  phone: string;
+}
+
+export interface TelegramUserSignedIn {
+  config: { session: string; apiId: number; apiHash: string };
+  identity: { userId: string; displayName: string };
+}
+
+export type TelegramUserStep = '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;
+}): TelegramUserCredentials {
+  const apiId = Number(raw.apiId);
+  if (!Number.isInteger(apiId) || apiId <= 0)
+    throw new TelegramUserLoginError(
+      '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(
+      '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(
+      '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 TelegramUserLogin {
+  private tg: TelegramClient;
+  private phoneCodeHash = '';
+  private closed = false;
+
+  constructor(private creds: TelegramUserCredentials) {
+    this.tg = new TelegramClient({
+      apiId: creds.apiId,
+      apiHash: creds.apiHash,
+      storage: ':memory:',
+    });
+  }
+
+  async requestCode(): Promise<{ step: TelegramUserStep; length: number }> {
+    await this.tg.connect();
+    const sent = await this.tg
+      .sendCode({ phone: this.creds.phone })
+      .catch((err: unknown) => {
+        throw new TelegramUserLoginError(readableAuthError(err));
+      });
+    if (!isSentCode(sent))
+      throw new TelegramUserLoginError(
+        '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'> {
+    const phoneCode = raw.replace(/[^0-9]/g, '');
+    if (phoneCode === '')
+      throw new TelegramUserLoginError('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 TelegramUserLoginError(readableAuthError(err));
+    }
+  }
+
+  async submitPassword(password: string): Promise<TelegramUserSignedIn> {
+    if (password === '')
+      throw new TelegramUserLoginError(
+        '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));
+    }
+  }
+
+  private async exportFor(user: UserLike): Promise<TelegramUserSignedIn> {
+    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-user/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/mcp/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-user/src/members.ts

@@ -0,0 +1,75 @@
+import type { MemberList, MetroMember } from '@metro-labs/mcp/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-user/src/normalize.ts

@@ -0,0 +1,22 @@
+import type { Normalized } from '@metro-labs/mcp/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-user/src/reactions.ts

@@ -0,0 +1,167 @@
+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 { 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-user[${accountId}] reaction normalize failed: ${errMsg(e)}\n`,
+      );
+    }
+  });
+}

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

@@ -0,0 +1,24 @@
+import type { GroupOp, Station, Verb } from '@metro-labs/mcp/stations/types';
+
+export const telegramUserStation: Station = {
+  name: 'telegram-user',
+  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-user/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-user/src/wire.ts

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

package/runtime/node_modules/@metro-labs/webhook/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@metro-labs/webhook",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/station.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/mcp": "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/webhook/src/station.ts

@@ -0,0 +1,40 @@
+import { randomUUID } from 'node:crypto';
+import { Line, asLine } from '@metro-labs/mcp/lines';
+import { mintId, type MetroEvent } from '@metro-labs/mcp/events';
+import type { Endpoint } from '@metro-labs/mcp/endpoints';
+import type { Station, Verb } from '@metro-labs/mcp/stations/types';
+
+const sessionOwner = (sessionId: string): Line =>
+  asLine(`metro://session/${sessionId}`);
+
+export const webhookStation: Station = {
+  name: 'webhook',
+  hasAccounts: true,
+  hasTrain: false,
+  messageVerbs: new Set<Verb>(),
+  attachmentMode: 'none',
+  tools: [],
+};
+
+export function webhookEntry(
+  endpoint: Endpoint,
+  headers: Record<string, string>,
+  body: unknown,
+  method: string,
+  url: string,
+): MetroEvent {
+  const line = Line.webhook(endpoint.id);
+  return {
+    id: mintId(),
+    ts: new Date().toISOString(),
+    station: 'webhook',
+    line,
+    lineName: endpoint.label,
+    from: line,
+    to: endpoint.session ? sessionOwner(endpoint.session) : line,
+    messageId:
+      headers['x-github-delivery'] ?? headers['x-request-id'] ?? randomUUID(),
+    text: `${headers['x-github-event'] ?? headers['x-intercom-topic'] ?? 'event'} ${method} ${url}`,
+    payload: { headers, body },
+  };
+}

package/runtime/node_modules/@metro-labs/whatsapp/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@metro-labs/whatsapp",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/station.ts",
+    "./train": "./src/index.ts",
+    "./login": "./src/login.ts",
+    "./tokens": "./src/token-store.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/mcp": "workspace:*",
+    "baileys": "7.0.0-rc14"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.2",
+    "@types/qrcode-terminal": "^0.12.2",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "qrcode-terminal": "^0.12.0",
+    "typescript": "^5"
+  }
+}