@stage-labs/metro 0.1.0-beta.276 → 0.1.0-beta.277

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

@@ -0,0 +1,186 @@
+import {
+  ChannelDirectory,
+  DIRECTORY_LIMIT,
+  type ChannelEntry,
+  type ChannelSnapshot,
+} 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 { ChannelType, PermissionFlagsBits } from 'discord.js';
+import { accounts, lineOf, type Account } from './accounts.js';
+import {
+  discordChannelSource,
+  type DiscordChannelMetadata,
+  type DiscordChannelSource,
+  type DiscordGuildSource,
+} from './channel-source.js';
+
+const directories = new WeakMap<Account, ChannelDirectory>();
+const GUILD_PAGE = 20;
+const REQUEST_LIMIT = 100;
+const SCAN_MS = 30_000;
+const LIMIT_REASON = `Discovery stopped at the ${DIRECTORY_LIMIT} metadata scan limit; results are partial.`;
+const THREAD_REASON = 'Archived and inaccessible threads are omitted; only accessible active threads are listed.';
+const DM_REASON = 'DMs are limited to channels already cached by this bot; Discord has no complete bot DM directory.';
+
+function kindOf(type: ChannelType): ChannelEntry['kind'] | undefined {
+  switch (type) {
+    case ChannelType.DM: return 'direct';
+    case ChannelType.GroupDM: return 'group';
+    case ChannelType.AnnouncementThread:
+    case ChannelType.PublicThread:
+    case ChannelType.PrivateThread: return 'thread';
+    case ChannelType.GuildCategory: return undefined;
+    default: return 'channel';
+  }
+}
+
+function visible(channel: DiscordChannelMetadata): boolean {
+  if (!channel.permissions?.has(PermissionFlagsBits.ViewChannel)) return false;
+  return channel.type !== ChannelType.PrivateThread || channel.joined === true ||
+    channel.permissions.has(PermissionFlagsBits.ManageThreads);
+}
+
+function inaccessible(error: unknown): boolean {
+  return typeof error === 'object' && error !== null && 'status' in error &&
+    (error.status === 403 || error.status === 404);
+}
+
+class Snapshot {
+  readonly channels = new Map<string, ChannelEntry>();
+  readonly reasons = new Set([THREAD_REASON, DM_REASON]);
+  private scanned = 0;
+  private requests = 0;
+  private readonly started: number;
+  remote = false;
+
+  constructor(private readonly account: string, private readonly now: () => number) {
+    this.started = now();
+  }
+
+  canFetch(cost = 1): boolean {
+    if (this.requests + cost > REQUEST_LIMIT || this.now() - this.started >= SCAN_MS) {
+      this.reasons.add('Discovery request or time budget reached; additional guilds or threads may be missing.');
+      return false;
+    }
+    this.requests += cost;
+    return true;
+  }
+
+  collect(channels: Iterable<DiscordChannelMetadata>, direct = false): boolean {
+    for (const channel of channels) {
+      if (++this.scanned > DIRECTORY_LIMIT) {
+        this.reasons.add(LIMIT_REASON);
+        return false;
+      }
+      this.add(channel, direct);
+    }
+    return true;
+  }
+
+  private add(channel: DiscordChannelMetadata, direct: boolean): void {
+    const kind = kindOf(channel.type);
+    if (!kind || channel.archived) return;
+    if (direct ? kind !== 'direct' && kind !== 'group' : !visible(channel)) return;
+    const line = lineOf(this.account, channel.id);
+    if (!this.channels.has(line)) {
+      this.channels.set(line, {
+        id: channel.id,
+        line,
+        kind,
+        ...(channel.name ? { name: channel.name } : {}),
+      });
+    }
+  }
+
+  result(): ChannelSnapshot {
+    return {
+      channels: [...this.channels.values()],
+      capability: {
+        supported: true,
+        complete: false,
+        source: this.remote ? 'mixed' : 'local',
+        reason: [...this.reasons].join(' '),
+      },
+    };
+  }
+}
+
+async function collectGuild(guild: DiscordGuildSource, snapshot: Snapshot): Promise<boolean> {
+  if (!snapshot.canFetch() || !snapshot.collect(await guild.channels())) return false;
+  if (!snapshot.canFetch()) return false;
+  try {
+    return snapshot.collect(await guild.threads());
+  } catch (error) {
+    if (!inaccessible(error)) throw error;
+    snapshot.reasons.add('Some active threads could not be accessed and were omitted.');
+    return true;
+  }
+}
+
+async function visitGuild(id: string, source: DiscordChannelSource, snapshot: Snapshot): Promise<boolean> {
+  try {
+    return await collectGuild(await source.guild(id), snapshot);
+  } catch (error) {
+    if (!inaccessible(error)) throw error;
+    snapshot.reasons.add('Some guilds or their channel permissions could not be accessed and were omitted.');
+    return true;
+  }
+}
+
+async function collectGuilds(source: DiscordChannelSource, snapshot: Snapshot): Promise<void> {
+  const visited = new Set<string>();
+  let after: string | undefined;
+  for (;;) {
+    if (!snapshot.canFetch()) return;
+    const page = await source.guilds(after, GUILD_PAGE);
+    snapshot.remote = true;
+    const previousSize = visited.size;
+    for (const id of page) {
+      if (visited.has(id)) continue;
+      if (!snapshot.canFetch(2)) return;
+      visited.add(id);
+      if (!await visitGuild(id, source, snapshot)) return;
+    }
+    if (page.length < GUILD_PAGE) return;
+    if (visited.size === previousSize || page.at(-1) === after) {
+      snapshot.reasons.add('Discord guild pagination did not advance; results are partial.');
+      return;
+    }
+    after = page.at(-1);
+  }
+}
+
+export async function loadDiscordChannels(
+  account: string,
+  source: DiscordChannelSource,
+  now: () => number = Date.now,
+): Promise<ChannelSnapshot> {
+  const snapshot = new Snapshot(account, now);
+  if (snapshot.collect(source.directs(), true)) {
+    try {
+      await collectGuilds(source, snapshot);
+    } catch (error) {
+      if (!inaccessible(error)) throw error;
+      snapshot.reasons.add(snapshot.remote
+        ? 'Discord guild pagination became inaccessible; channels from remaining guilds are omitted.'
+        : 'The bot guild directory could not be accessed; only cached DMs are listed.');
+    }
+  }
+  return snapshot.result();
+}
+
+export async function listChannels(id: string, args: Record<string, unknown>): Promise<void> {
+  const { account } = args;
+  if (typeof account !== 'string' || !account.trim())
+    throw new TrainError('bad_request', 'account is required to list Discord channels');
+  const bot = accounts.get(account);
+  if (!bot) throw new TrainError('bad_request', `Unknown Discord account '${account}'`);
+  const directory = directories.get(bot) ?? new ChannelDirectory();
+  directories.set(bot, directory);
+  const result = await directory.list(account, args, () => {
+    if (!bot.client.isReady()) throw new TrainError('unavailable', 'Discord bot is not ready');
+    return loadDiscordChannels(account, discordChannelSource(bot.client));
+  });
+  respond(id, { result });
+}

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

