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

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

@@ -1,81 +0,0 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import {
-  makeAccountStore,
-  resolveAccountId,
-  type Die,
-} from '@metro-labs/mcp/stations/account-store';
-import type { UserAccount } from './types.js';
-
-const ACCOUNTS_FILE =
-  process.env.TELEGRAM_USER_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'telegram-user-accounts.json');
-
-const isSignedInt = (s: string): boolean => /^-?\d+$/.test(s);
-const isTopic = (s: string): boolean => /^\d+$/.test(s);
-
-function validateAccount(a: UserAccount, seen: Set<string>, die: Die): void {
-  if (!a.id) die('account missing id');
-  if (!a.session || typeof a.session !== 'string')
-    die(`account '${a.id}' missing session`);
-  if (!Number.isInteger(a.apiId) || (a.apiId ?? 0) <= 0)
-    die(`account '${a.id}' missing apiId`);
-  if (!a.apiHash || typeof a.apiHash !== 'string')
-    die(`account '${a.id}' missing apiHash`);
-  if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-  seen.add(a.id);
-}
-
-export const { loadAccounts } = makeAccountStore<UserAccount>({
-  prefix: 'telegram-user',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['TELEGRAM_USER_ONLY_ACCOUNTS', 'TELEGRAM_USER_ACCOUNTS'],
-  validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) validateAccount(a, seen, die);
-  },
-});
-
-export const accounts = new Map<string, UserAccount>();
-
-export function accountFor(args: { account?: string; line?: string }): string {
-  return resolveAccountId(accounts, args, (line) => targetOf(line)?.accountId);
-}
-
-export function lineOf(
-  accountId: string,
-  chatId: number | string,
-  topicId?: number,
-): string {
-  const tail = topicId !== undefined ? `${chatId}/${topicId}` : `${chatId}`;
-  return `metro://telegram-user/${accountId}/${tail}`;
-}
-
-interface Target {
-  accountId: string;
-  chatId: number;
-  topicId?: number;
-}
-
-function splitScoped(path: string[]): { accountId: string; rest: string[] } {
-  const first = path[0];
-  if (path.length >= 2 && first !== undefined && !isSignedInt(first))
-    return { accountId: first, rest: path.slice(1) };
-  return { accountId: 'default', rest: path };
-}
-
-export function targetOf(line: string): Target | undefined {
-  const prefix = 'metro://telegram-user/';
-  if (!line.startsWith(prefix)) return undefined;
-  const path = line.slice(prefix.length).split('/').filter(Boolean);
-  const { accountId, rest } = splitScoped(path);
-  const [chatId, topicId] = rest;
-  if (rest.length < 1 || rest.length > 2 || chatId === undefined) return undefined;
-  if (!isSignedInt(chatId)) return undefined;
-  if (topicId !== undefined && !isTopic(topicId)) return undefined;
-  return {
-    accountId,
-    chatId: Number(chatId),
-    ...(topicId !== undefined ? { topicId: Number(topicId) } : {}),
-  };
-}

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

