@stage-labs/metro 0.1.0-beta.22 → 0.1.0-beta.221

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

@@ -1,6 +1,7 @@
-import { tg, tgForm, targetOf } from './accounts.js';
-import { emit, mintId, respond, SELF_URI } from './wire.js';
-import { appendFile } from '@metro-labs/mcp/stations/attachments';
+import { tg, targetOf } from './accounts.js';
+import { selfUri } from '@metro-labs/core/stations/train-events';
+import { emit, mintId, respond } from '@metro-labs/core/stations/station-runtime';
+import { appendFile } from '@metro-labs/core/stations/attachments';
 
 export function emitOutbound(
   accountId: string,
@@ -10,18 +11,16 @@ export function emitOutbound(
   replyTo?: string,
 ): void {
   emit({
-    kind: 'outbound',
     id: mintId(),
     ts: new Date().toISOString(),
     station: 'telegram-bot',
     line,
-    from: SELF_URI,
+    from: selfUri(),
     to: line,
     message_id: messageId,
     text,
     reply_to: replyTo,
     ...(replyTo ? { event: { type: 'reply', replyTo } } : {}),
-    account: accountId,
     payload: { account: accountId },
   });
 }
@@ -46,7 +45,6 @@ interface MediaArgs {
   path: string;
   caption?: string;
   replyTo?: string;
-  parseMode?: string;
   account?: string;
   name?: string;
 }
@@ -61,7 +59,6 @@ export async function sendMedia(
     path,
     caption,
     replyTo,
-    parseMode,
     account,
     name: fileName,
   } = args as unknown as MediaArgs;
@@ -70,7 +67,6 @@ export async function sendMedia(
   form.append('chat_id', String(chatId));
   if (topicId !== undefined) form.append('message_thread_id', String(topicId));
   if (caption) form.append('caption', caption);
-  if (parseMode) form.append('parse_mode', parseMode);
   if (replyTo)
     form.append(
       'reply_parameters',
@@ -78,29 +74,10 @@ export async function sendMedia(
     );
   const name = fileName ?? path.split('/').pop() ?? fieldName;
   await appendFile(form, fieldName, path, name);
-  const r = await tgForm<{ message_id: number }>(accountId, method, form);
+  const r = await tg<{ message_id: number }>(accountId, method, form);
   return { accountId, message_id: r.message_id };
 }
 
-export async function media(
-  id: string,
-  method: string,
-  field: string,
-  label: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const { accountId, message_id } = await sendMedia(method, field, args);
-  const line = (args as { line: string }).line;
-  finishSend(
-    id,
-    accountId,
-    line,
-    String(message_id),
-    label,
-    args.replyTo as string | undefined,
-  );
-}
-
 export const MEDIA_METHOD_FIELD: Record<
   string,
   { method: string; field: string }
@@ -111,56 +88,3 @@ export const MEDIA_METHOD_FIELD: Record<
   video: { method: 'sendVideo', field: 'video' },
   document: { method: 'sendDocument', field: 'document' },
 };
-
-export async function sendDice(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const {
-    line,
-    emoji = '\U0001F3B2',
-    account,
-  } = args as { line: string; emoji?: string; account?: string };
-  const { accountId, chatId, topicId } = targetOf(line, account);
-  const body: Record<string, unknown> = { chat_id: chatId, emoji };
-  if (topicId !== undefined) body.message_thread_id = topicId;
-  const r = await tg<{ message_id: number; dice?: { value: number } }>(
-    accountId,
-    'sendDice',
-    body,
-  );
-  finishSend(
-    id,
-    accountId,
-    line,
-    String(r.message_id),
-    `[dice ${emoji} = ${r.dice?.value ?? '?'}]`,
-    undefined,
-    { value: r.dice?.value },
-  );
-}
-
-export async function sendLocation(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const { line, latitude, longitude, account } = args as {
-    line: string;
-    latitude: number;
-    longitude: number;
-    account?: string;
-  };
-  const { accountId, chatId } = targetOf(line, account);
-  const r = await tg<{ message_id: number }>(accountId, 'sendLocation', {
-    chat_id: chatId,
-    latitude,
-    longitude,
-  });
-  finishSend(
-    id,
-    accountId,
-    line,
-    String(r.message_id),
-    `[location: ${latitude}, ${longitude}]`,
-  );
-}

package/runtime/node_modules/@metro-labs/telegram-bot/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';
 
 export interface TgUser {
   id: number;

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

@@ -0,0 +1,85 @@
+import { appendFile } from '@metro-labs/core/stations/attachments';
+import {
+  assertImage,
+  fieldsOf,
+  parseProfileChange,
+  type ProfileApplied,
+  type ProfileAvatar,
+  type ProfileChange,
+} from '@metro-labs/core/stations/profile';
+import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountFor, accounts, tg } from './accounts.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+
+async function setPhoto(accountId: string, avatar: ProfileAvatar): Promise<void> {
+  assertImage(avatar);
+  const form = new FormData();
+  form.append('photo', JSON.stringify({ type: 'static', photo: 'attach://avatar' }));
+  await appendFile(form, 'avatar', avatar.path, avatar.name);
+  await tg(accountId, 'setMyProfilePhoto', form);
+}
+
+export async function applyProfile(accountId: string, change: ProfileChange): Promise<void> {
+  if (change.name !== undefined) await tg(accountId, 'setMyName', { name: change.name });
+  if (change.bio !== undefined) await tg(accountId, 'setMyDescription', { description: change.bio });
+  if (change.avatar !== undefined) await setPhoto(accountId, change.avatar);
+}
+
+export async function setProfile(id: string, args: Record<string, unknown>): Promise<void> {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const change = parseProfileChange(args);
+  await applyProfile(accountId, change);
+  const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
+  respond(id, { result });
+}
+
+interface TgChat {
+  username?: unknown;
+  first_name?: unknown;
+  last_name?: unknown;
+  bio?: unknown;
+  photo?: { small_file_id?: unknown };
+}
+
+const PHOTO_MAX = 64 * 1024;
+
+async function photoData(accountId: string, fileId: unknown): Promise<string | undefined> {
+  if (typeof fileId !== 'string' || fileId === '') return undefined;
+  try {
+    const file = await tg<{ file_path?: string }>(accountId, 'getFile', { file_id: fileId }, 10_000);
+    const acct = accounts.get(accountId);
+    if (acct === undefined || typeof file.file_path !== 'string') return undefined;
+    const res = await fetch(`${acct.fileApi}/${file.file_path}`, { signal: AbortSignal.timeout(10_000) });
+    if (!res.ok) return undefined;
+    const bytes = Buffer.from(await res.arrayBuffer());
+    return bytes.length === 0 || bytes.length > PHOTO_MAX ? undefined : `data:image/jpeg;base64,${bytes.toString('base64')}`;
+  } catch {
+    return undefined;
+  }
+}
+
+const senders = makeProfileCache<SenderProfile>(
+  async (key) => {
+    const [accountId, user] = key.split(':', 2) as [string, string];
+    const chat = await tg<TgChat>(accountId, 'getChat', { chat_id: Number(user) }, 10_000);
+    const handle = nonEmpty(chat.username);
+    const display = nonEmpty([chat.first_name, chat.last_name].filter((part) => typeof part === 'string').join(' '));
+    const avatar = await photoData(accountId, chat.photo?.small_file_id);
+    return {
+      id: user,
+      ...(handle === undefined ? {} : { name: `@${handle}` }),
+      ...(display === undefined ? {} : { display_name: display }),
+      ...(nonEmpty(chat.bio) === undefined ? {} : { about: nonEmpty(chat.bio) }),
+      ...(avatar === undefined ? {} : { avatar }),
+    };
+  },
+  { onError: (key, err) => process.stderr.write(`telegram-bot: could not read the profile of ${key}: ${err instanceof Error ? err.message : String(err)}\n`) },
+);
+
+export async function readProfile(id: string, args: Record<string, unknown>): Promise<void> {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  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 senders.get(`${accountId}:${user}`)) ?? { id: user } });
+}

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

