@stage-labs/metro 0.1.0-beta.8 → 0.1.0-beta.80

package/runtime/node_modules/@metro-labs/http/src/identity-registry.ts

@@ -0,0 +1,13 @@
+const subjects = new Map<string, string>();
+
+export function authorizeIdentity(address: string, subject: string): void {
+  subjects.set(address.toLowerCase(), subject.toLowerCase());
+}
+
+export function identitySubject(address: string): string | undefined {
+  return subjects.get(address.toLowerCase());
+}
+
+export function resetIdentities(): void {
+  subjects.clear();
+}

package/runtime/node_modules/@metro-labs/http/src/mode-api.ts

@@ -0,0 +1,32 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { cors, sendJson } from './api-http.js';
+
+const PATH = '/api/mode';
+
+export type DaemonMode = 'hosted' | 'linked' | 'local';
+
+export interface ModeInfo {
+  mode: DaemonMode;
+  owner: string | null;
+  project: string | null;
+  version: string;
+}
+
+export function handleModeRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  info: () => ModeInfo,
+): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (path !== PATH) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== 'GET') {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  sendJson(req, res, 200, info());
+  return true;
+}

package/runtime/node_modules/@metro-labs/http/src/return-to.ts

@@ -0,0 +1,21 @@
+const PREVIEW = /^([a-z0-9-]+--)?metro-ui\.netlify\.app$/;
+
+export function allowedWebHost(host: string): boolean {
+  if (host === 'metro.box' || host === 'localhost' || host === '127.0.0.1')
+    return true;
+  return PREVIEW.test(host);
+}
+
+export function validateReturnTo(returnTo: string): boolean {
+  let url: URL;
+  try {
+    url = new URL(returnTo);
+  } catch {
+    return false;
+  }
+  const host = url.hostname;
+  if (url.protocol === 'http:' && (host === 'localhost' || host === '127.0.0.1'))
+    return true;
+  if (url.protocol !== 'https:') return false;
+  return allowedWebHost(host);
+}

package/runtime/node_modules/@metro-labs/http/src/signed-identity.ts

@@ -0,0 +1,36 @@
+import type { IncomingMessage } from 'node:http';
+import { verifyMessage } from 'viem';
+import { normalizeAddress } from '@metro-labs/core/address';
+
+export const AUTH_SCHEME = 'Metro';
+const SKEW_MS = 5 * 60_000;
+const SIGNATURE_RE = /^0x[0-9a-fA-F]{130}$/;
+
+export const identityChallenge = (method: string, path: string, at: number): string =>
+  `metro-auth\n${method} ${path}\n${String(at)}`;
+
+export interface SignedHeader {
+  address: string;
+  at: number;
+  signature: `0x${string}`;
+}
+
+export function parseIdentityHeader(header: string): SignedHeader | null {
+  const [scheme, rawAddress, rawAt, signature] = header.trim().split(/\s+/);
+  if (scheme !== AUTH_SCHEME || rawAddress === undefined || rawAt === undefined || signature === undefined) return null;
+  const address = normalizeAddress(rawAddress);
+  const at = Number(rawAt);
+  if (address === null || !Number.isFinite(at) || !SIGNATURE_RE.test(signature)) return null;
+  return { address, at, signature: signature as `0x${string}` };
+}
+
+export async function signedIdentity(req: IncomingMessage, now = Date.now()): Promise<string | null> {
+  const proof = parseIdentityHeader(req.headers.authorization ?? '');
+  if (proof === null || Math.abs(now - proof.at) > SKEW_MS) return null;
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const message = identityChallenge(req.method ?? '', path, proof.at);
+  const ok = await verifyMessage({ address: proof.address as `0x${string}`, message, signature: proof.signature }).catch(
+    () => false,
+  );
+  return ok ? proof.address : null;
+}

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