@@ -1,254 +0,0 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
-import {
-  makeStation,
-  respond,
-  type CallMsg,
-  type StationHandler,
-} from '@metro-labs/mcp/stations/station-runtime';
-import { accountFor, accounts, targetOf } from './accounts.js';
-import type { UserClient } from './client.js';
-import { normalizeTelegramUser } from './normalize.js';
-import {
-  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;
-}
-
-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_user_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 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}`,
-        owner: a.owner ?? null,
-      };
-    });
-    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),
-      listMembers: makeListMembers(clientFor),
-      groupCreate: makeGroupCreate(clientFor),
-      groupAddMembers: makeGroupAdd(clientFor),
-      groupRemoveMembers: makeGroupRemove(clientFor),
-      groupInviteLink: makeGroupInvite(clientFor),
-    },
-    normalize: normalizeTelegramUser,
-  });
-}

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

@@ -1,87 +0,0 @@
-import type { Message } from '@mtcute/bun';
-import { FileLocation } from '@mtcute/bun';
-import {
-  saveBufferToCache,
-  type SavedAttachment,
-} from '@metro-labs/mcp/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-user/src/format.ts

@@ -1,141 +0,0 @@
-import type { Chat, Message, Peer, User } from '@mtcute/bun';
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
-import { lineOf } from './accounts.js';
-import { mintId } from './wire.js';
-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.firstName;
-  return peer.title;
-}
-
-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;
-}
-
-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 {
-    kind: 'inbound',
-    id: mintId(),
-    ts: m.date.toISOString(),
-    station: 'telegram-user',
-    line,
-    line_name: chatName(m.chat),
-    from: `metro://telegram-user/${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,
-    payload: {
-      account: accountId,
-      message_id: String(m.id),
-      ...(attachments ? { attachments } : {}),
-    },
-  };
-}
-
-export function attachmentSavedEnvelope(
-  accountId: string,
-  line: string,
-  sourceEnvId: string,
-  saved: SavedAttachment,
-  index = 0,
-): Record<string, unknown> {
-  return {
-    kind: 'inbound',
-    id: mintId(),
-    ts: new Date().toISOString(),
-    station: 'telegram-user',
-    line,
-    from: `metro://telegram-user/${accountId}/self`,
-    text: `📎 saved: ${saved.path}`,
-    payload: {
-      account: accountId,
-      contentType: 'attachmentSaved',
-      attachmentFor: sourceEnvId,
-      index,
-      attachmentPath: saved.path,
-      localPath: saved.path,
-      mime: saved.mime,
-      name: saved.name,
-    },
-  };
-}
-
-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 {
-    kind: 'react',
-    id: mintId(),
-    ts: r.date.toISOString(),
-    station: 'telegram-user',
-    line: lineOf(r.accountId, r.chatId),
-    from: `metro://telegram-user/${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,
-    },
-  };
-}

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

@@ -1,78 +0,0 @@
-import type { Message } from '@mtcute/bun';
-import { errMsg, log } from '@metro-labs/mcp/log';
-import { emit } from './wire.js';
-import { envelope, isOwnEcho, attachmentSavedEnvelope } from './format.js';
-import { downloadMedia, isDownloadable } from './attachments.js';
-import { subscribeReactions } from './reactions.js';
-import type { UserClient } from './client.js';
-
-async function saveMediaAndEmit(
-  client: UserClient,
-  m: Message,
-  env: Record<string, unknown>,
-): Promise<void> {
-  const { media } = m;
-  if (media === null || !isDownloadable(media)) return;
-  const accountId = client.account.id;
-  try {
-    const saved = await downloadMedia(client, media, String(m.id), 0);
-    emit(
-      attachmentSavedEnvelope(
-        accountId,
-        env.line as string,
-        env.id as string,
-        saved,
-      ),
-    );
-  } catch (e) {
-    process.stderr.write(
-      `telegram-user[${accountId}] media save failed: ${errMsg(e)}\n`,
-    );
-  }
-}
-
-function emitMessage(client: UserClient, m: Message): void {
-  log.debug(
-    { train: 'telegram-user', account: client.account.id, messageId: m.id },
-    'inbound message received',
-  );
-  if (isOwnEcho(m)) return;
-  const env = envelope(client.account.id, m);
-  emit(env);
-  if (m.media !== null)
-    saveMediaAndEmit(client, m, env).catch((err: unknown) => {
-      process.stderr.write(
-        `telegram-user[${client.account.id}] media save failed: ${errMsg(err)}\n`,
-      );
-    });
-}
-
-function subscribe(client: UserClient): void {
-  const accountId = client.account.id;
-  const onMessage = (m: Message): void => {
-    try {
-      emitMessage(client, m);
-    } catch (e) {
-      process.stderr.write(
-        `telegram-user[${accountId}] normalize failed: ${errMsg(e)}\n`,
-      );
-    }
-  };
-  client.tg.onNewMessage.add(onMessage);
-  client.tg.onEditMessage.add(onMessage);
-  subscribeReactions(client);
-}
-
-export async function startInbound(client: UserClient): Promise<void> {
-  const accountId = client.account.id;
-  try {
-    subscribe(client);
-    await client.connect();
-    await client.startUpdates();
-    process.stderr.write(`telegram-user[${accountId}] inbound connected\n`);
-  } catch (e) {
-    process.stderr.write(
-      `telegram-user[${accountId}] connect failed: ${errMsg(e)}\n`,
-    );
-  }
-}

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

@@ -1,46 +0,0 @@
-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 };