@@ -19,5 +19,6 @@ export const discordBotStation: Station = {
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
   readsProfiles: true,
+  discoversChannels: true,
   tools: [],
 };

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

@@ -1,5 +1,6 @@
 import { makeStation, respond } from '@metro-labs/core/stations/station-runtime';
 import { accountOf, accounts } from './accounts.js';
+import { listChannels } from './channels.js';
 import { MAILBOX_URL } from './config.js';
 import { reply, send } from './outbound.js';
 import { read } from './query.js';
@@ -15,5 +16,5 @@ async function disconnect(id: string, args: Record<string, unknown>): Promise<vo
 }
 
 export const handleCall = makeStation({
-  handlers: { accounts: listAccounts, send, reply, read, disconnect },
+  handlers: { accounts: listAccounts, listChannels, send, reply, read, disconnect },
 });

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

@@ -0,0 +1,66 @@
+import type { ChannelEntry } from '@metro-labs/core/stations/channel-directory';
+import { ChannelPages, type ChannelPage } from '@metro-labs/core/stations/channel-pages';
+import { mailLine } from '@metro-labs/core/stations/mail';
+import { firstHeader, type MailHeader } from '@metro-labs/core/stations/mail-trust';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountOf, type Account } from './accounts.js';
+import { gmailJson, queryOf, USER } from './api.js';
+
+const BATCH = 10;
+const SCOPE = 'Matches thread ids, lines and subjects in Gmail mailbox order, excluding Spam and Trash.';
+const directories = new WeakMap<Account, ChannelPages>();
+
+interface ThreadPage {
+  threads?: { id?: string }[];
+  nextPageToken?: string;
+}
+
+interface ThreadSubject {
+  messages?: { payload?: { headers?: MailHeader[] } }[];
+}
+
+async function threadEntry(acct: Account, id: string, signal: AbortSignal): Promise<ChannelEntry> {
+  const params: [string, string][] = [
+    ['format', 'metadata'],
+    ['metadataHeaders', 'Subject'],
+    ['fields', 'messages(payload(headers(name,value)))'],
+  ];
+  const thread = await gmailJson<ThreadSubject>(acct, `${USER}/threads/${encodeURIComponent(id)}?${queryOf(params)}`, { redirect: 'error', signal });
+  const subject = firstHeader(thread.messages?.[0]?.payload?.headers ?? [], 'subject') ?? '';
+  return { id, line: mailLine('gmail', acct.id, id), kind: 'thread', ...(subject ? { name: subject } : {}) };
+}
+
+async function loadPage(account: Account, token: string | undefined, limit: number, seen: ReadonlySet<string>): Promise<ChannelPage> {
+  const signal = AbortSignal.timeout(45_000);
+  const params: [string, string][] = [
+    ['maxResults', String(limit)],
+    ['fields', 'threads(id),nextPageToken'],
+    ...(token ? [['pageToken', token] as [string, string]] : []),
+  ];
+  const page = await gmailJson<ThreadPage>(account, `${USER}/threads?${queryOf(params)}`, { redirect: 'error', signal });
+  const rows = page.threads ?? [];
+  if (rows.length > limit) throw new TrainError('gmail_channel_page', 'Gmail returned more thread metadata than requested.');
+  const ids = new Set<string>();
+  for (const row of rows) {
+    if (!row.id || row.id.length > 1024) throw new TrainError('gmail_channel_page', 'Gmail returned invalid thread metadata.');
+    if (!seen.has(row.id)) ids.add(row.id);
+  }
+  const channels: ChannelEntry[] = [];
+  const unique = [...ids];
+  for (let i = 0; i < unique.length; i += BATCH) {
+    channels.push(...await Promise.all(unique.slice(i, i + BATCH).map((id) => threadEntry(account, id, signal))));
+  }
+  return { channels, scanned: rows.length, ...(page.nextPageToken ? { next: page.nextPageToken } : {}) };
+}
+
+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', 'account is required to list channels.');
+  const account = accountOf({ account: args.account });
+  account.check();
+  const directory = directories.get(account) ?? new ChannelPages();
+  directories.set(account, directory);
+  const result = await directory.list(account.id, args, (token, limit, seen) => loadPage(account, token, limit, seen), SCOPE);
+  account.check();
+  respond(id, { result });
+}

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