@@ -0,0 +1,26 @@
+{
+  "name": "@metro-labs/telegram",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/station.ts",
+    "./train": "./src/index.ts",
+    "./login": "./src/login.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/core": "workspace:*",
+    "@mtcute/bun": "0.30.1"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.2",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}

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

@@ -0,0 +1,80 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import {
+  makeAccountStore,
+  resolveAccountId,
+  type Die,
+} 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');
+  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,
+  validate(raw, die) {
+    const seen = new Set<string>();
+    for (const a of raw) validateAccount(a, seen, die);
+  },
+});
+
+export const accounts = new Map<string, UserAccount>();
+
+export function accountFor(args: { account?: string; line?: string }): string {
+  return resolveAccountId(accounts, args, (line) => targetOf(line)?.accountId);
+}
+
+export function lineOf(
+  accountId: string,
+  chatId: number | string,
+  topicId?: number,
+): string {
+  const tail = topicId !== undefined ? `${chatId}/${topicId}` : `${chatId}`;
+  return `metro://telegram/${accountId}/${tail}`;
+}
+
+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) } : {}),
+  };
+}

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

@@ -0,0 +1,254 @@
+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/core/stations/station-runtime';
+import { accountFor, accounts, targetOf } from './accounts.js';
+import type { UserClient } from './client.js';
+import { normalizeTelegramUser } from './normalize.js';
+import {
+  sendAttachments,
+  type CanonicalAttachment,
+} from './media-actions.js';
+import { clampLimit, shapeHistory } from './history.js';
+import { fetchMembers, isRestricted, restrictedMemberList } from './members.js';
+import {
+  groupAddMembers,
+  groupCreate,
+  groupInviteLink,
+  groupRemoveMembers,
+} from './group.js';
+
+type Args = Record<string, unknown>;
+
+interface Resolved {
+  accountId: string;
+  client: UserClient;
+  chatId: number;
+  topicId?: number;
+}
+
+type ClientFor = (accountId: string) => UserClient;
+
+function str(v: unknown): string | undefined {
+  return typeof v === 'string' ? v : undefined;
+}
+
+function lineOfArgs(args: Args): string {
+  const line = str(args.line);
+  if (!line) throw new TrainError('bad_request', 'missing line');
+  return line;
+}
+
+function resolve(args: Args, clientFor: ClientFor): Resolved {
+  const line = lineOfArgs(args);
+  const target = targetOf(line);
+  if (!target) throw new TrainError('bad_request', `bad line '${line}'`);
+  const accountId = accountFor({ account: str(args.account), line });
+  return {
+    accountId,
+    client: clientFor(accountId),
+    chatId: target.chatId,
+    ...(target.topicId !== undefined ? { topicId: target.topicId } : {}),
+  };
+}
+
+async function guard<T>(run: () => Promise<T>): Promise<T> {
+  try {
+    return await run();
+  } catch (e) {
+    const msg = errMsg(e);
+    if (/FLOOD_WAIT|SLOWMODE_WAIT/i.test(msg))
+      throw new TrainError('rate_limited', msg);
+    throw new TrainError('telegram_call', msg);
+  }
+}
+
+function attachmentsOf(args: Args): CanonicalAttachment[] {
+  const raw = args.attachments;
+  return Array.isArray(raw) ? (raw as CanonicalAttachment[]) : [];
+}
+
+function makeSend(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, chatId, topicId } = resolve(args, clientFor);
+    const text = str(args.text) ?? '';
+    const replyTo = str(args.replyTo);
+    const explicitReplyTo = replyTo ? Number(replyTo) : undefined;
+    const replyParam = explicitReplyTo ?? topicId;
+    const attachments = attachmentsOf(args);
+    if (attachments.length) {
+      const sent = await guard(() =>
+        sendAttachments({ client, chatId, replyTo: replyParam }, attachments, text),
+      );
+      respond(id, {
+        result: {
+          messageId: String(sent.message.id),
+          account: accountId,
+          attachments: sent.delivered,
+        },
+      });
+      return;
+    }
+    const peer = await guard(() => client.tg.resolvePeer(chatId));
+    const sent = await guard(() =>
+      client.tg.sendText(
+        peer,
+        text,
+        replyParam !== undefined ? { replyTo: replyParam } : undefined,
+      ),
+    );
+    respond(id, {
+      result: { messageId: String(sent.id), account: accountId },
+    });
+  };
+}
+
+function makeReact(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, chatId } = resolve(args, clientFor);
+    const message = Number(str(args.messageId));
+    const raw = str(args.emoji);
+    const emoji = raw === undefined || raw === '' ? null : raw;
+    await guard(() =>
+      client.tg.sendReaction({ chatId, message, emoji }),
+    );
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
+function makeEdit(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, chatId } = resolve(args, clientFor);
+    const message = Number(str(args.messageId));
+    const text = str(args.text) ?? '';
+    await guard(() => client.tg.editMessage({ chatId, message, text }));
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
+function makeDelete(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, chatId } = resolve(args, clientFor);
+    const message = Number(str(args.messageId));
+    await guard(() =>
+      client.tg.deleteMessagesById(chatId, [message], { revoke: true }),
+    );
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
+function makeRead(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, chatId } = resolve(args, clientFor);
+    const limit = clampLimit(args.limit);
+    const before = str(args.before);
+    const beforeId = before ? Number(before) : undefined;
+    const offset =
+      beforeId !== undefined && Number.isFinite(beforeId)
+        ? { offset: { id: beforeId, date: 0 } }
+        : {};
+    const page = await guard(() =>
+      client.tg.getHistory(chatId, { limit, ...offset }),
+    );
+    respond(id, { result: shapeHistory(accountId, chatId, page) });
+  };
+}
+
+function makeListMembers(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { client, chatId } = resolve(args, clientFor);
+    const limit = typeof args.limit === 'number' ? args.limit : undefined;
+    try {
+      respond(id, { result: await fetchMembers(client, chatId, limit) });
+    } catch (e) {
+      const msg = errMsg(e);
+      if (isRestricted(msg)) {
+        respond(id, { result: restrictedMemberList(msg) });
+        return;
+      }
+      throw e;
+    }
+  };
+}
+
+function makeGroupCreate(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const client = clientFor(accountId);
+    respond(id, {
+      result: await guard(() => groupCreate(client, accountId, args)),
+    });
+  };
+}
+
+function makeGroupAdd(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { client, chatId } = resolve(args, clientFor);
+    const line = lineOfArgs(args);
+    respond(id, {
+      result: await guard(() => groupAddMembers(client, chatId, line, args)),
+    });
+  };
+}
+
+function makeGroupRemove(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { client, chatId } = resolve(args, clientFor);
+    const line = lineOfArgs(args);
+    respond(id, {
+      result: await guard(() => groupRemoveMembers(client, chatId, line, args)),
+    });
+  };
+}
+
+function makeGroupInvite(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { client, chatId } = resolve(args, clientFor);
+    const line = lineOfArgs(args);
+    respond(id, {
+      result: await guard(() => groupInviteLink(client, chatId, line)),
+    });
+  };
+}
+
+function makeAccounts(clientFor: ClientFor): StationHandler {
+  return (id) => {
+    const list = [...accounts.values()].map((a) => {
+      const me = clientFor(a.id).self();
+      const username = me?.username ?? null;
+      return {
+        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 } });
+    return Promise.resolve();
+  };
+}
+
+export function makeHandleCall(
+  clientFor: ClientFor,
+): (msg: CallMsg) => Promise<void> {
+  return makeStation({
+    handlers: {
+      accounts: makeAccounts(clientFor),
+      send: makeSend(clientFor),
+      react: makeReact(clientFor),
+      edit: makeEdit(clientFor),
+      delete: makeDelete(clientFor),
+      read: makeRead(clientFor),
+      listMembers: makeListMembers(clientFor),
+      groupCreate: makeGroupCreate(clientFor),
+      groupAddMembers: makeGroupAdd(clientFor),
+      groupRemoveMembers: makeGroupRemove(clientFor),
+      groupInviteLink: makeGroupInvite(clientFor),
+    },
+    normalize: normalizeTelegramUser,
+  });
+}

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

