@stage-labs/metro 0.1.0-beta.20 → 0.1.0-beta.201

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

@@ -1,4 +1,5 @@
-import type { Station, Verb } from '@metro-labs/mcp/stations/types';
+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',
@@ -11,7 +12,16 @@ export const telegramStation: Station = {
     '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

@@ -1,48 +1,6 @@
-export interface TgMsg {
-  message_id: number;
-  date: number;
-  chat: { id: number; type: string; title?: string; first_name?: string };
-  from?: {
-    id: number;
-    username?: string;
-    first_name?: string;
-    is_bot?: boolean;
-  };
-  text?: string;
-  caption?: string;
-  message_thread_id?: number;
-  is_topic_message?: boolean;
-  photo?: { file_id: string; file_size?: number }[];
-  document?: { file_name?: string; file_id?: string; mime_type?: string };
-  voice?: { file_id?: string; duration?: number; mime_type?: string };
-  audio?: { file_id?: string; file_name?: string; mime_type?: string };
-  video?: { file_id?: string; file_name?: string; mime_type?: string };
-  animation?: { file_id?: string; file_name?: string; mime_type?: string };
-  sticker?: { file_id?: string; emoji?: string; set_name?: string };
-  location?: { latitude: number; longitude: number };
-  dice?: { emoji: string; value: number };
-}
-
-export interface TgReaction {
-  chat: { id: number; type: string };
-  message_id: number;
-  user?: {
-    id: number;
-    username?: string;
-    first_name?: string;
-    is_bot?: boolean;
-  };
-  date: number;
-  old_reaction: { type: string; emoji?: string }[];
-  new_reaction: { type: string; emoji?: string }[];
-}
-
-export interface TgReactionCount {
-  chat: { id: number; type: string };
-  message_id: number;
-  date: number;
-  reactions: {
-    type: { type: string; emoji?: string };
-    total_count: number;
-  }[];
+export interface UserAccount {
+  id: string;
+  session: string;
+  apiId?: number;
+  apiHash?: string;
 }

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

@@ -1,3 +1 @@
-export { emit, respond, mintId } from '@metro-labs/mcp/stations/station-runtime';
-
-export const SELF_URI = process.env.METRO_SELF_URI ?? '';
+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 };
+}

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