@@ -5,6 +5,7 @@ export const gmailStation: Station = {
   name: 'gmail',
   hasAccounts: true,
   hasTrain: true,
+  discoversChannels: true,
   messageVerbs: new Set<Verb>(['send', 'reply', 'read']),
   readFilters: new Set<ReadFilter>(['account', 'query', 'from', 'until', 'unread_only', 'message_id']),
   approvals: false,

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

@@ -1,5 +1,6 @@
 import { makeStation, respond } from '@metro-labs/core/stations/station-runtime';
 import { accounts } from './accounts.js';
+import { listChannels } from './channels.js';
 import { MAILBOX_URL } from './config.js';
 import { reply, send } from './outbound.js';
 import { read } from './query.js';
@@ -10,5 +11,5 @@ function listAccounts(id: string): void {
 }
 
 export const handleCall = makeStation({
-  handlers: { accounts: listAccounts, send, reply, read },
+  handlers: { accounts: listAccounts, listChannels, send, reply, read },
 });

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

@@ -0,0 +1,60 @@
+import { ChannelPages, type ChannelPage } from '@metro-labs/core/stations/channel-pages';
+import { mailLine } from '@metro-labs/core/stations/mail';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountOf, type Account } from './accounts.js';
+import { graphBase } from './config.js';
+import { graphJson } from './graph.js';
+
+const FIELDS = 'conversationId,subject';
+const ORDER = 'receivedDateTime desc';
+const PARAMS = new Set(['$select', '$orderby', '$top', '$skip', '$skiptoken']);
+const SCOPE = 'Matches thread ids, lines and the newest encountered subject across up to 5000 Outlook message records, newest first; repeated conversations are returned once.';
+const directories = new WeakMap<Account, ChannelPages>();
+
+interface MessagePage {
+  value?: { conversationId?: string; subject?: string | null }[];
+  '@odata.nextLink'?: string;
+}
+
+const refused = (): never => { throw new TrainError('outlook_channel_page', 'Outlook returned an unsafe metadata page link.'); };
+
+function checkParams(params: URLSearchParams): void {
+  for (const key of params.keys()) {
+    if (!PARAMS.has(key) || params.getAll(key).length !== 1) refused();
+  }
+  const select = params.get('$select');
+  const order = params.get('$orderby');
+  if ((select !== null && select !== FIELDS) || (order !== null && order !== ORDER)) refused();
+}
+
+function pageUrl(next: string | undefined, limit: number): string {
+  const base = new URL(`${graphBase()}/me/messages`);
+  const url = next === undefined ? base : new URL(next);
+  if (url.origin !== base.origin || url.pathname !== base.pathname || url.username || url.password || url.hash) refused();
+  checkParams(url.searchParams);
+  url.searchParams.set('$select', FIELDS);
+  url.searchParams.set('$orderby', ORDER);
+  url.searchParams.set('$top', String(limit));
+  return url.toString();
+}
+
+async function loadPage(account: Account, next: string | undefined, limit: number): Promise<ChannelPage> {
+  const page = await graphJson<MessagePage>(account, pageUrl(next, limit), { redirect: 'error', signal: AbortSignal.timeout(45_000) });
+  const rows = page.value ?? [];
+  const channels = rows.map((row) => {
+    if (!row.conversationId || row.conversationId.length > 1024) throw new TrainError('outlook_channel_page', 'Outlook returned invalid conversation metadata.');
+    return { id: row.conversationId, line: mailLine('outlook', account.id, row.conversationId), kind: 'thread' as const, ...(row.subject ? { name: row.subject } : {}) };
+  });
+  const token = page['@odata.nextLink'];
+  return { channels, scanned: rows.length, ...(token ? { next: pageUrl(token, limit) } : {}) };
+}
+
+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', 'account is required to list channels.');
+  const account = accountOf({ account: args.account });
+  const directory = directories.get(account) ?? new ChannelPages();
+  directories.set(account, directory);
+  const result = await directory.list(account.id, args, (token, limit) => loadPage(account, token, limit), SCOPE);
+  respond(id, { result });
+}

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