@@ -0,0 +1,87 @@
+import type { Message } from '@mtcute/bun';
+import { FileLocation } from '@mtcute/bun';
+import {
+  saveBufferToCache,
+  type SavedAttachment,
+} from '@metro-labs/core/stations/attachments';
+import type { UserClient } from './client.js';
+
+type Media = NonNullable<Message['media']>;
+export type DownloadableMedia = Media & FileLocation;
+
+export function isDownloadable(media: Media): media is DownloadableMedia {
+  return media instanceof FileLocation;
+}
+
+interface MediaMeta {
+  mime?: string;
+  name?: string;
+}
+
+function fallbackMime(media: DownloadableMedia): string | undefined {
+  const type = (media as { type?: unknown }).type;
+  if (type === 'photo') return 'image/jpeg';
+  if (type === 'sticker') return 'image/webp';
+  return undefined;
+}
+
+function metaOf(media: DownloadableMedia): MediaMeta {
+  const withMime = media as { mimeType?: unknown };
+  const withName = media as { fileName?: unknown };
+  const mime =
+    (typeof withMime.mimeType === 'string' ? withMime.mimeType : undefined) ??
+    fallbackMime(media);
+  const name =
+    typeof withName.fileName === 'string' ? withName.fileName : undefined;
+  return {
+    ...(mime ? { mime } : {}),
+    ...(name ? { name } : {}),
+  };
+}
+
+export interface PendingDescriptor {
+  kind: string;
+  name?: string;
+}
+
+const KIND_BY_TYPE: Record<string, string> = {
+  photo: 'image',
+  sticker: 'image',
+  voice: 'audio',
+  audio: 'audio',
+  video: 'video',
+  video_note: 'video',
+  animation: 'video',
+};
+
+function mediaType(media: DownloadableMedia): string {
+  const type = (media as { type?: unknown }).type;
+  return typeof type === 'string' ? type : '';
+}
+
+function kindOf(media: DownloadableMedia, mime: string | undefined): string {
+  const byType = KIND_BY_TYPE[mediaType(media)];
+  if (byType) return byType;
+  if (mime?.startsWith('image/')) return 'image';
+  if (mime?.startsWith('audio/')) return 'audio';
+  if (mime?.startsWith('video/')) return 'video';
+  return 'file';
+}
+
+export function pendingDescriptorOf(media: DownloadableMedia): PendingDescriptor {
+  const meta = metaOf(media);
+  return {
+    kind: kindOf(media, meta.mime),
+    ...(meta.name ? { name: meta.name } : {}),
+  };
+}
+
+export async function downloadMedia(
+  client: UserClient,
+  media: DownloadableMedia,
+  messageId: string,
+  index = 0,
+): Promise<SavedAttachment> {
+  const buf = await client.tg.downloadAsBuffer(media);
+  return saveBufferToCache(buf, messageId, index, metaOf(media));
+}

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

