@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

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

@@ -1,31 +1,20 @@
-import { accountFor, accounts, tg, targetOf } from './accounts.js';
-import { respond } from './wire.js';
-import { errMsg } from '@metro-labs/mcp/log';
-import { normalizeTelegram } from '@metro-labs/mcp/stations/messaging-normalize';
+import { accounts, tg, targetOf } from './accounts.js';
+import { errMsg } from '@metro-labs/core/log';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
 import {
   adminMemberList,
   inaccessibleMemberList,
   type TgChatMember,
 } from './members.js';
-import {
-  makeStation,
-  type CallMsg,
-  type StationHandler,
-} from '@metro-labs/mcp/stations/station-runtime';
+import { makeStation, respond, type CallMsg, type StationHandler } from '@metro-labs/core/stations/station-runtime';
 import { mediaKindOf } from './attachments.js';
-import { assertContentLength } from '@metro-labs/mcp/stations/attachments';
 import {
   emitOutbound,
   finishSend,
-  media,
   MEDIA_METHOD_FIELD,
-  sendDice,
-  sendLocation,
   sendMedia,
 } from './media-actions.js';
-
-
-
+import { readProfile, setProfile } from './profile.js';
 
 export type { CallMsg };
 
@@ -59,7 +48,6 @@ async function listAccounts(id: string): Promise<void> {
         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,
       };
@@ -72,13 +60,10 @@ 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;
   }[];
@@ -87,11 +72,8 @@ interface SendArgs {
 
 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);
+  mediaKindOf(att.kind, att.mime, att.path ?? att.name);
 
 async function sendOneAttachment(
   a: SendArgs,
@@ -103,10 +85,9 @@ async function sendOneAttachment(
   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),
+    path: att.path,
     caption,
     replyTo: a.replyTo,
-    parseMode: a.parseMode,
     account: a.account,
     name: att.name,
   });
@@ -151,13 +132,11 @@ async function send(id: string, args: Record<string, unknown>): Promise<void> {
     await sendAttachments(id, a);
     return;
   }
-  const { line, text, replyTo, parseMode, buttons, account } = a;
+  const { line, text, replyTo, 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);
 }
@@ -178,12 +157,20 @@ async function react(id: string, args: Record<string, unknown>): Promise<void> {
   respond(id, { result: { ok: true, account: accountId } });
 }
 
+async function typing(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, chatId, topicId } = targetOf(line, account);
+  const body: Record<string, unknown> = { chat_id: chatId, action: 'typing' };
+  if (topicId !== undefined) body.message_thread_id = topicId;
+  await tg(accountId, 'sendChatAction', body);
+  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 {
+  const { line, messageId, text, account } = args as {
     line: string;
     messageId: string;
     text: string;
-    parseMode?: string;
     account?: string;
   };
   const { accountId, chatId } = targetOf(line, account);
@@ -191,7 +178,6 @@ async function edit(id: string, args: Record<string, unknown>): Promise<void> {
     chat_id: chatId,
     message_id: Number(messageId),
     text,
-    parse_mode: parseMode,
   });
   respond(id, { result: { ok: true, account: accountId } });
 }
@@ -210,34 +196,6 @@ async function remove(id: string, args: Record<string, unknown>): Promise<void>
   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-bot 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 },
-  });
-}
-
 async function listMembers(
   id: string,
   args: Record<string, unknown>,
@@ -268,28 +226,15 @@ const HANDLERS: Record<string, StationHandler> = {
   accounts: (id) => listAccounts(id),
   send,
   react,
+  typing,
   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,
+  set_profile: setProfile,
+  profile: readProfile,
 };
 
 export const handleCall = makeStation({
   handlers: HANDLERS,
-  normalize: normalizeTelegram,
-  preDispatch: (id, action) => {
-    if (action === 'read') {
-      respond(id, { error: "unsupported verb 'read' on telegram-bot" });
-      return true;
-    }
-    return false;
-  },
+  normalize: messagingAliases(),
 });

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

@@ -1,8 +1,8 @@
 import {
   saveBufferToCache,
   assertContentLength,
-} from '@metro-labs/mcp/stations/attachments';
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
+} 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';
 

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

