@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

package/runtime/node_modules/@metro-labs/outlook/src/trust.ts

@@ -0,0 +1,41 @@
+import { automatedByHeaders, automatedBySender, domainOf, firstHeader, headerValues, type MailHeader, type Screened } from '@metro-labs/core/stations/mail-trust';
+import type { Account } from './accounts.js';
+import { addressOf, type GraphMessage } from './format.js';
+import { graphJson, messagePath } from './graph.js';
+
+function headerFrom(result: string): string | null {
+  return /header\.from=([^\s;]+)/i.exec(result)?.[1]?.toLowerCase() ?? null;
+}
+
+function passes(result: string, fromDomain: string): boolean {
+  const aligned = headerFrom(result);
+  if (aligned !== null && aligned !== fromDomain) return false;
+  if (/\bdmarc=pass\b/i.test(result)) return true;
+  return /\bcompauth=pass\b/i.test(result) && aligned === fromDomain;
+}
+
+export function senderVerified(headers: MailHeader[], fromAddress: string): boolean {
+  if ((firstHeader(headers, 'x-ms-exchange-organization-authas') ?? '').toLowerCase() === 'internal') return true;
+  const fromDomain = domainOf(fromAddress);
+  if (fromDomain === '') return false;
+  const ours = firstHeader(headers, 'authentication-results');
+  if (ours !== undefined && passes(ours, fromDomain)) return true;
+  const arc = headerValues(headers, 'arc-authentication-results').find((v) => /\bmx\.microsoft\.com\b/i.test(v));
+  return arc !== undefined && passes(arc, fromDomain);
+}
+
+async function headersOf(acct: Account, messageId: string): Promise<MailHeader[]> {
+  const m = await graphJson<{ internetMessageHeaders?: MailHeader[] }>(acct, `${messagePath(messageId)}?$select=internetMessageHeaders`);
+  return m.internetMessageHeaders ?? [];
+}
+
+export async function screen(acct: Account, m: GraphMessage): Promise<Screened> {
+  const from = addressOf(m.from);
+  const keepAutomated = acct.cfg.includeAutomated === true;
+  const bySender = keepAutomated ? null : automatedBySender(from);
+  if (bySender !== null) return { skip: bySender };
+  const headers = await headersOf(acct, m.id);
+  const byHeaders = keepAutomated ? null : automatedByHeaders(headers);
+  if (byHeaders !== null) return { skip: byHeaders };
+  return { verified: senderVerified(headers, from) };
+}

package/runtime/node_modules/@metro-labs/telegram/package.json

@@ -13,16 +13,14 @@
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*",
+    "@metro-labs/core": "workspace:*",
     "@mtcute/bun": "0.30.1"
   },
   "devDependencies": {
-    "@stage-labs/config": "0.1.0-beta.2",
-    "@types/qrcode-terminal": "^0.12.2",
+    "@stage-labs/config": "0.1.0-beta.3",
     "eslint": "^10.3.0",
     "knip": "^6.15.0",
     "madge": "^8.0.0",
-    "qrcode-terminal": "^0.12.0",
     "typescript": "^5"
   }
 }

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

@@ -1,38 +1,26 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import {
   makeAccountStore,
   resolveAccountId,
   type Die,
-} from '@metro-labs/mcp/stations/account-store';
+} from '@metro-labs/core/stations/account-store';
 import type { UserAccount } from './types.js';
 
-const ACCOUNTS_FILE =
-  process.env.TELEGRAM_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'telegram-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');
+function validateAccount(a: UserAccount, die: Die): void {
   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',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['TELEGRAM_ONLY_ACCOUNTS', 'TELEGRAM_ACCOUNTS'],
   validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) validateAccount(a, seen, die);
+    for (const a of raw) validateAccount(a, die);
   },
 });
 
