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

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

@@ -1,19 +1,20 @@
-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 { clampLimit, shapeHistory } from './history.js';
+import { makeReadProfile, makeSetProfile } from './profile.js';
 import { fetchMembers, isRestricted, restrictedMemberList } from './members.js';
 import {
   groupAddMembers,
@@ -224,7 +225,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 } });
@@ -248,7 +248,9 @@ export function makeHandleCall(
       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/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,7 @@ export const telegramStation: Station = {
     'invite_link',
   ]),
   attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: 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",

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 {