@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.23

package/runtime/node_modules/@metro-labs/mcp/src/db/materialize.ts

@@ -52,20 +52,20 @@ const STATION_TARGETS: Record<StationName, StationTarget> = {
     fileEnv: 'XMTP_ACCOUNTS_FILE',
     trainImport: '@metro-labs/xmtp/train',
   },
-  telegram: {
+  'telegram-bot': {
+    file: 'telegram-bot-accounts.json',
+    fileEnv: 'TELEGRAM_BOT_ACCOUNTS_FILE',
+    trainImport: '@metro-labs/telegram-bot/train',
+  },
+  'telegram': {
     file: 'telegram-accounts.json',
     fileEnv: 'TELEGRAM_ACCOUNTS_FILE',
     trainImport: '@metro-labs/telegram/train',
   },
-  'telegram-user': {
-    file: 'telegram-user-accounts.json',
-    fileEnv: 'TELEGRAM_USER_ACCOUNTS_FILE',
-    trainImport: '@metro-labs/telegram-user/train',
-  },
-  discord: {
-    file: 'discord-accounts.json',
-    fileEnv: 'DISCORD_ACCOUNTS_FILE',
-    trainImport: '@metro-labs/discord/train',
+  'discord-bot': {
+    file: 'discord-bot-accounts.json',
+    fileEnv: 'DISCORD_BOT_ACCOUNTS_FILE',
+    trainImport: '@metro-labs/discord-bot/train',
   },
   whatsapp: {
     file: 'whatsapp-accounts.json',
@@ -236,7 +236,12 @@ export const isLocalRuntime = (): boolean =>
 export const stationRunsHere = (station: StationName): boolean =>
   isLocalRuntime() || !MOVABLE_STATIONS.has(station);
 
-function writeStations(list: LoadedAgent[]): Map<StationName, number> {
+interface WrittenStations {
+  active: Map<StationName, number>;
+  changed: StationName[];
+}
+
+function writeStations(list: LoadedAgent[]): WrittenStations {
   mkdirSync(METRO_DIR, { recursive: true });
   mkdirSync(TRAINS_DIR, { recursive: true });
 
@@ -247,6 +252,13 @@ function writeStations(list: LoadedAgent[]): Map<StationName, number> {
   for (const agent of list) {
     names[agent.id] = agent.name;
     for (const a of agent.accounts) {
+      if (!(a.station in STATION_TARGETS)) {
+        log.error(
+          { station: a.station, id: a.id },
+          'unknown station — this metro is older or newer than the row; skipping it',
+        );
+        continue;
+      }
       map[`${a.station}/${a.id}`] = agent.id;
       if (a.allowlist) allow[`${a.station}/${a.id}`] = a.allowlist;
       if (stationRunsHere(a.station)) {
@@ -261,29 +273,36 @@ function writeStations(list: LoadedAgent[]): Map<StationName, number> {
   carryTokenStores(list.flatMap((agent) => agent.accounts));
 
   const active = new Map<StationName, number>();
+  const changed: StationName[] = [];
   for (const [station, accts] of byStation) {
     const records = accts.map((a) => ({ id: a.id, ...trainConfig(a.config) }));
-    writeSecure(accountFilePath(station), JSON.stringify(records, null, 2));
+    const path = accountFilePath(station);
+    const content = JSON.stringify(records, null, 2);
+    if (currentText(path) !== content) {
+      writeSecure(path, content);
+      changed.push(station);
+    }
     const { trainImport } = STATION_TARGETS[station];
     if (trainImport !== null)
       writeIfChanged(trainStubPath(station), `import '${trainImport}';\n`);
     active.set(station, accts.length);
   }
-  return active;
+  return { active, changed };
 }
 
+const BLANKED = '[]\n';
+
 function pruneStations(present: Map<StationName, number>): StationName[] {
   const removed: StationName[] = [];
   for (const station of Object.keys(STATION_TARGETS) as StationName[]) {
     if (present.has(station)) continue;
     const hasTrain = STATION_TARGETS[station].trainImport !== null;
     const stub = trainStubPath(station);
-    if (
-      (!hasTrain || !existsSync(stub)) &&
-      !existsSync(accountFilePath(station))
-    )
-      continue;
-    writeSecure(accountFilePath(station), '[]\n');
+    const stubGone = !hasTrain || !existsSync(stub);
+    const file = currentText(accountFilePath(station));
+    const fileInert = file === null || file === BLANKED;
+    if (stubGone && fileInert) continue;
+    if (!fileInert) writeSecure(accountFilePath(station), BLANKED);
     if (hasTrain) rmSync(stub, { force: true });
     removed.push(station);
   }
@@ -310,14 +329,15 @@ export function localAgentKey(): string | null {
 
 async function loadAndWrite(
   source: StationSource,
-): Promise<{ active: Map<StationName, number>; agents: number }> {
+): Promise<WrittenStations & { agents: number }> {
   const list = await source();
   applyKeyMap(list);
-  return { active: writeStations(list), agents: list.length };
+  return { ...writeStations(list), agents: list.length };
 }
 
 export async function materializeFrom(source: StationSource): Promise<void> {
   const { active, agents: found } = await loadAndWrite(source);
+
   if (found === 0) throw new Error('no agents found — nothing to materialize');
   log.info(
     { stations: stationLabels(active), agents: found },
@@ -338,18 +358,20 @@ export async function materializeFromDb(): Promise<void> {
 export interface ReloadedStations {
   active: StationName[];
   removed: StationName[];
+  changed: StationName[];
 }
 
 export async function reloadFrom(
   source: StationSource,
 ): Promise<ReloadedStations> {
-  const { active } = await loadAndWrite(source);
+  const { active, changed } = await loadAndWrite(source);
   const removed = pruneStations(active);
-  log.info(
-    { stations: stationLabels(active), removed },
-    'reloaded station accounts',
-  );
-  return { active: [...active.keys()], removed };
+  if (removed.length > 0 || changed.length > 0)
+    log.info(
+      { stations: stationLabels(active), removed, changed },
+      'reloaded station accounts',
+    );
+  return { active: [...active.keys()], removed, changed };
 }
 
 export async function reloadAccountsFromDb(): Promise<ReloadedStations> {

package/runtime/node_modules/@metro-labs/mcp/src/db/schema.ts

@@ -8,9 +8,9 @@ import {
 
 export const STATIONS = [
   'xmtp',
+  'telegram-bot',
   'telegram',
-  'telegram-user',
-  'discord',
+  'discord-bot',
   'whatsapp',
   'webhook',
 ] as const;

package/runtime/node_modules/@metro-labs/mcp/src/mcp/tool-schemas.ts

@@ -235,7 +235,7 @@ export const COMMON_TOOLS = [
       'limit?. The station is derived from the line. Returns {line, station, memberCount, ' +
       'members:[{id, name?, display_name?, address?, roles?, is_admin?, is_bot?}], capability:' +
       '{supported, complete, reason?, total?}}. Each station fills the fields it has (xmtp: id=' +
-      'inboxId + address; discord: id + username/nick + roles + is_bot; telegram/telegram-user: ' +
+      'inboxId + address; discord-bot: id + username/nick + roles + is_bot; telegram-bot/telegram: ' +
       'id + username/first_name). Never throws on "not supported": stations that cannot ' +
       'enumerate (e.g. the Telegram Bot API) return an empty or partial list with a reason in ' +
       '`capability`. Check `capability.complete` before assuming the roster is exhaustive.',
@@ -255,9 +255,9 @@ export const COMMON_TOOLS = [
     name: 'create_group',
     description:
       'Create a new group/channel on a station and add members, in a station-agnostic shape. ' +
-      'Args: station (required, xmtp|telegram-user|discord|telegram), name (required), members? ' +
-      '(string[]; xmtp: 0x address or inboxId, telegram-user: @username or user id, discord: ' +
-      'user id), account? (which station account), parent? (discord only: the metro:// line of ' +
+      'Args: station (required, xmtp|telegram|discord-bot|telegram-bot), name (required), members? ' +
+      '(string[]; xmtp: 0x address or inboxId, telegram: @username or user id, discord-bot: ' +
+      'user id), account? (which station account), parent? (discord-bot only: the metro:// line of ' +
       'the channel to open the thread under). Returns {op, line (the NEW group line), station, ' +
       'supported, reason?, id?, name?, members:[{id, status: added|invited|removed|failed, ' +
       'reason?}], inviteLink?}. Never throws on "not supported": stations that lack the op ' +
@@ -269,7 +269,7 @@ export const COMMON_TOOLS = [
       properties: {
         station: {
           type: 'string',
-          description: 'The station to create the group on (xmtp|telegram-user|discord).',
+          description: 'The station to create the group on (xmtp|telegram|discord-bot).',
         },
         name: { type: 'string', description: 'The group/channel name.' },
         members: {
@@ -357,7 +357,7 @@ export const COMMON_TOOLS = [
     description:
       'Get a join/invite link for a Metro group, for platforms where direct-add is not always ' +
       'permitted. Args: line (required). The station is derived from the line. Returns {op, ' +
-      'line, station, supported, reason?, inviteLink?}. Only telegram-user supports this today; ' +
+      'line, station, supported, reason?, inviteLink?}. Only telegram supports this today; ' +
       'other stations return {supported:false, reason}. Never throws on "not supported".',
     inputSchema: {
       type: 'object',

package/runtime/node_modules/@metro-labs/mcp/src/stations/attach-interactive.ts

@@ -1,6 +1,6 @@
 import { StationAttachError } from './attach.js';
 
-export const INTERACTIVE_STATIONS = ['telegram-user', 'whatsapp'] as const;
+export const INTERACTIVE_STATIONS = ['telegram', 'whatsapp'] as const;
 
 export type InteractiveStation = (typeof INTERACTIVE_STATIONS)[number];
 
@@ -61,12 +61,12 @@ async function startTelegramUser(
   input: Record<string, unknown>,
   hooks: DriverHooks,
 ): Promise<StartedAttach> {
-  const { TelegramUserLogin, TelegramUserLoginError, validateCredentials } =
-    await import('@metro-labs/telegram-user/login');
-  const isOwn = (e: unknown): boolean => e instanceof TelegramUserLoginError;
+  const { TelegramLogin, TelegramLoginError, validateCredentials } =
+    await import('@metro-labs/telegram/login');
+  const isOwn = (e: unknown): boolean => e instanceof TelegramLoginError;
   let login;
   try {
-    login = new TelegramUserLogin(
+    login = new TelegramLogin(
       validateCredentials({
         apiId: input.apiId,
         apiHash: input.apiHash,
@@ -155,7 +155,7 @@ export async function startInteractiveAttach(
   input: Record<string, unknown>,
   hooks: DriverHooks,
 ): Promise<StartedAttach> {
-  return station === 'telegram-user'
+  return station === 'telegram'
     ? startTelegramUser(input, hooks)
     : startWhatsapp(input, hooks);
 }

package/runtime/node_modules/@metro-labs/mcp/src/stations/attach.ts

@@ -2,11 +2,11 @@ import { randomBytes } from 'node:crypto';
 import {
   DiscordTokenError,
   verifyDiscordBotToken,
-} from '@metro-labs/discord/verify';
+} from '@metro-labs/discord-bot/verify';
 import {
   TelegramTokenError,
   verifyTelegramBotToken,
-} from '@metro-labs/telegram/verify';
+} from '@metro-labs/telegram-bot/verify';
 import { ApiError } from '../daemon/api-error.js';
 import { publicBaseOrDefault } from '../daemon/attach-serve.js';
 import {
@@ -18,8 +18,8 @@ import {
 } from './attach-xmtp.js';
 
 export const ATTACHABLE_STATIONS = [
-  'discord',
-  'telegram',
+  'discord-bot',
+  'telegram-bot',
   'xmtp',
   'webhook',
 ] as const;
@@ -175,8 +175,8 @@ export async function prepareAccount(
   input: AttachInput,
   verify: VerifyXmtpKey = verifyXmtpKeyOutOfProcess,
 ): Promise<PreparedAccount> {
-  if (input.station === 'discord') return prepareDiscord(input.token);
-  if (input.station === 'telegram') return prepareTelegram(input.token);
+  if (input.station === 'discord-bot') return prepareDiscord(input.token);
+  if (input.station === 'telegram-bot') return prepareTelegram(input.token);
   if (input.station === 'webhook') return prepareWebhook();
   return prepareXmtp(verify);
 }

package/runtime/node_modules/@metro-labs/mcp/src/stations/lines.ts

@@ -38,7 +38,7 @@ function parseTelegramLine(
   line: Line | string,
 ): { accountId: string; chatId: number; topicId?: number } | null {
   const p = Line.parse(line);
-  if (p?.station !== 'telegram') return null;
+  if (p?.station !== 'telegram-bot') return null;
   const { accountId, rest } = splitTelegramAccount(p.path);
   const [chatId, topicId] = rest;
   if (rest.length < 1 || rest.length > 2 || chatId === undefined || !isSignedInt(chatId))
@@ -76,7 +76,7 @@ export const Line = {
   parseXmtp: (line: Line | string) => parseAccountScoped(line, 'xmtp'),
 
   parseDiscord: (line: Line | string) =>
-    parseAccountScoped(line, 'discord', isSnowflake),
+    parseAccountScoped(line, 'discord-bot', isSnowflake),
 
   parseTelegram: (line: Line | string) => parseTelegramLine(line),
 };

package/runtime/node_modules/@metro-labs/mcp/src/stations/registry.ts

@@ -1,17 +1,17 @@
 import type { Station } from './types.js';
 import { Line } from './lines.js';
 import { xmtpStation } from '@metro-labs/xmtp';
+import { telegramBotStation } from '@metro-labs/telegram-bot';
 import { telegramStation } from '@metro-labs/telegram';
-import { telegramUserStation } from '@metro-labs/telegram-user';
-import { discordStation } from '@metro-labs/discord';
+import { discordBotStation } from '@metro-labs/discord-bot';
 import { whatsappStation } from '@metro-labs/whatsapp';
 import { webhookStation } from '@metro-labs/webhook';
 
 export const STATIONS: readonly Station[] = [
   xmtpStation,
+  telegramBotStation,
   telegramStation,
-  telegramUserStation,
-  discordStation,
+  discordBotStation,
   whatsappStation,
   webhookStation,
 ];

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

@@ -6,20 +6,23 @@
   "exports": {
     ".": "./src/station.ts",
     "./train": "./src/index.ts",
-    "./verify": "./src/verify.ts"
+    "./login": "./src/login.ts"
   },
   "scripts": {
     "build": "tsc",
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*"
+    "@metro-labs/mcp": "workspace:*",
+    "@mtcute/bun": "0.30.1"
   },
   "devDependencies": {
     "@stage-labs/config": "0.1.0-beta.2",
+    "@types/qrcode-terminal": "^0.12.2",
     "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

@@ -3,102 +3,43 @@ import { join } from 'node:path';
 import {
   makeAccountStore,
   resolveAccountId,
+  type Die,
 } from '@metro-labs/mcp/stations/account-store';
-import { Line } from '@metro-labs/mcp/lines';
+import type { UserAccount } from './types.js';
 
 const ACCOUNTS_FILE =
   process.env.TELEGRAM_ACCOUNTS_FILE ??
   join(homedir(), '.metro', 'telegram-accounts.json');
 
-export interface AccountConfig {
-  id: string;
-  token: string;
-  owner?: string;
+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');
+  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<AccountConfig>({
+export const { loadAccounts } = makeAccountStore<UserAccount>({
   prefix: 'telegram',
   file: ACCOUNTS_FILE,
   allowlistEnv: ['TELEGRAM_ONLY_ACCOUNTS', 'TELEGRAM_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);
-    }
+    const seen = new Set<string>();
+    for (const a of raw) validateAccount(a, seen, die);
   },
 });
 
-export interface Account {
-  cfg: AccountConfig;
-  api: string;
-  fileApi: string;
-  offset: number;
-}
-export const accounts = new Map<string, Account>();
-
-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 ${method}: ${json.description ?? 'unknown'}`);
-  return json.result as T;
-}
-
-export async function tgForm<T>(
-  accountId: string,
-  method: string,
-  form: FormData,
-  timeoutMs = 60_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',
-    body: form,
-    signal: AbortSignal.timeout(timeoutMs),
-  });
-  const json = (await res.json()) as {
-    ok: boolean;
-    description?: string;
-    result?: T;
-  };
-  if (!json.ok)
-    throw new Error(`telegram ${method}: ${json.description ?? 'unknown'}`);
-  return json.result as T;
-}
+export const accounts = new Map<string, UserAccount>();
 
 export function accountFor(args: { account?: string; line?: string }): string {
-  return resolveAccountId(
-    accounts,
-    args,
-    (line) => Line.parseTelegram(line)?.accountId,
-  );
+  return resolveAccountId(accounts, args, (line) => targetOf(line)?.accountId);
 }
 
 export function lineOf(
@@ -110,11 +51,31 @@ export function lineOf(
   return `metro://telegram/${accountId}/${tail}`;
 }
 
-export function targetOf(
-  line: string,
-  accountOverride?: string,
-): { accountId: string; chatId: number; topicId?: number } {
-  const parsed = Line.parseTelegram(line);
-  if (!parsed) throw new Error(`bad telegram line: ${line}`);
-  return { ...parsed, accountId: accountOverride ?? parsed.accountId };
+interface Target {
+  accountId: string;
+  chatId: number;
+  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 [chatId, topicId] = rest;
+  if (rest.length < 1 || rest.length > 2 || chatId === undefined) return undefined;
+  if (!isSignedInt(chatId)) return undefined;
+  if (topicId !== undefined && !isTopic(topicId)) return undefined;
+  return {
+    accountId,
+    chatId: Number(chatId),
+    ...(topicId !== undefined ? { topicId: Number(topicId) } : {}),
+  };
 }