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

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

@@ -1,295 +1,254 @@
-import { accountFor, accounts, tg, targetOf } from './accounts.js';
-import { respond } from './wire.js';
+import { TrainError } from '@metro-labs/mcp/train-error';
 import { errMsg } from '@metro-labs/mcp/log';
-import { normalizeTelegram } from '@metro-labs/mcp/stations/messaging-normalize';
-import {
-  adminMemberList,
-  inaccessibleMemberList,
-  type TgChatMember,
-} from './members.js';
 import {
   makeStation,
+  respond,
   type CallMsg,
   type StationHandler,
 } from '@metro-labs/mcp/stations/station-runtime';
-import { mediaKindOf } from './attachments.js';
-import { assertContentLength } from '@metro-labs/mcp/stations/attachments';
+import { accountFor, accounts, targetOf } from './accounts.js';
+import type { UserClient } from './client.js';
+import { normalizeTelegramUser } from './normalize.js';
 import {
-  emitOutbound,
-  finishSend,
-  media,
-  MEDIA_METHOD_FIELD,
-  sendDice,
-  sendLocation,
-  sendMedia,
+  sendAttachments,
+  type CanonicalAttachment,
 } from './media-actions.js';
+import { clampLimit, shapeHistory } from './history.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;
+}
 
-export type { CallMsg };
+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 } : {}),
+  };
+}
 
-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;
+async function guard<T>(run: () => Promise<T>): Promise<T> {
   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;
+    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);
   }
 }
 
-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}`,
-        owner: a.cfg.owner ?? null,
-        botId: me?.id ?? null,
-        username,
-      };
-    }),
-  );
-  respond(id, { result: { accounts: list } });
+function attachmentsOf(args: Args): CanonicalAttachment[] {
+  const raw = args.attachments;
+  return Array.isArray(raw) ? (raw as CanonicalAttachment[]) : [];
 }
 
-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;
-  }[];
+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 },
+    });
+  };
 }
 
-
-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 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 };
+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 } });
+  };
 }
 
-const captionLabel = (caption: string | undefined, kind: string): string =>
-  caption !== undefined && caption !== '' ? caption : `[${kind}]`;
+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 } });
+  };
+}
 
-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,
+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 }),
     );
-  }
-  if (!last) throw new Error('no attachments were sent');
-  respond(id, {
-    result: {
-      messageId: String(last.message_id),
-      account: last.accountId,
-      attachments: delivered,
-    },
-  });
+    respond(id, { result: { ok: true, account: accountId } });
+  };
 }
 
-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);
+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) });
+  };
 }
 
-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;
+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;
+    }
   };
-  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;
+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)),
+    });
   };
-  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;
+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)),
+    });
   };
-  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 download(id: string, args: Record<string, unknown>): Promise<void> {
-  const {
-    fileId,
-    outDir = '/tmp',
-    account,
-  } = args as { fileId: string; outDir?: string; account?: string };
-  const accountId = accountFor({ account });
-  const acct = accounts.get(accountId);
-  if (!acct) throw new Error(`unknown account '${accountId}'`);
-  const meta = await tg<{ file_path: string }>(accountId, 'getFile', {
-    file_id: fileId,
-  });
-  const res = await fetch(`${acct.fileApi}/${meta.file_path}`, {
-    signal: AbortSignal.timeout(60_000),
-  });
-  if (!res.ok) throw new Error(`telegram download ${res.status}`);
-  assertContentLength(res.headers.get('content-length'));
-  const data = await res.arrayBuffer();
-  const filename = meta.file_path.split('/').pop() ?? `${fileId}.bin`;
-  const path = `${outDir}/${Date.now()}-${filename}`;
-  await Bun.write(path, data);
-  respond(id, {
-    result: { path, fileSize: data.byteLength, account: accountId },
-  });
+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)),
+    });
+  };
 }
 
-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,
+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)),
     });
-  } catch {
-    total = null;
-  }
-  respond(id, { result: adminMemberList(admins, total) });
+  };
 }
 
-const HANDLERS: Record<string, StationHandler> = {
-  accounts: (id) => listAccounts(id),
-  send,
-  react,
-  edit,
-  delete: remove,
-  listMembers,
-  send_photo: (id, args) =>
-    media(id, 'sendPhoto', 'photo', ((args.caption as string) ?? '') + ' [image]', args),
-  send_document: (id, args) =>
-    media(id, 'sendDocument', 'document', ((args.caption as string) ?? '') + ' [file]', args),
-  send_voice: (id, args) => media(id, 'sendVoice', 'voice', '[voice]', args),
-  send_sticker: (id, args) => media(id, 'sendSticker', 'sticker', '[sticker]', args),
-  send_dice: sendDice,
-  send_location: sendLocation,
-  download,
-};
+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}`,
+        owner: a.owner ?? null,
+      };
+    });
+    respond(id, { result: { accounts: list } });
+    return Promise.resolve();
+  };
+}
 
-export const handleCall = makeStation({
-  handlers: HANDLERS,
-  normalize: normalizeTelegram,
-  preDispatch: (id, action) => {
-    if (action === 'read') {
-      respond(id, { error: "unsupported verb 'read' on telegram" });
-      return true;
-    }
-    return false;
-  },
-});
+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),
+      listMembers: makeListMembers(clientFor),
+      groupCreate: makeGroupCreate(clientFor),
+      groupAddMembers: makeGroupAdd(clientFor),
+      groupRemoveMembers: makeGroupRemove(clientFor),
+      groupInviteLink: makeGroupInvite(clientFor),
+    },
+    normalize: normalizeTelegramUser,
+  });
+}