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

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

@@ -1,38 +1,25 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import {
   makeAccountStore,
   resolveAccountId,
-} from '@metro-labs/mcp/stations/account-store';
-import { Line } from '@metro-labs/mcp/lines';
-
-const ACCOUNTS_FILE =
-  process.env.TELEGRAM_BOT_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'telegram-bot-accounts.json');
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
 
 export interface AccountConfig {
   id: string;
   token: string;
-  owner?: string;
 }
 
 export const { loadAccounts } = makeAccountStore<AccountConfig>({
   prefix: 'telegram-bot',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['TELEGRAM_BOT_ONLY_ACCOUNTS', 'TELEGRAM_BOT_ACCOUNTS'],
   validate(raw, die) {
-    const seenId = new Set<string>();
     const seenTok = new Set<string>();
     for (const a of raw) {
-      if (!a.id) die('account missing id');
       if (!a.token || typeof a.token !== 'string')
         die(`account '${a.id}' missing token`);
-      if (seenId.has(a.id)) die(`duplicate account id '${a.id}'`);
       if (seenTok.has(a.token))
         die(
           `account '${a.id}' reuses a token used by another account (409 on getUpdates)`,
         );
-      seenId.add(a.id);
       seenTok.add(a.token);
     }
   },
@@ -43,6 +30,7 @@ export interface Account {
   api: string;
   fileApi: string;
   offset: number;
+  username?: string;
 }
 export const accounts = new Map<string, Account>();
 
@@ -50,37 +38,15 @@ export async function tg<T>(
   accountId: string,
   method: string,
   body: unknown,
-  timeoutMs = 30_000,
-): Promise<T> {
-  const acct = accounts.get(accountId);
-  if (!acct) throw new Error(`unknown account '${accountId}'`);
-  const res = await fetch(`${acct.api}/${method}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(timeoutMs),
-  });
-  const json = (await res.json()) as {
-    ok: boolean;
-    description?: string;
-    result?: T;
-  };
-  if (!json.ok)
-    throw new Error(`telegram-bot ${method}: ${json.description ?? 'unknown'}`);
-  return json.result as T;
-}
-
-export async function tgForm<T>(
-  accountId: string,
-  method: string,
-  form: FormData,
-  timeoutMs = 60_000,
+  timeoutMs = body instanceof FormData ? 60_000 : 30_000,
 ): Promise<T> {
   const acct = accounts.get(accountId);
   if (!acct) throw new Error(`unknown account '${accountId}'`);
+  const form = body instanceof FormData;
   const res = await fetch(`${acct.api}/${method}`, {
     method: 'POST',
-    body: form,
+    ...(form ? {} : { headers: { 'Content-Type': 'application/json' } }),
+    body: form ? body : JSON.stringify(body),
     signal: AbortSignal.timeout(timeoutMs),
   });
   const json = (await res.json()) as {

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

@@ -1,31 +1,21 @@
-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';
+import { listChannels } from './channels.js';
 
 export type { CallMsg };
 
@@ -59,7 +49,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 +61,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 +73,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 +86,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 +133,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 +158,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 +179,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 +197,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 +227,16 @@ 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,
+  listChannels,
+  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/channel-files.ts

@@ -0,0 +1,3 @@
+import { accountFiles } from '@metro-labs/core/stations/account-files';
+
+export const channelFiles = accountFiles('TELEGRAM_BOT_STATE_DIR', 'telegram-bot-channels-');

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

@@ -0,0 +1,43 @@
+import { ChannelDirectory } from '@metro-labs/core/stations/channel-directory';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accounts, type Account } from './accounts.js';
+import { channelFiles } from './channel-files.js';
+import { ObservedChats } from './observed-chats.js';
+import type { TgUpdate } from './types.js';
+
+interface DiscoveryState {
+  book: ObservedChats;
+  directory: ChannelDirectory;
+}
+
+const states = new WeakMap<Account, DiscoveryState>();
+
+function stateFor(account: Account): DiscoveryState {
+  let state = states.get(account);
+  if (state === undefined) {
+    state = {
+      book: new ObservedChats(account.cfg.id, channelFiles.path(account.cfg.id)),
+      directory: new ChannelDirectory(),
+    };
+    states.set(account, state);
+  }
+  return state;
+}
+
+export const observedChatsFor = (account: Account): ObservedChats => stateFor(account).book;
+
+export function observeChannels(account: string, update: TgUpdate): void {
+  const known = accounts.get(account);
+  if (known !== undefined) observedChatsFor(known).observe(update);
+}
+
+export async function listChannels(id: string, args: Record<string, unknown>): Promise<void> {
+  if (typeof args.account !== 'string' || args.account.trim() === '')
+    throw new TrainError('bad_request', 'listChannels requires an explicit account');
+  const account = accounts.get(args.account);
+  if (account === undefined) throw new TrainError('bad_request', `unknown account '${args.account}'`);
+  const { directory, book } = stateFor(account);
+  const result = await directory.list(account.cfg.id, args, () => Promise.resolve(book.snapshot()));
+  respond(id, { result });
+}

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,44 +1,13 @@
-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,
-  envelope,
-  reactionCountEnvelope,
-  reactionEnvelope,
-  saveMediaAndEmit,
-  type TgMsg,
-  type TgReaction,
-  type TgReactionCount,
-} from './format.js';
-import { readCalls } from '@metro-labs/mcp/trains/protocol';
+import { announceAccounts } from '@metro-labs/core/stations/train-boot';
+import { readCalls } from '@metro-labs/core/trains/protocol';
 import { handleCall } from './actions.js';
+import { handleUpdate } from './updates.js';
+import type { TgUpdate } from './types.js';
 
 readCalls('telegram-bot', handleCall);
 
-interface Update {
-  update_id: number;
-  message?: TgMsg;
-  message_reaction?: TgReaction;
-  message_reaction_count?: TgReactionCount;
-}
-
-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);
-  }
-  if (u.message_reaction) {
-    const env = reactionEnvelope(id, u.message_reaction);
-    if (env) emitInbound(emit, id, env);
-  }
-  if (u.message_reaction_count) {
-    const env = reactionCountEnvelope(id, u.message_reaction_count);
-    if (env) emitInbound(emit, id, env);
-  }
-}
-
 async function runAccount(acct: Account): Promise<void> {
   const { id } = acct.cfg;
   try {
@@ -48,10 +17,16 @@ 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 {
-      const updates = await tg<Update[]>(
+      const updates = await tg<TgUpdate[]>(
         id,
         'getUpdates',
         {
@@ -59,6 +34,8 @@ async function runAccount(acct: Account): Promise<void> {
           timeout: 25,
           allowed_updates: [
             'message',
+            'channel_post',
+            'my_chat_member',
             'message_reaction',
             'message_reaction_count',
           ],
@@ -87,13 +64,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) => {