@@ -57,20 +45,13 @@ interface Target {
   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/';
   if (!line.startsWith(prefix)) return undefined;
   const path = line.slice(prefix.length).split('/').filter(Boolean);
-  const { accountId, rest } = splitScoped(path);
+  const [accountId, ...rest] = path;
   const [chatId, topicId] = rest;
-  if (rest.length < 1 || rest.length > 2 || chatId === undefined) return undefined;
+  if (accountId === undefined || chatId === undefined || rest.length > 2) return undefined;
   if (!isSignedInt(chatId)) return undefined;
   if (topicId !== undefined && !isTopic(topicId)) return undefined;
   return {

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

@@ -1,19 +1,22 @@
-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 {
   makeStation,
   respond,
   type CallMsg,
   type StationHandler,
-} from '@metro-labs/mcp/stations/station-runtime';
+} from '@metro-labs/core/stations/station-runtime';
 import { accountFor, accounts, targetOf } from './accounts.js';
 import type { UserClient } from './client.js';
-import { normalizeTelegramUser } from './normalize.js';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
 import {
   sendAttachments,
   type CanonicalAttachment,
 } from './media-actions.js';
+import { ChannelDirectory } from '@metro-labs/core/stations/channel-directory';
+import { fetchChannels } from './channels.js';
 import { clampLimit, shapeHistory } from './history.js';
+import { makeReadProfile, makeSetProfile } from './profile.js';
 import { fetchMembers, isRestricted, restrictedMemberList } from './members.js';
 import {
   groupAddMembers,
@@ -158,6 +161,22 @@ function makeRead(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeListChannels(clientFor: ClientFor): StationHandler {
+  const directories = new WeakMap<UserClient, ChannelDirectory>();
+  return async (id, args) => {
+    const account = str(args.account);
+    if (!account) throw new TrainError('bad_request', 'missing account');
+    const accountId = accountFor({ account });
+    const client = clientFor(accountId);
+    const directory = directories.get(client) ?? new ChannelDirectory();
+    directories.set(client, directory);
+    const result = await directory.list(accountId, args, () =>
+      guard(() => fetchChannels(accountId, client.tg)),
+    );
+    respond(id, { result });
+  };
+}
+
 function makeListMembers(clientFor: ClientFor): StationHandler {
   return async (id, args) => {
     const { client, chatId } = resolve(args, clientFor);
@@ -224,7 +243,6 @@ function makeAccounts(clientFor: ClientFor): StationHandler {
         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 } });
@@ -243,12 +261,15 @@ export function makeHandleCall(
       edit: makeEdit(clientFor),
       delete: makeDelete(clientFor),
       read: makeRead(clientFor),
+      listChannels: makeListChannels(clientFor),
       listMembers: makeListMembers(clientFor),
       groupCreate: makeGroupCreate(clientFor),
       groupAddMembers: makeGroupAdd(clientFor),
       groupRemoveMembers: makeGroupRemove(clientFor),
       groupInviteLink: makeGroupInvite(clientFor),
+      set_profile: makeSetProfile(clientFor),
+      profile: makeReadProfile(clientFor),
     },
-    normalize: normalizeTelegramUser,
+    normalize: messagingAliases(),
   });
 }

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

@@ -3,7 +3,7 @@ import { FileLocation } from '@mtcute/bun';
 import {
   saveBufferToCache,
   type SavedAttachment,
-} from '@metro-labs/mcp/stations/attachments';
+} from '@metro-labs/core/stations/attachments';
 import type { UserClient } from './client.js';
 
 type Media = NonNullable<Message['media']>;

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

@@ -0,0 +1,58 @@
+import type { Chat, Dialog, TelegramClient } from '@mtcute/bun';
+import {
+  DIRECTORY_LIMIT,
+  type ChannelEntry,
+  type ChannelSnapshot,
+} from '@metro-labs/core/stations/channel-directory';
+import { lineOf } from './accounts.js';
+
+type DialogOptions = NonNullable<Parameters<TelegramClient['iterDialogs']>[0]>;
+type DialogPeer = Pick<Dialog['peer'], 'id' | 'type' | 'displayName'> &
+  Partial<Pick<Chat, 'chatType'>>;
+
+export interface DialogSource {
+  iterDialogs(params: DialogOptions): AsyncIterable<{ peer: DialogPeer }>;
+}
+
+const SCAN_TIMEOUT_MS = 30_000;
+const TIME_LIMIT_REASON = 'Telegram dialog scan reached its time limit; results are partial.';
+
+const SCANS: DialogOptions[] = [
+  { pinned: 'only', archived: 'exclude' },
+  { pinned: 'only', archived: 'only' },
+  { pinned: 'exclude', archived: 'keep' },
+];
+
+function channelOf(account: string, peer: DialogPeer): ChannelEntry {
+  return {
+    id: String(peer.id),
+    line: lineOf(account, peer.id),
+    ...(peer.displayName ? { name: peer.displayName } : {}),
+    kind: peer.type === 'user' ? 'direct' : peer.chatType === 'channel' ? 'channel' : 'group',
+  };
+}
+
+function partial(channels: ChannelEntry[], reason: string): ChannelSnapshot {
+  return { channels, capability: { supported: true, complete: false, source: 'remote', reason } };
+}
+
+export async function fetchChannels(account: string, source: DialogSource): Promise<ChannelSnapshot> {
+  const channels: ChannelEntry[] = [];
+  const deadline = Date.now() + SCAN_TIMEOUT_MS;
+  for (const scan of SCANS) {
+    if (Date.now() >= deadline) return partial(channels, TIME_LIMIT_REASON);
+    const dialogs = source.iterDialogs({
+      ...scan,
+      limit: DIRECTORY_LIMIT + 1 - channels.length,
+      chunkSize: 100,
+    });
+    for await (const dialog of dialogs) {
+      channels.push(channelOf(account, dialog.peer));
+      if (channels.length > DIRECTORY_LIMIT) {
+        return partial(channels, 'Telegram dialog scan reached the snapshot limit; results are partial.');
+      }
+      if (Date.now() >= deadline) return partial(channels, TIME_LIMIT_REASON);
+    }
+  }
+  return { channels, capability: { supported: true, complete: true, source: 'remote' } };
+}

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