@@ -0,0 +1,246 @@
+import { accounts, tg, targetOf } from './accounts.js';
+import { respond } from './wire.js';
+import { errMsg } from '@metro-labs/core/log';
+import { normalizeTelegram } from '@metro-labs/core/stations/messaging-normalize';
+import {
+  adminMemberList,
+  inaccessibleMemberList,
+  type TgChatMember,
+} from './members.js';
+import {
+  makeStation,
+  type CallMsg,
+  type StationHandler,
+} from '@metro-labs/core/stations/station-runtime';
+import { mediaKindOf } from './attachments.js';
+import {
+  emitOutbound,
+  finishSend,
+  MEDIA_METHOD_FIELD,
+  sendMedia,
+} from './media-actions.js';
+import { readProfile, setProfile } from './profile.js';
+
+export type { CallMsg };
+
+const meCache = new Map<string, { id: number; username: string | null }>();
+async function getMe(
+  accountId: string,
+): Promise<{ id: number; username: string | null } | null> {
+  const cached = meCache.get(accountId);
+  if (cached) return cached;
+  try {
+    const me = await tg<{ id: number; username?: string }>(
+      accountId,
+      'getMe',
+      {},
+      10_000,
+    );
+    const v = { id: me.id, username: me.username ?? null };
+    meCache.set(accountId, v);
+    return v;
+  } catch {
+    return null;
+  }
+}
+
+async function listAccounts(id: string): Promise<void> {
+  const list = await Promise.all(
+    [...accounts.values()].map(async (a) => {
+      const me = await getMe(a.cfg.id);
+      const username = me?.username ?? null;
+      return {
+        id: a.cfg.id,
+        handle: username === null ? null : `@${username}`,
+        url: username === null ? null : `https://t.me/${username}`,
+        botId: me?.id ?? null,
+        username,
+      };
+    }),
+  );
+  respond(id, { result: { accounts: list } });
+}
+
+interface SendArgs {
+  line: string;
+  text: string;
+  replyTo?: string;
+  parseMode?: string;
+  buttons?: { text: string; url: string }[][];
+  account?: string;
+  attachments?: {
+    kind?: string;
+    path?: string;
+    url?: string;
+    mime?: string;
+    name?: string;
+  }[];
+}
+
+
+type WireAttachment = NonNullable<SendArgs['attachments']>[number];
+
+const attachmentSrc = (att: WireAttachment): string | undefined =>
+  att.path ?? att.url;
+
+const attachmentKind = (att: WireAttachment): string =>
+  mediaKindOf(att.kind, att.mime, attachmentSrc(att) ?? att.name);
+
+async function sendOneAttachment(
+  a: SendArgs,
+  att: WireAttachment,
+  caption: string | undefined,
+): Promise<{ accountId: string; message_id: number; kind: string }> {
+  const kind = attachmentKind(att);
+  const mf = MEDIA_METHOD_FIELD[kind];
+  if (!mf) throw new Error(`telegram-bot cannot send a '${kind}' attachment`);
+  const sent = await sendMedia(mf.method, mf.field, {
+    line: a.line,
+    path: attachmentSrc(att),
+    caption,
+    replyTo: a.replyTo,
+    parseMode: a.parseMode,
+    account: a.account,
+    name: att.name,
+  });
+  return { ...sent, kind };
+}
+
+const captionLabel = (caption: string | undefined, kind: string): string =>
+  caption !== undefined && caption !== '' ? caption : `[${kind}]`;
+
+async function sendAttachments(id: string, a: SendArgs): Promise<void> {
+  const { line, text, replyTo, attachments = [] } = a;
+  let last: { accountId: string; message_id: number } | undefined;
+  const delivered: string[] = [];
+  for (let i = 0; i < attachments.length; i++) {
+    const att = attachments[i];
+    if (!att) continue;
+    const caption = i === 0 ? text : undefined;
+    const sent = await sendOneAttachment(a, att, caption);
+    last = sent;
+    delivered.push(sent.kind);
+    emitOutbound(
+      sent.accountId,
+      line,
+      String(sent.message_id),
+      captionLabel(caption, sent.kind),
+      replyTo,
+    );
+  }
+  if (!last) throw new Error('no attachments were sent');
+  respond(id, {
+    result: {
+      messageId: String(last.message_id),
+      account: last.accountId,
+      attachments: delivered,
+    },
+  });
+}
+
+async function send(id: string, args: Record<string, unknown>): Promise<void> {
+  const a = args as unknown as SendArgs;
+  if (a.attachments?.length) {
+    await sendAttachments(id, a);
+    return;
+  }
+  const { line, text, replyTo, parseMode, buttons, account } = a;
+  const { accountId, chatId, topicId } = targetOf(line, account);
+  const body: Record<string, unknown> = { chat_id: chatId, text };
+  if (topicId !== undefined) body.message_thread_id = topicId;
+  if (replyTo) body.reply_parameters = { message_id: Number(replyTo) };
+  if (parseMode) body.parse_mode = parseMode;
+  if (buttons) body.reply_markup = { inline_keyboard: buttons };
+  const sent = await tg<{ message_id: number }>(accountId, 'sendMessage', body);
+  finishSend(id, accountId, line, String(sent.message_id), text, replyTo);
+}
+
+async function react(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, emoji, account } = args as {
+    line: string;
+    messageId: string;
+    emoji: string;
+    account?: string;
+  };
+  const { accountId, chatId } = targetOf(line, account);
+  await tg(accountId, 'setMessageReaction', {
+    chat_id: chatId,
+    message_id: Number(messageId),
+    reaction: emoji ? [{ type: 'emoji', emoji }] : [],
+  });
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function edit(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, text, parseMode, account } = args as {
+    line: string;
+    messageId: string;
+    text: string;
+    parseMode?: string;
+    account?: string;
+  };
+  const { accountId, chatId } = targetOf(line, account);
+  await tg(accountId, 'editMessageText', {
+    chat_id: chatId,
+    message_id: Number(messageId),
+    text,
+    parse_mode: parseMode,
+  });
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function remove(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, account } = args as {
+    line: string;
+    messageId: string;
+    account?: string;
+  };
+  const { accountId, chatId } = targetOf(line, account);
+  await tg(accountId, 'deleteMessage', {
+    chat_id: chatId,
+    message_id: Number(messageId),
+  });
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function listMembers(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, chatId } = targetOf(line, account);
+  let admins: TgChatMember[];
+  try {
+    admins = await tg<TgChatMember[]>(accountId, 'getChatAdministrators', {
+      chat_id: chatId,
+    });
+  } catch (e) {
+    respond(id, { result: inaccessibleMemberList(errMsg(e)) });
+    return;
+  }
+  let total: number | null = null;
+  try {
+    total = await tg<number>(accountId, 'getChatMemberCount', {
+      chat_id: chatId,
+    });
+  } catch {
+    total = null;
+  }
+  respond(id, { result: adminMemberList(admins, total) });
+}
+
+const HANDLERS: Record<string, StationHandler> = {
+  accounts: (id) => listAccounts(id),
+  send,
+  react,
+  edit,
+  delete: remove,
+  listMembers,
+  set_profile: setProfile,
+  profile: readProfile,
+};
+
+export const handleCall = makeStation({
+  handlers: HANDLERS,
+  normalize: normalizeTelegram,
+});

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