@@ -5,6 +5,7 @@ export const outlookStation: Station = {
   name: 'outlook',
   hasAccounts: true,
   hasTrain: true,
+  discoversChannels: true,
   messageVerbs: new Set<Verb>(['send', 'reply', 'read']),
   readFilters: new Set<ReadFilter>(['account', 'query', 'from', 'until', 'unread_only', 'message_id']),
   approvals: false,

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

@@ -13,6 +13,8 @@ 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';
@@ -159,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);
@@ -243,6 +261,7 @@ export function makeHandleCall(
       edit: makeEdit(clientFor),
       delete: makeDelete(clientFor),
       read: makeRead(clientFor),
+      listChannels: makeListChannels(clientFor),
       listMembers: makeListMembers(clientFor),
       groupCreate: makeGroupCreate(clientFor),
       groupAddMembers: makeGroupAdd(clientFor),

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/station.ts

@@ -23,5 +23,6 @@ export const telegramStation: Station = {
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
   readsProfiles: true,
+  discoversChannels: true,
   tools: [],
 };

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

@@ -15,6 +15,7 @@ import {
   sendMedia,
 } from './media-actions.js';
 import { readProfile, setProfile } from './profile.js';
+import { listChannels } from './channels.js';
 
 export type { CallMsg };
 
@@ -230,6 +231,7 @@ const HANDLERS: Record<string, StationHandler> = {
   edit,
   delete: remove,
   listMembers,
+  listChannels,
   set_profile: setProfile,
   profile: readProfile,
 };

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/index.ts

@@ -1,44 +1,13 @@
 import { errMsg } from '@metro-labs/core/log';
 import { accounts, loadAccounts, tg, type Account } from './accounts.js';
-import { emitInbound } from '@metro-labs/core/stations/train-events';
 import { announceAccounts } from '@metro-labs/core/stations/train-boot';
-import {
-  envelope,
-  reactionCountEnvelope,
-  reactionEnvelope,
-  saveMediaAndEmit,
-  type TgMsg,
-  type TgReaction,
-  type TgReactionCount,
-} from './format.js';
 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(id, env);
-    saveMediaAndEmit(id, u.message, env.id as string);
-  }
-  if (u.message_reaction) {
-    const env = reactionEnvelope(id, u.message_reaction);
-    if (env) emitInbound(id, env);
-  }
-  if (u.message_reaction_count) {
-    const env = reactionCountEnvelope(id, u.message_reaction_count);
-    if (env) emitInbound(id, env);
-  }
-}
-
 async function runAccount(acct: Account): Promise<void> {
   const { id } = acct.cfg;
   try {
@@ -57,7 +26,7 @@ async function runAccount(acct: Account): Promise<void> {
 
   for (;;) {
     try {
-      const updates = await tg<Update[]>(
+      const updates = await tg<TgUpdate[]>(
         id,
         'getUpdates',
         {
@@ -65,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',
           ],