@@ -1,9 +1,9 @@
 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 { ensureSecureDir } from '@metro-labs/core/secure-fs';
 import type { UserAccount } from './types.js';
 
 const STATE_DIR =
@@ -25,7 +25,7 @@ export interface UserClient {
 
 function storagePath(accountId: string): string {
   const dir = join(STATE_DIR, 'telegram');
-  mkdirSync(dir, { recursive: true });
+  ensureSecureDir(dir);
   return join(dir, `${accountId}.session`);
 }
 

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

@@ -1,7 +1,6 @@
 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 { mintId } from '@metro-labs/core/stations/station-runtime';
 import { isDownloadable, pendingDescriptorOf } from './attachments.js';
 
 const isUser = (peer: Peer): peer is User => peer.type === 'user';
@@ -13,8 +12,9 @@ export function senderName(peer: Peer): string | undefined {
 }
 
 export function displayName(peer: Peer): string | undefined {
-  if (isUser(peer)) return peer.firstName;
-  return peer.title;
+  if (!isUser(peer)) return peer.title;
+  const name = [peer.firstName, peer.lastName].filter((part) => typeof part === 'string' && part !== '').join(' ');
+  return name === '' ? undefined : name;
 }
 
 function chatName(peer: Peer): string | undefined {
@@ -45,6 +45,20 @@ export function isOwnEcho(m: Message): boolean {
   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 {
+    reply_to: id,
+    event: { type: 'reply', replyTo: id },
+    reply_to_self: sender?.type === 'user' && sender.isSelf,
+  };
+}
+
 export function envelope(
   accountId: string,
   m: Message,
@@ -58,7 +72,6 @@ export function envelope(
       ? [pendingDescriptorOf(media)]
       : undefined;
   return {
-    kind: 'inbound',
     id: mintId(),
     ts: m.date.toISOString(),
     station: 'telegram',
@@ -71,6 +84,7 @@ export function envelope(
     text: projectText(m),
     is_private: isPrivate,
     has_media: media !== null,
+    ...replyMeta(m),
     payload: {
       account: accountId,
       message_id: String(m.id),
@@ -79,34 +93,6 @@ export function envelope(
   };
 }
 
-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',
-    line,
-    from: `metro://telegram/${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;
@@ -121,7 +107,6 @@ export interface ReactionInput {
 
 export function reactionEnvelope(r: ReactionInput): Record<string, unknown> {
   return {
-    kind: 'react',
     id: mintId(),
     ts: r.date.toISOString(),
     station: 'telegram',

package/runtime/node_modules/@metro-labs/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';
 

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

@@ -1,36 +1,12 @@
 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 { 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';
 
-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[${accountId}] media save failed: ${errMsg(e)}\n`,
-    );
-  }
-}
-
 function emitMessage(client: UserClient, m: Message): void {
   log.debug(
     { train: 'telegram', account: client.account.id, messageId: m.id },
@@ -39,12 +15,15 @@ function emitMessage(client: UserClient, m: Message): void {
   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[${client.account.id}] media save failed: ${errMsg(err)}\n`,
-      );
-    });
+  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 {

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

@@ -1,46 +1,7 @@
-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 { runClientTrain } from '@metro-labs/core/stations/train-boot';
+import { accounts, loadAccounts } from './accounts.js';
+import { createClient } 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', 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[${id}] inbound failed: ${errMsg(err)}\n`);
-    });
-  process.stderr.write(
-    `telegram train ready (inbound+outbound) — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
-  );
-}
-
-boot();
-
-export { clients, accounts, clientFor, accountFor, lineOf, targetOf };
+runClientTrain({ station: 'telegram', accounts, loadAccounts, createClient, startInbound, makeHandleCall });

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

@@ -1,17 +1,16 @@
 import type { InputMediaLike, Message } from '@mtcute/bun';
 import { InputMedia } from '@mtcute/bun';
-import { isImageMime, isImageExt } from '@metro-labs/mcp/stations/attachments';
+import { isImageMime, isImageExt } from '@metro-labs/core/stations/attachments';
 import type { UserClient } from './client.js';
 
 export interface CanonicalAttachment {
   kind?: string;
   path?: string;
-  url?: string;
   mime?: string;
   name?: string;
 }
 
-const srcOf = (att: CanonicalAttachment): string => att.path ?? att.url ?? '';
+const srcOf = (att: CanonicalAttachment): string => att.path ?? '';
 
 function isImage(att: CanonicalAttachment): boolean {
   if (att.kind === 'image') return true;

package/runtime/node_modules/@metro-labs/telegram/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';
 import type { UserClient } from './client.js';
 
 export interface RawUserMember {

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

@@ -0,0 +1,70 @@
+import type { TelegramClient } from '@mtcute/bun';
+import {
+  assertImage,
+  fieldsOf,
+  parseProfileChange,
+  type ProfileApplied,
+  type ProfileChange,
+} from '@metro-labs/core/stations/profile';
+import { respond, type StationHandler } from '@metro-labs/core/stations/station-runtime';
+import { str } from '@metro-labs/core/str';
+import { makeProfileCache, nonEmpty, type ProfileCache, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountFor } from './accounts.js';
+import type { UserClient } from './client.js';
+
+const BIO_MAX = 70;
+
+export async function applyProfile(tg: TelegramClient, change: ProfileChange): Promise<void> {
+  if (change.name !== undefined || change.bio !== undefined)
+    await tg.updateProfile({
+      ...(change.name === undefined ? {} : { firstName: change.name }),
+      ...(change.bio === undefined ? {} : { bio: change.bio.slice(0, BIO_MAX) }),
+    });
+  if (change.avatar !== undefined) {
+    assertImage(change.avatar);
+    await tg.setMyProfilePhoto({ type: 'photo', media: `file:${change.avatar.path}` });
+  }
+}
+
+export function makeSetProfile(clientFor: (accountId: string) => UserClient): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const change = parseProfileChange(args);
+    await applyProfile(clientFor(accountId).tg, change);
+    const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
+    respond(id, { result });
+  };
+}
+
+const senders = new Map<string, ProfileCache<SenderProfile>>();
+
+function sendersOf(client: UserClient): ProfileCache<SenderProfile> {
+  const held = senders.get(client.account.id);
+  if (held !== undefined) return held;
+  const made = makeProfileCache<SenderProfile>(
+    async (user) => {
+      const full = await client.tg.getFullUser(Number(user));
+      const handle = nonEmpty(full.username);
+      const display = nonEmpty([full.firstName, full.lastName].filter((part) => typeof part === 'string').join(' '));
+      return {
+        id: user,
+        ...(handle === undefined ? {} : { name: `@${handle}` }),
+        ...(display === undefined ? {} : { display_name: display }),
+        ...(nonEmpty(full.bio) === undefined ? {} : { about: nonEmpty(full.bio) }),
+      };
+    },
+    { onError: (user, err) => process.stderr.write(`telegram[${client.account.id}] could not read the profile of ${user}: ${err instanceof Error ? err.message : String(err)}\n`) },
+  );
+  senders.set(client.account.id, made);
+  return made;
+}
+
+export function makeReadProfile(clientFor: (accountId: string) => UserClient): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const user = str(args.user) ?? '';
+    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 sendersOf(clientFor(accountId)).get(user)) ?? { id: user } });
+  };
+}

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

@@ -1,7 +1,7 @@
 import type { tl } from '@mtcute/bun';
 import { getBarePeerId, getMarkedPeerId } from '@mtcute/bun';
-import { errMsg } from '@metro-labs/mcp/log';
-import { emit } from './wire.js';
+import { errMsg } from '@metro-labs/core/log';
+import { emit } from '@metro-labs/core/stations/station-runtime';
 import { reactionEnvelope } from './format.js';
 import type { UserClient } from './client.js';
 

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

@@ -1,4 +1,5 @@
-import type { GroupOp, 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',
@@ -20,5 +21,8 @@ export const telegramStation: Station = {
     'invite_link',
   ]),
   attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  discoversChannels: true,
   tools: [],
 };

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

@@ -3,5 +3,4 @@ export interface UserAccount {
   session: string;
   apiId?: number;
   apiHash?: string;
-  owner?: string;
 }

package/runtime/node_modules/@metro-labs/telegram-bot/package.json

@@ -13,10 +13,10 @@
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*"
+    "@metro-labs/core": "workspace:*"
   },
   "devDependencies": {
-    "@stage-labs/config": "0.1.0-beta.2",
+    "@stage-labs/config": "0.1.0-beta.3",
     "eslint": "^10.3.0",
     "knip": "^6.15.0",
     "madge": "^8.0.0",