@@ -0,0 +1,77 @@
+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/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
+import type { UserAccount } from './types.js';
+
+const STATE_DIR =
+  process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
+
+export interface Self {
+  username: string | null;
+  phone: string | null;
+}
+
+export interface UserClient {
+  account: UserAccount;
+  tg: TelegramClient;
+  self: () => Self | null;
+  connect: () => Promise<void>;
+  startUpdates: () => Promise<void>;
+  disconnect: () => Promise<void>;
+}
+
+function storagePath(accountId: string): string {
+  const dir = join(STATE_DIR, 'telegram');
+  mkdirSync(dir, { recursive: true });
+  return join(dir, `${accountId}.session`);
+}
+
+export function createClient(account: UserAccount): UserClient {
+  const apiId = account.apiId ?? 0;
+  const { apiHash } = account;
+  if (!Number.isInteger(apiId) || apiId <= 0 || !apiHash)
+    throw new TrainError(
+      'telegram_auth',
+      `account '${account.id}' missing apiId/apiHash`,
+    );
+  const tg = new TelegramClient({
+    apiId,
+    apiHash,
+    storage: storagePath(account.id),
+  });
+
+  let me: Self | null = null;
+
+  const connect = async (): Promise<void> => {
+    try {
+      await tg.importSession(account.session);
+      await tg.connect();
+    } catch (e) {
+      throw new TrainError(
+        'telegram_auth',
+        `account '${account.id}' connect failed: ${errMsg(e)}`,
+      );
+    }
+    try {
+      const user = await tg.getMe();
+      me = { username: user.username ?? null, phone: user.phoneNumber ?? null };
+    } catch (e) {
+      process.stderr.write(
+        `telegram[${account.id}] identity unavailable: ${errMsg(e)}\n`,
+      );
+    }
+  };
+
+  const startUpdates = async (): Promise<void> => {
+    await tg.startUpdatesLoop();
+  };
+
+  const disconnect = async (): Promise<void> => {
+    await tg.disconnect();
+  };
+
+  return { account, tg, self: () => me, connect, startUpdates, disconnect };
+}