@@ -1,4 +1,5 @@
-import type { Station, Verb } from '@metro-labs/mcp/stations/types';
+import type { Station, Verb } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
 
 export const telegramBotStation: Station = {
   name: 'telegram-bot',
@@ -11,7 +12,10 @@ export const telegramBotStation: Station = {
     'unreact',
     'edit',
     'delete',
+    'typing',
   ]),
   attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   tools: [],
 };

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

@@ -1,13 +1,26 @@
+export interface TgEntity {
+  type: string;
+  offset: number;
+  length: number;
+  user?: { id: number };
+}
+
+export interface TgUser {
+  id: number;
+  username?: string;
+  first_name?: string;
+  last_name?: string;
+  is_bot?: boolean;
+}
+
 export interface TgMsg {
+  entities?: TgEntity[];
+  caption_entities?: TgEntity[];
+  reply_to_message?: { message_id: number; from?: { id: number; username?: string; is_bot?: boolean } };
   message_id: number;
   date: number;
   chat: { id: number; type: string; title?: string; first_name?: string };
-  from?: {
-    id: number;
-    username?: string;
-    first_name?: string;
-    is_bot?: boolean;
-  };
+  from?: TgUser;
   text?: string;
   caption?: string;
   message_thread_id?: number;
@@ -26,12 +39,7 @@ export interface TgMsg {
 export interface TgReaction {
   chat: { id: number; type: string };
   message_id: number;
-  user?: {
-    id: number;
-    username?: string;
-    first_name?: string;
-    is_bot?: boolean;
-  };
+  user?: TgUser;
   date: number;
   old_reaction: { type: string; emoji?: string }[];
   new_reaction: { type: string; emoji?: string }[];

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

@@ -0,0 +1,26 @@
+{
+  "name": "@metro-labs/threema",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/station.ts",
+    "./train": "./src/index.ts",
+    "./verify": "./src/verify.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/core": "workspace:*",
+    "tweetnacl": "^1.0.3"
+  },
+  "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/threema/src/accounts.ts

@@ -0,0 +1,95 @@
+import {
+  makeAccountStore,
+  resolveAccountId,
+  type Die,
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
+import { fetchPublicKey } from './api.js';
+import { hexToBytes, keyPairFrom, type KeyPair } from './crypto.js';
+import { isGatewayId, normalizeThreemaId, parsePrivateKey } from './ids.js';
+import { GroupStore, parseGroupKey } from './groups.js';
+import type { GroupRef } from './messages.js';
+
+export interface AccountConfig {
+  id: string;
+  gatewayId: string;
+  secret: string;
+  privateKey: string;
+  callbackId?: string;
+  callbackToken?: string;
+}
+
+function checkAccount(a: AccountConfig, die: Die): void {
+  if (typeof a.gatewayId !== 'string' || !isGatewayId(a.gatewayId))
+    die(`account '${a.id}' has no Gateway ID`);
+  if (typeof a.secret !== 'string' || a.secret === '')
+    die(`account '${a.id}' missing secret`);
+  if (typeof a.privateKey !== 'string' || parsePrivateKey(a.privateKey) === null)
+    die(`account '${a.id}' has no usable private key`);
+}
+
+export const { loadAccounts } = makeAccountStore<AccountConfig>({
+  prefix: 'threema',
+  validate(raw, die) {
+    const seenGateway = new Set<string>();
+    for (const a of raw) {
+      checkAccount(a, die);
+      if (seenGateway.has(a.gatewayId))
+        die(`account '${a.id}' reuses the Gateway ID of another account`);
+      seenGateway.add(a.gatewayId);
+    }
+  },
+});
+
+export interface Account {
+  cfg: AccountConfig;
+  keys: KeyPair;
+  publicKeys: Map<string, Uint8Array>;
+  groups: GroupStore;
+}
+
+export type Target = { kind: 'user'; id: string } | { kind: 'group'; group: GroupRef };
+
+export const accounts = new Map<string, Account>();
+
+export function bootAccount(cfg: AccountConfig): Account {
+  const key = parsePrivateKey(cfg.privateKey);
+  if (key === null) throw new Error(`account '${cfg.id}' has no usable private key`);
+  return { cfg, keys: keyPairFrom(key), publicKeys: new Map(), groups: new GroupStore(cfg.id, cfg.gatewayId) };
+}
+
+export function accountFor(id: string): Account {
+  const acct = accounts.get(id);
+  if (!acct)
+    throw new Error(
+      `unknown account '${id}' (have: ${[...accounts.keys()].join(', ')})`,
+    );
+  return acct;
+}
+
+export function targetOf(
+  line: string,
+  account?: string,
+): { acct: Account; target: Target } {
+  const parsed = Line.parseThreema(line);
+  if (parsed === null) throw new Error(`not a threema line: ${line}`);
+  const id = resolveAccountId(
+    accounts,
+    { account, line },
+    (l) => Line.parseThreema(l)?.accountId,
+  );
+  const group = parseGroupKey(parsed.resource);
+  const target: Target = group === null ? { kind: 'user', id: normalizeThreemaId(parsed.resource) } : { kind: 'group', group };
+  return { acct: accountFor(id), target };
+}
+
+export async function publicKeyFor(
+  acct: Account,
+  threemaId: string,
+): Promise<Uint8Array> {
+  const cached = acct.publicKeys.get(threemaId);
+  if (cached) return cached;
+  const key = hexToBytes(await fetchPublicKey(acct.cfg, threemaId), 'public key');
+  acct.publicKeys.set(threemaId, key);
+  return key;
+}

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

@@ -0,0 +1,124 @@
+import { TrainError } from '@metro-labs/core/train-error';
+import {
+  makeStation,
+  respond,
+  type CallMsg,
+} from '@metro-labs/core/stations/station-runtime';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
+import { accountFor, accounts, publicKeyFor, targetOf, type Account } from './accounts.js';
+import { hexToBytes, macMatches, open } from './crypto.js';
+import { groupLineOf, type InboundMeta } from './format.js';
+import { groupKey } from './groups.js';
+import { deliver } from './inbound.js';
+import { isThreemaId, normalizeThreemaId } from './ids.js';
+import { decode } from './messages.js';
+import { react, send } from './outbound.js';
+
+export type { CallMsg };
+export { MAX_TEXT_BYTES } from './outbound.js';
+
+type Args = Record<string, unknown>;
+
+const WEB_CHAT = 'https://web.threema.com/#!/messenger/conversation/contact/';
+
+export const chatUrl = (gatewayId: string): string => `${WEB_CHAT}${encodeURIComponent(gatewayId)}`;
+
+function listAccounts(id: string): void {
+  const list = [...accounts.values()].map((a) => ({
+    id: a.cfg.id,
+    handle: a.cfg.gatewayId,
+    url: chatUrl(a.cfg.gatewayId),
+    gatewayId: a.cfg.gatewayId,
+    groups: a.groups.list().map((g) => ({ line: groupLineOf(a.cfg.id, g), name: g.name, members: g.members.length })),
+    ...(a.cfg.callbackId && a.cfg.callbackToken
+      ? { callbackId: a.cfg.callbackId, callbackToken: a.cfg.callbackToken }
+      : {}),
+  }));
+  respond(id, { result: { accounts: list } });
+}
+
+function listMembers(id: string, args: Args): void {
+  const line = typeof args.line === 'string' ? args.line : '';
+  const { acct, target } = targetOf(line, typeof args.account === 'string' ? args.account : undefined);
+  if (target.kind !== 'group') {
+    respond(id, { result: { members: [], capability: { supported: false, complete: false, reason: 'a Threema 1:1 chat has no roster' } } });
+    return;
+  }
+  const roster = acct.groups.get(target.group);
+  if (roster === undefined) {
+    respond(id, { result: { members: [], capability: { supported: true, complete: false, reason: `no member list yet for ${groupKey(target.group)}` } } });
+    return;
+  }
+  const members = roster.members.map((m) => ({ id: m, name: m, is_admin: m === roster.creator, is_bot: m === acct.cfg.gatewayId }));
+  respond(id, { result: { members, capability: { supported: true, complete: true, total: members.length } } });
+}
+
+interface CallbackArgs {
+  account: string;
+  from: string;
+  to: string;
+  messageId: string;
+  date: string;
+  nonce: string;
+  box: string;
+  mac: string;
+  nickname?: string;
+}
+
+const str = (v: unknown): string => (typeof v === 'string' ? v : '');
+
+function parseCallback(args: Args): CallbackArgs {
+  const fields = {
+    account: str(args.account),
+    from: str(args.from),
+    to: str(args.to),
+    messageId: str(args.messageId),
+    date: str(args.date),
+    nonce: str(args.nonce),
+    box: str(args.box),
+    mac: str(args.mac),
+  };
+  for (const [key, value] of Object.entries(fields))
+    if (value === '')
+      throw new TrainError('threema_bad_callback', `callback is missing ${key}`, {
+        retryable: false,
+      });
+  const nickname = str(args.nickname);
+  return nickname === '' ? fields : { ...fields, nickname };
+}
+
+function checkedSender(acct: Account, cb: CallbackArgs): string {
+  if (!macMatches(acct.cfg.secret, cb, cb.mac))
+    throw new TrainError('threema_bad_mac', 'the callback MAC does not match this account API secret', { retryable: false });
+  const from = normalizeThreemaId(cb.from);
+  if (!isThreemaId(from))
+    throw new TrainError('threema_bad_callback', `'${cb.from}' is not a Threema ID`, { retryable: false });
+  if (normalizeThreemaId(cb.to) !== acct.cfg.gatewayId)
+    throw new TrainError('threema_wrong_recipient', `callback addressed to ${cb.to}, not to ${acct.cfg.gatewayId}`, { retryable: false });
+  return from;
+}
+
+async function callback(id: string, args: Args): Promise<void> {
+  const cb = parseCallback(args);
+  const acct = accountFor(cb.account);
+  const from = checkedSender(acct, cb);
+  const plain = open(
+    hexToBytes(cb.box, 'box'),
+    hexToBytes(cb.nonce, 'nonce'),
+    await publicKeyFor(acct, from),
+    acct.keys,
+  );
+  if (plain === null)
+    throw new TrainError(
+      'threema_undecryptable',
+      `could not decrypt a message from ${from}; the private key may not match the Gateway ID`,
+      { retryable: false },
+    );
+  const meta: InboundMeta = { ...cb, from, messageId: cb.messageId.toLowerCase() };
+  respond(id, { result: { ok: true, kind: deliver(acct, meta, decode(plain)) } });
+}
+
+export const handleCall = makeStation({
+  handlers: { accounts: listAccounts, send, react, callback, listMembers },
+  normalize: messagingAliases({ action: 'removed' }),
+});

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

@@ -0,0 +1,152 @@
+import { errMsg } from '@metro-labs/core/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { GATEWAY_API, MESSAGE_ID_RE } from './ids.js';
+
+const TIMEOUT_MS = 15_000;
+const PUBLIC_KEY_RE = /^[0-9a-f]{64}$/;
+
+export interface GatewayCreds {
+  gatewayId: string;
+  secret: string;
+}
+
+async function call(
+  path: string,
+  init: RequestInit,
+  label: string,
+): Promise<Response> {
+  try {
+    return await fetch(`${GATEWAY_API}${path}`, {
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+      ...init,
+    });
+  } catch (err) {
+    throw new TrainError(
+      'threema_unreachable',
+      `${label}: could not reach the Threema Gateway (${errMsg(err)})`,
+      { retryable: true },
+    );
+  }
+}
+
+const authQuery = (c: GatewayCreds): string =>
+  new URLSearchParams({ from: c.gatewayId, secret: c.secret }).toString();
+
+function refusal(status: number, what: string): TrainError {
+  if (status === 401)
+    return new TrainError(
+      'threema_unauthorized',
+      'the Threema Gateway rejected this account credentials; check the Gateway ID and API secret',
+      { retryable: false },
+    );
+  if (status === 402)
+    return new TrainError(
+      'threema_no_credits',
+      'this Threema Gateway ID has no credits left; top it up at gateway.threema.ch',
+      { retryable: false },
+    );
+  if (status === 404)
+    return new TrainError('threema_unknown_id', `Threema does not know the ID ${what}`, {
+      retryable: false,
+    });
+  if (status === 413)
+    return new TrainError(
+      'threema_message_too_long',
+      'Threema refused the message as too long',
+      { retryable: false },
+    );
+  if (status === 400)
+    return new TrainError('threema_bad_recipient', `Threema refused the recipient ${what}`, {
+      retryable: false,
+    });
+  return new TrainError(
+    'threema_gateway_error',
+    `the Threema Gateway answered ${status}`,
+    { retryable: status >= 500 },
+  );
+}
+
+export async function fetchPublicKey(
+  c: GatewayCreds,
+  threemaId: string,
+): Promise<string> {
+  const res = await call(
+    `/pubkeys/${encodeURIComponent(threemaId)}?${authQuery(c)}`,
+    {},
+    'pubkeys',
+  );
+  if (!res.ok) throw refusal(res.status, threemaId);
+  const hex = (await res.text()).trim().toLowerCase();
+  if (!PUBLIC_KEY_RE.test(hex))
+    throw new TrainError(
+      'threema_gateway_error',
+      `pubkeys: the Threema Gateway gave an unexpected answer for ${threemaId}`,
+    );
+  return hex;
+}
+
+export async function fetchCredits(c: GatewayCreds): Promise<number> {
+  const res = await call(`/credits?${authQuery(c)}`, {}, 'credits');
+  if (!res.ok) throw refusal(res.status, c.gatewayId);
+  const credits = Number((await res.text()).trim());
+  if (!Number.isInteger(credits))
+    throw new TrainError(
+      'threema_gateway_error',
+      'credits: the Threema Gateway gave an unexpected answer',
+    );
+  return credits;
+}
+
+export async function sendE2E(
+  c: GatewayCreds,
+  to: string,
+  nonceHex: string,
+  boxHex: string,
+  group = false,
+): Promise<string> {
+  const body = new URLSearchParams({
+    from: c.gatewayId,
+    to,
+    nonce: nonceHex,
+    box: boxHex,
+    secret: c.secret,
+    ...(group ? { group: '1' } : {}),
+  });
+  const res = await call(
+    '/send_e2e',
+    {
+      method: 'POST',
+      headers: { 'content-type': 'application/x-www-form-urlencoded' },
+      body: body.toString(),
+    },
+    'send_e2e',
+  );
+  if (!res.ok) throw refusal(res.status, to);
+  const messageId = (await res.text()).trim().toLowerCase();
+  if (!MESSAGE_ID_RE.test(messageId))
+    throw new TrainError(
+      'threema_gateway_error',
+      'send_e2e: the Threema Gateway answered without a message id',
+    );
+  return messageId;
+}
+
+const BLOB_ID_RE = /^[0-9a-f]{32}$/;
+const BLOB_TIMEOUT_MS = 120_000;
+
+export async function uploadBlob(c: GatewayCreds, data: Uint8Array): Promise<string> {
+  const form = new FormData();
+  form.append('blob', new Blob([Buffer.from(data)]), 'blob');
+  const res = await call(`/upload_blob?${authQuery(c)}`, { method: 'POST', body: form, signal: AbortSignal.timeout(BLOB_TIMEOUT_MS) }, 'upload_blob');
+  if (!res.ok) throw refusal(res.status, 'blob');
+  const blobId = (await res.text()).trim().toLowerCase();
+  if (!BLOB_ID_RE.test(blobId)) throw new TrainError('threema_gateway_error', 'upload_blob: the Threema Gateway answered without a blob id');
+  return blobId;
+}
+
+export async function downloadBlob(c: GatewayCreds, blobId: string): Promise<Uint8Array> {
+  if (!BLOB_ID_RE.test(blobId)) throw new TrainError('threema_bad_blob', `'${blobId}' is not a blob id`, { retryable: false });
+  const res = await call(`/blobs/${blobId}?${authQuery(c)}`, { signal: AbortSignal.timeout(BLOB_TIMEOUT_MS) }, 'blob download');
+  if (!res.ok) throw refusal(res.status, `blob ${blobId}`);
+  return new Uint8Array(await res.arrayBuffer());
+}