@@ -1,8 +1,8 @@
-import { errMsg } from '@metro-labs/mcp/log';
 import { accounts, lineOf } from './accounts.js';
-import { mintId, SELF_URI } from './wire.js';
+import { reportAttachment } from '@metro-labs/core/stations/train-events';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
 import { mediaRefOf, saveTelegramMedia } from './attachments.js';
-import type { TgMsg, TgReaction, TgReactionCount } from './types.js';
+import type { TgMsg, TgReaction, TgReactionCount, TgUser } from './types.js';
 
 export type { TgMsg, TgReaction, TgReactionCount };
 
@@ -44,10 +44,42 @@ function projectText(m: TgMsg): string {
   return [m.text ?? m.caption, ...tags].filter(Boolean).join(' ');
 }
 
+const botIdOf = (accountId: string): number | null => {
+  const token = accounts.get(accountId)?.cfg.token ?? '';
+  const id = Number(token.split(':')[0]);
+  return Number.isInteger(id) && id > 0 ? id : null;
+};
+
+function mentionsBot(m: TgMsg, botId: number | null, username: string | undefined): boolean {
+  const text = m.text ?? m.caption ?? '';
+  const handle = username === undefined ? null : `@${username.toLowerCase()}`;
+  return [...(m.entities ?? []), ...(m.caption_entities ?? [])].some((e) => {
+    if (e.type === 'text_mention') return botId !== null && e.user?.id === botId;
+    if (e.type !== 'mention' || handle === null) return false;
+    return text.slice(e.offset, e.offset + e.length).toLowerCase() === handle;
+  });
+}
+
+function addressing(accountId: string, m: TgMsg): Record<string, unknown> {
+  const botId = botIdOf(accountId);
+  const topicRoot = m.is_topic_message === true && m.reply_to_message?.message_id === m.message_thread_id;
+  const replied = topicRoot ? undefined : m.reply_to_message;
+  const replyTo = replied === undefined ? undefined : String(replied.message_id);
+  return {
+    ...(replyTo === undefined ? {} : { reply_to: replyTo, event: { type: 'reply', replyTo } }),
+    mentions_self: mentionsBot(m, botId, accounts.get(accountId)?.username),
+    reply_to_self: botId !== null && replied?.from?.id === botId,
+  };
+}
+
+export const fullName = (u: TgUser | undefined): string | undefined => {
+  const name = [u?.first_name, u?.last_name].filter((part) => typeof part === 'string' && part !== '').join(' ');
+  return name === '' ? undefined : name;
+};
+
 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-bot',