@@ -0,0 +1,128 @@
+import {
+  saveBufferToCache,
+  assertContentLength,
+} from '@metro-labs/core/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/core/stations/attachments';
+import { tg, accounts } from './accounts.js';
+import type { TgMsg } from './types.js';
+
+export type { SavedAttachment };
+
+function isOggRef(mime: string | undefined, ref: string | undefined): boolean {
+  const ext = ref?.split('?')[0]?.split('.').pop()?.toLowerCase();
+  return mime === 'audio/ogg' || ext === 'ogg' || ext === 'oga';
+}
+
+function isVoiceRef(
+  kind: string | undefined,
+  mime: string | undefined,
+  ref: string | undefined,
+): boolean {
+  const isOgg = isOggRef(mime, ref);
+  if (kind === 'voice') return true;
+  if (kind === 'audio') return isOgg;
+  return !kind && isOgg;
+}
+
+export function mediaKindOf(
+  kind: string | undefined,
+  mime: string | undefined,
+  ref: string | undefined,
+): 'image' | 'voice' | 'audio' | 'video' | 'document' {
+  const m = mime ?? '';
+  if (kind === 'image' || m.startsWith('image/')) return 'image';
+  if (isVoiceRef(kind, mime, ref)) return 'voice';
+  if (kind === 'video' || m.startsWith('video/')) return 'video';
+  if (kind === 'audio' || m.startsWith('audio/')) return 'audio';
+  return 'document';
+}
+
+export interface TgMediaRef {
+  fileId: string;
+  name?: string;
+  mime?: string;
+}
+
+const MEDIA_EXTRACTORS: ((m: TgMsg) => TgMediaRef | null)[] = [
+  (m) => {
+    const largest = m.photo?.[m.photo.length - 1];
+    return largest ? { fileId: largest.file_id, mime: 'image/jpeg' } : null;
+  },
+  (m) =>
+    m.document?.file_id
+      ? {
+          fileId: m.document.file_id,
+          name: m.document.file_name,
+          mime: m.document.mime_type,
+        }
+      : null,
+  (m) =>
+    m.video?.file_id
+      ? {
+          fileId: m.video.file_id,
+          name: m.video.file_name,
+          mime: m.video.mime_type ?? 'video/mp4',
+        }
+      : null,
+  (m) =>
+    m.animation?.file_id
+      ? {
+          fileId: m.animation.file_id,
+          name: m.animation.file_name,
+          mime: m.animation.mime_type,
+        }
+      : null,
+  (m) =>
+    m.audio?.file_id
+      ? {
+          fileId: m.audio.file_id,
+          name: m.audio.file_name,
+          mime: m.audio.mime_type,
+        }
+      : null,
+  (m) =>
+    m.voice?.file_id
+      ? { fileId: m.voice.file_id, mime: m.voice.mime_type ?? 'audio/ogg' }
+      : null,
+  (m) =>
+    m.sticker?.file_id
+      ? { fileId: m.sticker.file_id, mime: 'image/webp' }
+      : null,
+];
+
+export function mediaRefOf(m: TgMsg): TgMediaRef | null {
+  for (const extract of MEDIA_EXTRACTORS) {
+    const ref = extract(m);
+    if (ref) return ref;
+  }
+  return null;
+}
+
+export async function saveTelegramMedia(
+  accountId: string,
+  ref: TgMediaRef,
+  messageId: string,
+  index = 0,
+): Promise<SavedAttachment> {
+  const file = await tg<{ file_path?: string }>(accountId, 'getFile', {
+    file_id: ref.fileId,
+  });
+  if (!file.file_path)
+    throw new Error(`telegram-bot getFile returned no file_path for ${ref.fileId}`);
+  const acct = accounts.get(accountId);
+  if (!acct) throw new Error(`unknown account '${accountId}'`);
+  const res = await fetch(`${acct.fileApi}/${file.file_path}`, {
+    signal: AbortSignal.timeout(60_000),
+  });
+  if (!res.ok)
+    throw new Error(
+      `telegram-bot file download ${res.status} for ${file.file_path}`,
+    );
+  assertContentLength(res.headers.get('content-length'));
+  const data = new Uint8Array(await res.arrayBuffer());
+  const saved = await saveBufferToCache(data, messageId, index, {
+    mime: ref.mime,
+    name: ref.name ?? file.file_path,
+  });
+  return { ...saved, name: ref.name };
+}