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

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

@@ -1,128 +1,87 @@
+import type { Message } from '@mtcute/bun';
+import { FileLocation } from '@mtcute/bun';
 import {
   saveBufferToCache,
-  assertContentLength,
-} from '@metro-labs/mcp/stations/attachments';
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
-import { tg, accounts } from './accounts.js';
-import type { TgMsg } from './types.js';
+  type SavedAttachment,
+} from '@metro-labs/core/stations/attachments';
+import type { UserClient } from './client.js';
 
-export type { SavedAttachment };
+type Media = NonNullable<Message['media']>;
+export type DownloadableMedia = Media & FileLocation;
 
-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';
+export function isDownloadable(media: Media): media is DownloadableMedia {
+  return media instanceof FileLocation;
 }
 
-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;
+interface MediaMeta {
+  mime?: string;
+  name?: string;
 }
 
-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';
+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;
 }
 
-export interface TgMediaRef {
-  fileId: string;
+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;
-  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,
-];
+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 mediaRefOf(m: TgMsg): TgMediaRef | null {
-  for (const extract of MEDIA_EXTRACTORS) {
-    const ref = extract(m);
-    if (ref) return ref;
-  }
-  return null;
+export function pendingDescriptorOf(media: DownloadableMedia): PendingDescriptor {
+  const meta = metaOf(media);
+  return {
+    kind: kindOf(media, meta.mime),
+    ...(meta.name ? { name: meta.name } : {}),
+  };
 }
 
-export async function saveTelegramMedia(
-  accountId: string,
-  ref: TgMediaRef,
+export async function downloadMedia(
+  client: UserClient,
+  media: DownloadableMedia,
   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 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 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 };
+  const buf = await client.tg.downloadAsBuffer(media);
+  return saveBufferToCache(buf, messageId, index, metaOf(media));
 }

package/runtime/node_modules/@metro-labs/{telegram-user → telegram}/src/client.ts

@@ -2,8 +2,8 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { mkdirSync } from 'node:fs';
 import { TelegramClient } from '@mtcute/bun';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
 import type { UserAccount } from './types.js';
 
 const STATE_DIR =
@@ -24,7 +24,7 @@ export interface UserClient {
 }
 
 function storagePath(accountId: string): string {
-  const dir = join(STATE_DIR, 'telegram-user');
+  const dir = join(STATE_DIR, 'telegram');
   mkdirSync(dir, { recursive: true });
   return join(dir, `${accountId}.session`);
 }
@@ -34,7 +34,7 @@ export function createClient(account: UserAccount): UserClient {
   const { apiHash } = account;
   if (!Number.isInteger(apiId) || apiId <= 0 || !apiHash)
     throw new TrainError(
-      'telegram_user_auth',
+      'telegram_auth',
       `account '${account.id}' missing apiId/apiHash`,
     );
   const tg = new TelegramClient({
@@ -51,7 +51,7 @@ export function createClient(account: UserAccount): UserClient {
       await tg.connect();
     } catch (e) {
       throw new TrainError(
-        'telegram_user_auth',
+        'telegram_auth',
         `account '${account.id}' connect failed: ${errMsg(e)}`,
       );
     }
@@ -60,7 +60,7 @@ export function createClient(account: UserAccount): UserClient {
       me = { username: user.username ?? null, phone: user.phoneNumber ?? null };
     } catch (e) {
       process.stderr.write(
-        `telegram-user[${account.id}] identity unavailable: ${errMsg(e)}\n`,
+        `telegram[${account.id}] identity unavailable: ${errMsg(e)}\n`,
       );
     }
   };

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

@@ -1,172 +1,126 @@
-import { errMsg } from '@metro-labs/mcp/log';
-import { accounts, lineOf } from './accounts.js';
-import { mintId, SELF_URI } from './wire.js';
-import { mediaRefOf, saveTelegramMedia } from './attachments.js';
-import type { TgMsg, TgReaction, TgReactionCount } from './types.js';
+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';
 
-export type { TgMsg, TgReaction, TgReactionCount };
+const isUser = (peer: Peer): peer is User => peer.type === 'user';
+const isChat = (peer: Peer): peer is Chat => peer.type === 'chat';
 
-function lineForMsg(
-  accountId: string,
-  m: TgMsg,
-): { line: string; topicId?: number } {
-  const topicId = m.is_topic_message ? m.message_thread_id : undefined;
-  return { line: lineOf(accountId, m.chat.id, topicId), topicId };
+export function senderName(peer: Peer): string | undefined {
+  if (isUser(peer)) return peer.username ? `@${peer.username}` : peer.firstName;
+  return peer.title;
 }
 
-function stickerTag(s: NonNullable<TgMsg['sticker']>): string {
-  const set = s.set_name ? ` · ${s.set_name}` : '';
-  return `[sticker${s.emoji ? ` ${s.emoji}` : ''}${set}]`;
+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;
 }
 
-const TAG_EXTRACTORS: ((m: TgMsg) => string | null)[] = [
-  (m) => (m.photo?.length ? '[image]' : null),
-  (m) => (m.voice ? '[voice]' : null),
-  (m) => (m.audio ? `[audio: ${m.audio.file_name ?? 'audio'}]` : null),
-  (m) => (m.video ? `[video: ${m.video.file_name ?? 'video'}]` : null),
-  (m) => (m.animation ? `[gif: ${m.animation.file_name ?? 'gif'}]` : null),
-  (m) => (m.sticker ? stickerTag(m.sticker) : null),
-  (m) =>
-    m.document && !m.animation
-      ? `[file: ${m.document.file_name ?? 'doc'}]`
-      : null,
-  (m) =>
-    m.location
-      ? `[location: ${m.location.latitude}, ${m.location.longitude}]`
-      : null,
-  (m) => (m.dice ? `[dice ${m.dice.emoji} = ${m.dice.value}]` : null),
-];
+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 projectText(m: TgMsg): string {
-  const tags = TAG_EXTRACTORS.map((f) => f(m)).filter(
-    (t): t is string => t !== null,
-  );
-  return [m.text ?? m.caption, ...tags].filter(Boolean).join(' ');
+function topicOf(m: Message): number | undefined {
+  if (!m.isTopicMessage) return undefined;
+  const threadId = m.replyToMessage?.threadId;
+  return threadId ?? undefined;
 }
 
-export function envelope(accountId: string, m: TgMsg): Record<string, unknown> {
-  const { line } = lineForMsg(accountId, m);
-  return {
-    kind: 'inbound',
-    id: mintId(),
-    ts: new Date(m.date * 1000).toISOString(),
-    station: 'telegram',
-    line,
-    line_name: m.chat.title ?? m.chat.first_name ?? undefined,
-    from: `metro://telegram/${accountId}/user/${m.from?.id ?? 'unknown'}`,
-    from_name: m.from?.username ? `@${m.from.username}` : m.from?.first_name,
-    from_display_name: m.from?.first_name,
-    message_id: String(m.message_id),
-    text: projectText(m),
-    payload: m,
-    is_private: m.chat.type === 'private',
-  };
+function mediaTag(m: Message): string | undefined {
+  if (m.media === null) return undefined;
+  return `[${m.media.type}]`;
 }
 
-export function reactionEnvelope(
-  accountId: string,
-  r: TgReaction,
-): Record<string, unknown> | null {
-  if (r.user?.is_bot) return null;
-  const newEmojis = r.new_reaction
-    .filter((x) => x.type === 'emoji')
-    .map((x) => x.emoji ?? '');
-  const oldEmojis = r.old_reaction
-    .filter((x) => x.type === 'emoji')
-    .map((x) => x.emoji ?? '');
-  const added = newEmojis.filter((e) => !oldEmojis.includes(e));
-  if (!added.length) return null;
+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 {
-    kind: 'react',
-    id: mintId(),
-    ts: new Date(r.date * 1000).toISOString(),
-    station: 'telegram',
-    line: lineOf(accountId, r.chat.id),
-    from: `metro://telegram/${accountId}/user/${r.user?.id ?? 'unknown'}`,
-    from_name: r.user?.username ? `@${r.user.username}` : r.user?.first_name,
-    from_display_name: r.user?.first_name,
-    message_id: String(r.message_id),
-    emoji: added[0],
-    event: { type: 'react', emoji: added[0], targetId: String(r.message_id) },
-    is_private: r.chat.type === 'private',
-    payload: r,
+    reply_to: id,
+    event: { type: 'reply', replyTo: id },
+    reply_to_self: sender?.type === 'user' && sender.isSelf,
   };
 }
 
-export function reactionCountEnvelope(
+export function envelope(
   accountId: string,
-  rc: TgReactionCount,
-): Record<string, unknown> | null {
-  const emojiReactions = rc.reactions.filter(
-    (r) => r.type.type === 'emoji' && r.type.emoji,
-  );
-  if (!emojiReactions.length) return null;
-  const top = emojiReactions.reduce((a, b) =>
-    b.total_count > a.total_count ? b : a,
-  );
-  const emoji = top.type.emoji ?? '';
-  if (!emoji) return null;
+  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: 'react',
     id: mintId(),
-    ts: new Date(rc.date * 1000).toISOString(),
+    ts: m.date.toISOString(),
     station: 'telegram',
-    line: lineOf(accountId, rc.chat.id),
-    from: `metro://telegram/${accountId}/user/unknown`,
-    message_id: String(rc.message_id),
-    emoji,
-    event: { type: 'react', emoji, targetId: String(rc.message_id) },
-    is_private: rc.chat.type === 'private',
-    payload: rc,
+    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 function emitInbound(
-  emit: (e: unknown) => void,
-  accountId: string,
-  e: Record<string, unknown>,
-): void {
-  const owner = accounts.get(accountId)?.cfg.owner;
-  const payload = {
-    ...(e.payload as Record<string, unknown> | undefined),
-    account: accountId,
-  };
-  emit({ ...e, ...(owner ? { to: owner } : {}), account: accountId, payload });
+export interface ReactionInput {
+  accountId: string;
+  chatId: number;
+  messageId: number;
+  emoji: string;
+  senderId: number;
+  date: Date;
+  isPrivate: boolean;
+  senderName?: string;
+  removed?: boolean;
 }
 
-export function saveMediaAndEmit(
-  emit: (e: unknown) => void,
-  accountId: string,
-  m: TgMsg,
-  sourceEnvId: string,
-): void {
-  const ref = mediaRefOf(m);
-  if (!ref) return;
-  const line = lineForMsg(accountId, m).line;
-  void saveTelegramMedia(accountId, ref, String(m.message_id), 0)
-    .then((saved) => {
-      emitInbound(emit, accountId, {
-        kind: 'inbound',
-        id: mintId(),
-        ts: new Date().toISOString(),
-        station: 'telegram',
-        line,
-        from: SELF_URI || `metro://telegram/${accountId}/self`,
-        text: `📎 saved: ${saved.path}`,
-        payload: {
-          contentType: 'attachmentSaved',
-          attachmentFor: sourceEnvId,
-          index: 0,
-          attachmentPath: saved.path,
-          localPath: saved.path,
-          mime: saved.mime,
-          name: saved.name,
-        },
-      });
-    })
-    .catch((err: unknown) =>
-      process.stderr.write(
-        `telegram media save failed: ${errMsg(err)}\n`,
-      ),
-    );
+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,
+    },
+  };
 }

package/runtime/node_modules/@metro-labs/{telegram-user → telegram}/src/group.ts

@@ -1,9 +1,9 @@
 import type {
   GroupResult,
   MemberOutcome,
-} from '@metro-labs/mcp/stations/types';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
+} from '@metro-labs/core/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
 import type { UserClient } from './client.js';
 import { lineOf } from './accounts.js';
 
@@ -140,7 +140,7 @@ async function createPerMember(
   }
   if (chatId === null)
     throw new TrainError(
-      'telegram_user_call',
+      'telegram_call',
       'could not create group: no requested member could be added',
     );
   for (const m of pending) outcomes.push(await addOne(client, chatId, m));

package/runtime/node_modules/@metro-labs/{telegram-user → telegram}/src/history.ts

@@ -12,7 +12,7 @@ export function clampLimit(limit: unknown): number {
 }
 
 function senderUri(accountId: string, m: Message): string {
-  return `metro://telegram-user/${accountId}/user/${m.sender.id}`;
+  return `metro://telegram/${accountId}/user/${m.sender.id}`;
 }
 
 function textOf(m: Message): string {

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

@@ -0,0 +1,57 @@
+import type { Message } from '@mtcute/bun';
+import { errMsg, log } from '@metro-labs/core/log';
+import { emit } from '@metro-labs/core/stations/station-runtime';
+import { reportAttachment } from '@metro-labs/core/stations/train-events';
+import { envelope, isOwnEcho } from './format.js';
+import { downloadMedia, isDownloadable } from './attachments.js';
+import { subscribeReactions } from './reactions.js';
+import type { UserClient } from './client.js';
+
+function emitMessage(client: UserClient, m: Message): void {
+  log.debug(
+    { train: 'telegram', account: client.account.id, messageId: m.id },
+    'inbound message received',
+  );
+  if (isOwnEcho(m)) return;
+  const env = envelope(client.account.id, m);
+  emit(env);
+  const { media } = m;
+  if (media === null || !isDownloadable(media)) return;
+  reportAttachment(downloadMedia(client, media, String(m.id), 0), {
+    station: 'telegram',
+    account: client.account.id,
+    line: String(env.line),
+    forId: String(env.id),
+    index: 0,
+  });
+}
+
+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[${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[${accountId}] inbound connected\n`);
+  } catch (e) {
+    process.stderr.write(
+      `telegram[${accountId}] connect failed: ${errMsg(e)}\n`,
+    );
+  }
+}