@@ -55,11 +87,12 @@ export function envelope(accountId: string, m: TgMsg): Record<string, unknown> {
     line_name: m.chat.title ?? m.chat.first_name ?? undefined,
     from: `metro://telegram-bot/${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,
+    from_display_name: fullName(m.from),
     message_id: String(m.message_id),
     text: projectText(m),
     payload: m,
     is_private: m.chat.type === 'private',
+    ...addressing(accountId, m),
   };
 }
 
@@ -77,14 +110,13 @@ export function reactionEnvelope(
   const added = newEmojis.filter((e) => !oldEmojis.includes(e));
   if (!added.length) return null;
   return {
-    kind: 'react',
     id: mintId(),
     ts: new Date(r.date * 1000).toISOString(),
     station: 'telegram-bot',
     line: lineOf(accountId, r.chat.id),
     from: `metro://telegram-bot/${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,
+    from_display_name: fullName(r.user),
     message_id: String(r.message_id),
     emoji: added[0],
     event: { type: 'react', emoji: added[0], targetId: String(r.message_id) },
@@ -107,7 +139,6 @@ export function reactionCountEnvelope(
   const emoji = top.type.emoji ?? '';
   if (!emoji) return null;
   return {
-    kind: 'react',
     id: mintId(),
     ts: new Date(rc.date * 1000).toISOString(),
     station: 'telegram-bot',
@@ -121,21 +152,7 @@ export function reactionCountEnvelope(
   };
 }
 
-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 function saveMediaAndEmit(
-  emit: (e: unknown) => void,
   accountId: string,
   m: TgMsg,
   sourceEnvId: string,
@@ -143,30 +160,11 @@ export function saveMediaAndEmit(
   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-bot',
-        line,
-        from: SELF_URI || `metro://telegram-bot/${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-bot media save failed: ${errMsg(err)}\n`,
-      ),
-    );
+  reportAttachment(saveTelegramMedia(accountId, ref, String(m.message_id), 0), {
+    station: 'telegram-bot',
+    account: accountId,
+    line,
+    forId: sourceEnvId,
+    index: 0,
+  });
 }

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

@@ -1,8 +1,8 @@
-import { errMsg } from '@metro-labs/mcp/log';
+import { errMsg } from '@metro-labs/core/log';
 import { accounts, loadAccounts, tg, type Account } from './accounts.js';
-import { emit } from './wire.js';
+import { emitInbound } from '@metro-labs/core/stations/train-events';
+import { announceAccounts } from '@metro-labs/core/stations/train-boot';
 import {
-  emitInbound,
   envelope,
   reactionCountEnvelope,
   reactionEnvelope,
@@ -11,7 +11,7 @@ import {
   type TgReaction,
   type TgReactionCount,
 } from './format.js';
-import { readCalls } from '@metro-labs/mcp/trains/protocol';
+import { readCalls } from '@metro-labs/core/trains/protocol';
 import { handleCall } from './actions.js';
 
 readCalls('telegram-bot', handleCall);
@@ -26,16 +26,16 @@ interface Update {
 function handleUpdate(id: string, u: Update): void {
   if (u.message && !u.message.from?.is_bot) {
     const env = envelope(id, u.message);
-    emitInbound(emit, id, env);
-    saveMediaAndEmit(emit, id, u.message, env.id as string);
+    emitInbound(id, env);
+    saveMediaAndEmit(id, u.message, env.id as string);
   }
   if (u.message_reaction) {
     const env = reactionEnvelope(id, u.message_reaction);
-    if (env) emitInbound(emit, id, env);
+    if (env) emitInbound(id, env);
   }
   if (u.message_reaction_count) {
     const env = reactionCountEnvelope(id, u.message_reaction_count);
-    if (env) emitInbound(emit, id, env);
+    if (env) emitInbound(id, env);
   }
 }
 
@@ -48,6 +48,12 @@ async function runAccount(acct: Account): Promise<void> {
       `telegram-bot[${id}] deleteWebhook: ${errMsg(err)}\n`,
     );
   }
+  try {
+    const me = await tg<{ username?: string }>(id, 'getMe', {});
+    if (typeof me.username === 'string') acct.username = me.username;
+  } catch (err) {
+    process.stderr.write(`telegram-bot[${id}] getMe: ${errMsg(err)}\n`);
+  }
 
   for (;;) {
     try {
@@ -87,13 +93,7 @@ for (const cfg of cfgs) {
     offset: 0,
   });
 }
-if (accounts.size === 0) {
-  process.stderr.write('telegram-bot: no accounts booted, exiting\n');
-  process.exit(2);
-}
-process.stderr.write(
-  `telegram-bot train ready (multi) — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
-);
+announceAccounts('telegram-bot', accounts.keys());
 
 for (const acct of accounts.values())
   runAccount(acct).catch((err: unknown) => {

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

@@ -1,6 +1,7 @@
-import { tg, tgForm, targetOf } from './accounts.js';
-import { emit, mintId, respond, SELF_URI } from './wire.js';
-import { appendFile } from '@metro-labs/mcp/stations/attachments';
+import { tg, targetOf } from './accounts.js';
+import { selfUri } from '@metro-labs/core/stations/train-events';
+import { emit, mintId, respond } from '@metro-labs/core/stations/station-runtime';
+import { appendFile } from '@metro-labs/core/stations/attachments';
 
 export function emitOutbound(
   accountId: string,
@@ -10,18 +11,16 @@ export function emitOutbound(
   replyTo?: string,
 ): void {
   emit({
-    kind: 'outbound',
     id: mintId(),
     ts: new Date().toISOString(),
     station: 'telegram-bot',
     line,
-    from: SELF_URI,
+    from: selfUri(),
     to: line,
     message_id: messageId,
     text,
     reply_to: replyTo,
     ...(replyTo ? { event: { type: 'reply', replyTo } } : {}),
-    account: accountId,
     payload: { account: accountId },
   });
 }
@@ -46,7 +45,6 @@ interface MediaArgs {
   path: string;
   caption?: string;
   replyTo?: string;
-  parseMode?: string;
   account?: string;
   name?: string;
 }
@@ -61,7 +59,6 @@ export async function sendMedia(
     path,
     caption,
     replyTo,
-    parseMode,
     account,
     name: fileName,
   } = args as unknown as MediaArgs;
@@ -70,7 +67,6 @@ export async function sendMedia(
   form.append('chat_id', String(chatId));
   if (topicId !== undefined) form.append('message_thread_id', String(topicId));
   if (caption) form.append('caption', caption);
-  if (parseMode) form.append('parse_mode', parseMode);
   if (replyTo)
     form.append(
       'reply_parameters',
@@ -78,29 +74,10 @@ export async function sendMedia(
     );
   const name = fileName ?? path.split('/').pop() ?? fieldName;
   await appendFile(form, fieldName, path, name);
-  const r = await tgForm<{ message_id: number }>(accountId, method, form);
+  const r = await tg<{ message_id: number }>(accountId, method, form);
   return { accountId, message_id: r.message_id };
 }
 
-export async function media(
-  id: string,
-  method: string,
-  field: string,
-  label: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const { accountId, message_id } = await sendMedia(method, field, args);
-  const line = (args as { line: string }).line;
-  finishSend(
-    id,
-    accountId,
-    line,
-    String(message_id),
-    label,
-    args.replyTo as string | undefined,
-  );
-}
-
 export const MEDIA_METHOD_FIELD: Record<
   string,
   { method: string; field: string }
@@ -111,56 +88,3 @@ export const MEDIA_METHOD_FIELD: Record<
   video: { method: 'sendVideo', field: 'video' },
   document: { method: 'sendDocument', field: 'document' },
 };
-
-export async function sendDice(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const {
-    line,
-    emoji = '\U0001F3B2',
-    account,
-  } = args as { line: string; emoji?: string; account?: string };
-  const { accountId, chatId, topicId } = targetOf(line, account);
-  const body: Record<string, unknown> = { chat_id: chatId, emoji };
-  if (topicId !== undefined) body.message_thread_id = topicId;
-  const r = await tg<{ message_id: number; dice?: { value: number } }>(
-    accountId,
-    'sendDice',
-    body,
-  );
-  finishSend(
-    id,
-    accountId,
-    line,
-    String(r.message_id),
-    `[dice ${emoji} = ${r.dice?.value ?? '?'}]`,
-    undefined,
-    { value: r.dice?.value },
-  );
-}
-
-export async function sendLocation(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const { line, latitude, longitude, account } = args as {
-    line: string;
-    latitude: number;
-    longitude: number;
-    account?: string;
-  };
-  const { accountId, chatId } = targetOf(line, account);
-  const r = await tg<{ message_id: number }>(accountId, 'sendLocation', {
-    chat_id: chatId,
-    latitude,
-    longitude,
-  });
-  finishSend(
-    id,
-    accountId,
-    line,
-    String(r.message_id),
-    `[location: ${latitude}, ${longitude}]`,
-  );
-}

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

@@ -1,4 +1,4 @@
-import type { MemberList, MetroMember } from '@metro-labs/mcp/stations/types';
+import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
 
 export interface TgUser {
   id: number;

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

@@ -0,0 +1,85 @@
+import { appendFile } from '@metro-labs/core/stations/attachments';
+import {
+  assertImage,
+  fieldsOf,
+  parseProfileChange,
+  type ProfileApplied,
+  type ProfileAvatar,
+  type ProfileChange,
+} from '@metro-labs/core/stations/profile';
+import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountFor, accounts, tg } from './accounts.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+
+async function setPhoto(accountId: string, avatar: ProfileAvatar): Promise<void> {
+  assertImage(avatar);
+  const form = new FormData();
+  form.append('photo', JSON.stringify({ type: 'static', photo: 'attach://avatar' }));
+  await appendFile(form, 'avatar', avatar.path, avatar.name);
+  await tg(accountId, 'setMyProfilePhoto', form);
+}
+
+export async function applyProfile(accountId: string, change: ProfileChange): Promise<void> {
+  if (change.name !== undefined) await tg(accountId, 'setMyName', { name: change.name });
+  if (change.bio !== undefined) await tg(accountId, 'setMyDescription', { description: change.bio });
+  if (change.avatar !== undefined) await setPhoto(accountId, change.avatar);
+}
+
+export async function setProfile(id: string, args: Record<string, unknown>): Promise<void> {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const change = parseProfileChange(args);
+  await applyProfile(accountId, change);
+  const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
+  respond(id, { result });
+}
+
+interface TgChat {
+  username?: unknown;
+  first_name?: unknown;
+  last_name?: unknown;
+  bio?: unknown;
+  photo?: { small_file_id?: unknown };
+}
+
+const PHOTO_MAX = 64 * 1024;
+
+async function photoData(accountId: string, fileId: unknown): Promise<string | undefined> {
+  if (typeof fileId !== 'string' || fileId === '') return undefined;
+  try {
+    const file = await tg<{ file_path?: string }>(accountId, 'getFile', { file_id: fileId }, 10_000);
+    const acct = accounts.get(accountId);
+    if (acct === undefined || typeof file.file_path !== 'string') return undefined;
+    const res = await fetch(`${acct.fileApi}/${file.file_path}`, { signal: AbortSignal.timeout(10_000) });
+    if (!res.ok) return undefined;
+    const bytes = Buffer.from(await res.arrayBuffer());
+    return bytes.length === 0 || bytes.length > PHOTO_MAX ? undefined : `data:image/jpeg;base64,${bytes.toString('base64')}`;
+  } catch {
+    return undefined;
+  }
+}
+
+const senders = makeProfileCache<SenderProfile>(
+  async (key) => {
+    const [accountId, user] = key.split(':', 2) as [string, string];
+    const chat = await tg<TgChat>(accountId, 'getChat', { chat_id: Number(user) }, 10_000);
+    const handle = nonEmpty(chat.username);
+    const display = nonEmpty([chat.first_name, chat.last_name].filter((part) => typeof part === 'string').join(' '));
+    const avatar = await photoData(accountId, chat.photo?.small_file_id);
+    return {
+      id: user,
+      ...(handle === undefined ? {} : { name: `@${handle}` }),
+      ...(display === undefined ? {} : { display_name: display }),
+      ...(nonEmpty(chat.bio) === undefined ? {} : { about: nonEmpty(chat.bio) }),
+      ...(avatar === undefined ? {} : { avatar }),
+    };
+  },
+  { onError: (key, err) => process.stderr.write(`telegram-bot: could not read the profile of ${key}: ${err instanceof Error ? err.message : String(err)}\n`) },
+);
+
+export async function readProfile(id: string, args: Record<string, unknown>): Promise<void> {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  if (!/^\d+$/.test(user)) throw new TrainError('telegram_user_required', 'profile needs the numeric Telegram id of the person', { retryable: false });
+  respond(id, { result: (await senders.get(`${accountId}:${user}`)) ?? { id: user } });
+}

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

@@ -1,4 +1,5 @@
-import type { Station, Verb } from '@metro-labs/mcp/stations/types';
+import type { Station, Verb } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
 
 export const telegramBotStation: Station = {
   name: 'telegram-bot',
@@ -11,7 +12,10 @@ export const telegramBotStation: Station = {
     'unreact',
     'edit',
     'delete',
+    'typing',
   ]),
   attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   tools: [],
 };