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

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

@@ -0,0 +1,21 @@
+export const GATEWAY_API = (
+  process.env.THREEMA_GATEWAY_URL ?? 'https://msgapi.threema.ch'
+).replace(/\/+$/, '');
+
+const THREEMA_ID_RE = /^(?:[A-Z0-9]{8}|\*[A-Z0-9]{7})$/;
+const KEY_HEX_RE = /^[0-9a-f]{64}$/;
+
+export const MESSAGE_ID_RE = /^[0-9a-f]{16}$/;
+
+export const isThreemaId = (raw: string): boolean => THREEMA_ID_RE.test(raw);
+
+export const isGatewayId = (raw: string): boolean =>
+  raw.startsWith('*') && isThreemaId(raw);
+
+export const normalizeThreemaId = (raw: string): string =>
+  raw.trim().toUpperCase();
+
+export function parsePrivateKey(raw: string): string | null {
+  const text = raw.trim().replace(/^private:/i, '').trim().toLowerCase();
+  return KEY_HEX_RE.test(text) ? text : null;
+}

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

@@ -0,0 +1,89 @@
+import type { Account } from './accounts.js';
+import { emitInbound } from '@metro-labs/core/stations/train-events';
+import {
+  DIRECT,
+  reactionEnvelope,
+  receiptEnvelope,
+  textEnvelope,
+  type InboundMeta,
+  type Room,
+} from './format.js';
+import { deliverFile } from './files.js';
+import type { Decoded, GroupRef } from './messages.js';
+import { requestSync, sentByUs } from './outbound.js';
+
+const synced = new Set<string>();
+
+function roomOf(acct: Account, group: GroupRef | null): Room {
+  if (group === null) return DIRECT;
+  return { group, name: acct.groups.get(group)?.name ?? null };
+}
+
+function askForRoster(acct: Account, group: GroupRef): void {
+  const key = `${acct.cfg.id}:${group.creator}-${group.groupId}`;
+  if (acct.groups.get(group) !== undefined || synced.has(key)) return;
+  synced.add(key);
+  requestSync(acct, group).catch((err: unknown) => {
+    process.stderr.write(`threema[${acct.cfg.id}]: could not ask ${group.creator} for the group roster: ${err instanceof Error ? err.message : String(err)}\n`);
+  });
+}
+
+function reactions(acct: Account, m: InboundMeta, d: Extract<Decoded, { kind: 'receipt' }>): string {
+  let count = 0;
+  for (const target of d.messageIds) {
+    const env = receiptEnvelope(acct.cfg.id, m, d.status, target, roomOf(acct, d.group));
+    if (env === null) continue;
+    emitInbound(acct.cfg.id, env);
+    count += 1;
+  }
+  return count > 0 ? 'reaction' : `receipt:${String(d.status)}`;
+}
+
+function control(acct: Account, m: InboundMeta, d: Decoded): string | null {
+  if (d.kind === 'group-setup') {
+    acct.groups.setup(m.from, d.groupId, d.members);
+    return 'group-setup';
+  }
+  if (d.kind === 'group-rename') {
+    acct.groups.rename(m.from, d.groupId, d.name);
+    return 'group-rename';
+  }
+  if (d.kind === 'group-leave') {
+    acct.groups.leave(d.group, m.from);
+    return 'group-leave';
+  }
+  return null;
+}
+
+function chat(acct: Account, m: InboundMeta, d: Decoded): string | null {
+  if (d.kind === 'text') {
+    emitInbound(acct.cfg.id, textEnvelope(acct.cfg.id, m, d.text, sentByUs));
+    return 'text';
+  }
+  if (d.kind === 'group-text') {
+    askForRoster(acct, d.group);
+    emitInbound(acct.cfg.id, textEnvelope(acct.cfg.id, m, d.text, sentByUs, roomOf(acct, d.group)));
+    return 'group-text';
+  }
+  if (d.kind === 'file') {
+    if (d.group !== null) askForRoster(acct, d.group);
+    deliverFile(acct, m, d.file, roomOf(acct, d.group), sentByUs);
+    return 'file';
+  }
+  if (d.kind === 'reaction') {
+    if (d.group !== null) askForRoster(acct, d.group);
+    emitInbound(acct.cfg.id, reactionEnvelope(acct.cfg.id, m, d.emoji, d.messageId, d.removed, roomOf(acct, d.group)));
+    return 'reaction';
+  }
+  return null;
+}
+
+export function deliver(acct: Account, m: InboundMeta, d: Decoded): string {
+  const handled = control(acct, m, d) ?? chat(acct, m, d);
+  if (handled !== null) return handled;
+  if (d.kind === 'receipt') return reactions(acct, m, d);
+  if (d.kind === 'typing') return 'typing';
+  const type = d.kind === 'other' ? `0x${d.type.toString(16)}` : d.kind;
+  process.stderr.write(`threema[${acct.cfg.id}]: ignored a message of type ${type} from ${m.from}\n`);
+  return `ignored:${type}`;
+}

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

@@ -0,0 +1,24 @@
+import { errMsg } from '@metro-labs/core/log';
+import { readCalls } from '@metro-labs/core/trains/protocol';
+import { announceAccounts } from '@metro-labs/core/stations/train-boot';
+import { accounts, bootAccount, loadAccounts } from './accounts.js';
+import { handleCall } from './actions.js';
+import { fetchCredits } from './api.js';
+
+readCalls('threema', handleCall);
+
+for (const cfg of loadAccounts()) accounts.set(cfg.id, bootAccount(cfg));
+announceAccounts('threema', accounts.keys());
+
+for (const acct of accounts.values())
+  fetchCredits(acct.cfg)
+    .then((credits) => {
+      process.stderr.write(
+        `threema[${acct.cfg.id}] ${acct.cfg.gatewayId}: ${credits} credits left\n`,
+      );
+    })
+    .catch((err: unknown) => {
+      process.stderr.write(
+        `threema[${acct.cfg.id}] credits check failed: ${errMsg(err)}\n`,
+      );
+    });

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

@@ -0,0 +1,264 @@
+import { bytesToHex, hexToBytes } from './crypto.js';
+
+export const MSG_TEXT = 0x01;
+export const MSG_FILE = 0x17;
+export const MSG_GROUP_TEXT = 0x41;
+export const MSG_GROUP_FILE = 0x46;
+export const MSG_GROUP_SETUP = 0x4a;
+export const MSG_GROUP_RENAME = 0x4b;
+export const MSG_GROUP_LEAVE = 0x4c;
+export const MSG_GROUP_REQUEST_SYNC = 0x51;
+export const MSG_DELIVERY_RECEIPT = 0x80;
+export const MSG_GROUP_DELIVERY_RECEIPT = 0x81;
+export const MSG_REACTION = 0x82;
+export const MSG_GROUP_REACTION = 0x83;
+export const MSG_TYPING = 0x90;
+
+export const RECEIPT_ACK = 0x03;
+export const RECEIPT_DECLINE = 0x04;
+
+export const ID_BYTES = 8;
+const MESSAGE_ID_BYTES = 8;
+const PROTO_MESSAGE_ID = 0x09;
+const PROTO_APPLY = 0x12;
+const PROTO_WITHDRAW = 0x1a;
+
+export interface GroupRef {
+  creator: string;
+  groupId: string;
+}
+
+export interface FileData {
+  blobId: string;
+  key: string;
+  mime: string;
+  name: string;
+  size: number | null;
+  caption: string | null;
+  media: boolean;
+}
+
+export type Decoded =
+  | { kind: 'text'; text: string }
+  | { kind: 'file'; group: GroupRef | null; file: FileData }
+  | { kind: 'group-text'; group: GroupRef; text: string }
+  | { kind: 'group-setup'; groupId: string; members: string[] }
+  | { kind: 'group-rename'; groupId: string; name: string }
+  | { kind: 'group-leave'; group: GroupRef }
+  | { kind: 'receipt'; group: GroupRef | null; status: number; messageIds: string[] }
+  | { kind: 'reaction'; group: GroupRef | null; messageId: string; emoji: string; removed: boolean }
+  | { kind: 'typing' }
+  | { kind: 'other'; type: number };
+
+const ascii = (bytes: Uint8Array): string => Buffer.from(bytes).toString('ascii');
+const utf8 = (bytes: Uint8Array): string => Buffer.from(bytes).toString('utf8');
+
+const groupHeader = (group: GroupRef): Uint8Array =>
+  new Uint8Array([...Buffer.from(group.creator, 'ascii'), ...hexToBytes(group.groupId, 'group id')]);
+
+const readGroup = (body: Uint8Array): GroupRef | null =>
+  body.length < ID_BYTES * 2 ? null : { creator: ascii(body.subarray(0, ID_BYTES)), groupId: bytesToHex(body.subarray(ID_BYTES, ID_BYTES * 2)) };
+
+function ids(body: Uint8Array, from: number): string[] {
+  const out: string[] = [];
+  for (let at = from; at + MESSAGE_ID_BYTES <= body.length; at += MESSAGE_ID_BYTES) out.push(bytesToHex(body.subarray(at, at + MESSAGE_ID_BYTES)));
+  return out;
+}
+
+const members = (body: Uint8Array, from: number): string[] => {
+  const out: string[] = [];
+  for (let at = from; at + ID_BYTES <= body.length; at += ID_BYTES) out.push(ascii(body.subarray(at, at + ID_BYTES)));
+  return out;
+};
+
+function concat(...parts: Uint8Array[]): Uint8Array {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+
+const typed = (type: number, ...parts: Uint8Array[]): Uint8Array => concat(new Uint8Array([type]), ...parts);
+
+export const encodeText = (text: string): Uint8Array => typed(MSG_TEXT, Buffer.from(text, 'utf8'));
+
+export const encodeGroupText = (group: GroupRef, text: string): Uint8Array => typed(MSG_GROUP_TEXT, groupHeader(group), Buffer.from(text, 'utf8'));
+
+const fileJson = (f: FileData): Uint8Array =>
+  Buffer.from(
+    JSON.stringify({
+      b: f.blobId,
+      k: f.key,
+      m: f.mime,
+      n: f.name,
+      ...(f.size === null ? {} : { s: f.size }),
+      i: f.media ? 1 : 0,
+      j: f.media ? 1 : 0,
+      ...(f.caption === null ? {} : { d: f.caption }),
+    }),
+    'utf8',
+  );
+
+export const encodeFile = (f: FileData): Uint8Array => typed(MSG_FILE, fileJson(f));
+
+export const encodeGroupFile = (group: GroupRef, f: FileData): Uint8Array => typed(MSG_GROUP_FILE, groupHeader(group), fileJson(f));
+
+const HEX_RE = /^[0-9a-f]+$/i;
+
+const str = (v: unknown, fallback: string): string => (typeof v === 'string' && v !== '' ? v : fallback);
+const num = (v: unknown): number | null => (typeof v === 'number' ? v : null);
+const hexOf = (v: unknown, length: number): string | null => {
+  const text = typeof v === 'string' ? v.toLowerCase() : '';
+  return text.length === length && HEX_RE.test(text) ? text : null;
+};
+
+function parseJson(raw: Uint8Array): Record<string, unknown> | null {
+  try {
+    const parsed: unknown = JSON.parse(utf8(raw));
+    return typeof parsed === 'object' && parsed !== null ? (parsed as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+export function decodeFileJson(raw: Uint8Array): FileData | null {
+  const o = parseJson(raw);
+  if (o === null) return null;
+  const blobId = hexOf(o.b, 32);
+  const key = hexOf(o.k, 64);
+  if (blobId === null || key === null) return null;
+  const rendering = num(o.j) ?? num(o.i) ?? 0;
+  return {
+    blobId,
+    key,
+    mime: str(o.m, 'application/octet-stream'),
+    name: str(o.n, 'file'),
+    size: num(o.s),
+    caption: typeof o.d === 'string' && o.d !== '' ? o.d : null,
+    media: rendering === 1,
+  };
+}
+
+export const encodeGroupSyncRequest = (groupId: string): Uint8Array => typed(MSG_GROUP_REQUEST_SYNC, hexToBytes(groupId, 'group id'));
+
+function varint(n: number): Uint8Array {
+  const out: number[] = [];
+  let rest = n;
+  while (rest >= 0x80) {
+    out.push((rest & 0x7f) | 0x80);
+    rest = Math.floor(rest / 0x80);
+  }
+  out.push(rest);
+  return new Uint8Array(out);
+}
+
+export function encodeReactionProto(messageId: string, emoji: string, removed: boolean): Uint8Array {
+  const emojiBytes = Buffer.from(emoji, 'utf8');
+  return concat(
+    new Uint8Array([PROTO_MESSAGE_ID]),
+    hexToBytes(messageId, 'message id'),
+    new Uint8Array([removed ? PROTO_WITHDRAW : PROTO_APPLY]),
+    varint(emojiBytes.length),
+    emojiBytes,
+  );
+}
+
+export const encodeReaction = (messageId: string, emoji: string, removed: boolean): Uint8Array =>
+  typed(MSG_REACTION, encodeReactionProto(messageId, emoji, removed));
+
+export const encodeGroupReaction = (group: GroupRef, messageId: string, emoji: string, removed: boolean): Uint8Array =>
+  typed(MSG_GROUP_REACTION, groupHeader(group), encodeReactionProto(messageId, emoji, removed));
+
+function readVarint(body: Uint8Array, at: number): { value: number; next: number } | null {
+  let value = 0;
+  let shift = 1;
+  for (let i = at; i < body.length; i++) {
+    const byte = body[i] ?? 0;
+    value += (byte & 0x7f) * shift;
+    if (byte < 0x80) return { value, next: i + 1 };
+    shift *= 0x80;
+  }
+  return null;
+}
+
+interface ProtoField {
+  tag: number;
+  bytes: Uint8Array;
+  next: number;
+}
+
+function readField(body: Uint8Array, at: number): ProtoField | null {
+  const tag = body[at] ?? 0;
+  if (tag === PROTO_MESSAGE_ID)
+    return at + 1 + MESSAGE_ID_BYTES > body.length ? null : { tag, bytes: body.subarray(at + 1, at + 1 + MESSAGE_ID_BYTES), next: at + 1 + MESSAGE_ID_BYTES };
+  if (tag !== PROTO_APPLY && tag !== PROTO_WITHDRAW) return null;
+  const len = readVarint(body, at + 1);
+  if (len === null || len.next + len.value > body.length) return null;
+  return { tag, bytes: body.subarray(len.next, len.next + len.value), next: len.next + len.value };
+}
+
+export function decodeReactionProto(body: Uint8Array): { messageId: string; emoji: string; removed: boolean } | null {
+  let messageId: string | null = null;
+  let emoji = '';
+  let removed = false;
+  for (let at = 0; at < body.length; ) {
+    const field = readField(body, at);
+    if (field === null) return null;
+    if (field.tag === PROTO_MESSAGE_ID) messageId = bytesToHex(field.bytes);
+    else {
+      emoji = utf8(field.bytes);
+      removed = field.tag === PROTO_WITHDRAW;
+    }
+    at = field.next;
+  }
+  return messageId === null || emoji === '' ? null : { messageId, emoji, removed };
+}
+
+function decodeGroup(type: number, body: Uint8Array): Decoded {
+  const group = readGroup(body);
+  if (group === null) return { kind: 'other', type };
+  const rest = body.subarray(ID_BYTES * 2);
+  if (type === MSG_GROUP_TEXT) return { kind: 'group-text', group, text: utf8(rest) };
+  if (type === MSG_GROUP_FILE) {
+    const file = decodeFileJson(rest);
+    return file === null ? { kind: 'other', type } : { kind: 'file', group, file };
+  }
+  if (type === MSG_GROUP_LEAVE) return { kind: 'group-leave', group };
+  if (type === MSG_GROUP_DELIVERY_RECEIPT) return { kind: 'receipt', group, status: rest[0] ?? 0, messageIds: ids(rest, 1) };
+  const reaction = decodeReactionProto(rest);
+  return reaction === null ? { kind: 'other', type } : { kind: 'reaction', group, ...reaction };
+}
+
+const GROUP_TYPES = new Set([MSG_GROUP_TEXT, MSG_GROUP_FILE, MSG_GROUP_LEAVE, MSG_GROUP_DELIVERY_RECEIPT, MSG_GROUP_REACTION]);
+const DIRECT_TYPES = new Set([MSG_TEXT, MSG_FILE, MSG_TYPING, MSG_DELIVERY_RECEIPT, MSG_REACTION]);
+
+function decodeControl(type: number, body: Uint8Array): Decoded {
+  if (body.length < ID_BYTES) return { kind: 'other', type };
+  const groupId = bytesToHex(body.subarray(0, ID_BYTES));
+  if (type === MSG_GROUP_SETUP) return { kind: 'group-setup', groupId, members: members(body, ID_BYTES) };
+  return { kind: 'group-rename', groupId, name: utf8(body.subarray(ID_BYTES)) };
+}
+
+function decodeDirect(type: number, body: Uint8Array): Decoded {
+  if (type === MSG_TEXT) return { kind: 'text', text: utf8(body) };
+  if (type === MSG_FILE) {
+    const file = decodeFileJson(body);
+    return file === null ? { kind: 'other', type } : { kind: 'file', group: null, file };
+  }
+  if (type === MSG_TYPING) return { kind: 'typing' };
+  if (type === MSG_DELIVERY_RECEIPT) return { kind: 'receipt', group: null, status: body[0] ?? 0, messageIds: ids(body, 1) };
+  const reaction = decodeReactionProto(body);
+  return reaction === null ? { kind: 'other', type } : { kind: 'reaction', group: null, ...reaction };
+}
+
+export function decode(plain: Uint8Array): Decoded {
+  const type = plain[0] ?? -1;
+  const body = plain.subarray(1);
+  if (DIRECT_TYPES.has(type)) return decodeDirect(type, body);
+  if (type === MSG_GROUP_SETUP || type === MSG_GROUP_RENAME) return decodeControl(type, body);
+  if (GROUP_TYPES.has(type)) return decodeGroup(type, body);
+  return { kind: 'other', type };
+}

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

@@ -0,0 +1,160 @@
+import { TrainError } from '@metro-labs/core/train-error';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { publicKeyFor, targetOf, type Account, type Target } from './accounts.js';
+import { sendE2E } from './api.js';
+import { bytesToHex, quoted, seal } from './crypto.js';
+import { encodeFileFor, fileLabel, packFile, type OutgoingFile } from './files.js';
+import { emitOutbound, emitOutboundReaction } from './format.js';
+import { MESSAGE_ID_RE } from './ids.js';
+import {
+  encodeGroupReaction,
+  encodeGroupSyncRequest,
+  encodeGroupText,
+  encodeReaction,
+  encodeText,
+  type GroupRef,
+} from './messages.js';
+
+export const MAX_TEXT_BYTES = 3500;
+const SENT_MAX = 2000;
+
+type Args = Record<string, unknown>;
+
+const sentIds = new Set<string>();
+
+export function noteSent(messageId: string): void {
+  sentIds.add(messageId);
+  while (sentIds.size > SENT_MAX) {
+    const oldest = sentIds.values().next();
+    if (oldest.done) break;
+    sentIds.delete(oldest.value);
+  }
+}
+
+export const sentByUs = (messageId: string): boolean => sentIds.has(messageId);
+
+async function deliver(acct: Account, to: string, plain: Uint8Array, group: boolean): Promise<string> {
+  const { nonce, box } = seal(plain, await publicKeyFor(acct, to), acct.keys);
+  const messageId = await sendE2E(acct.cfg, to, bytesToHex(nonce), bytesToHex(box), group);
+  noteSent(messageId);
+  return messageId;
+}
+
+function recipientsOf(acct: Account, group: GroupRef): string[] {
+  const members = acct.groups.recipients(group);
+  if (members === null)
+    throw new TrainError(
+      'threema_unknown_group',
+      'metro has not received this group\'s member list yet; it asked the group creator for it, try again in a moment',
+      { retryable: true },
+    );
+  return members;
+}
+
+export async function requestSync(acct: Account, group: GroupRef): Promise<void> {
+  await deliver(acct, group.creator, encodeGroupSyncRequest(group.groupId), true);
+}
+
+async function fanOut(acct: Account, target: Target, direct: Uint8Array, grouped: (g: GroupRef) => Uint8Array): Promise<string[]> {
+  if (target.kind === 'user') return [await deliver(acct, target.id, direct, false)];
+  const ids: string[] = [];
+  for (const member of recipientsOf(acct, target.group)) ids.push(await deliver(acct, member, grouped(target.group), true));
+  if (ids.length === 0) throw new TrainError('threema_empty_group', 'nobody else is in this group', { retryable: false });
+  return ids;
+}
+
+interface SendArgs {
+  line: string;
+  text?: unknown;
+  replyTo?: unknown;
+  account?: string;
+  attachments?: unknown;
+}
+
+const filesOf = (raw: unknown): OutgoingFile[] =>
+  (Array.isArray(raw) ? raw : [])
+    .map((a) => (a ?? {}) as Record<string, unknown>)
+    .filter((a) => typeof a.path === 'string' && a.path !== '')
+    .map((a) => ({ path: String(a.path), mime: typeof a.mime === 'string' && a.mime !== '' ? a.mime : 'application/octet-stream', name: typeof a.name === 'string' && a.name !== '' ? a.name : 'file' }));
+
+function textOf(a: SendArgs, files: OutgoingFile[]): string {
+  const text = typeof a.text === 'string' ? a.text : '';
+  if (text === '' && files.length === 0)
+    throw new TrainError('threema_text_required', 'give some text or a file to send', { retryable: false });
+  return text;
+}
+
+async function sendFiles(acct: Account, target: Target, files: OutgoingFile[], caption: string | null): Promise<{ ids: string[]; labels: string[] }> {
+  const ids: string[] = [];
+  const labels: string[] = [];
+  for (const [i, file] of files.entries()) {
+    const packed = await packFile(acct, file, i === 0 ? caption : null);
+    const sent = await fanOut(acct, target, encodeFileFor(null, packed), (g) => encodeFileFor(g, packed));
+    ids.push(...sent);
+    labels.push(fileLabel(file));
+  }
+  return { ids, labels };
+}
+
+function messageIdOf(raw: unknown, field: string): string {
+  const id = typeof raw === 'string' ? raw.toLowerCase() : '';
+  if (!MESSAGE_ID_RE.test(id))
+    throw new TrainError('threema_bad_message_id', `${field} must be a Threema message id, 16 hex characters`, { retryable: false });
+  return id;
+}
+
+const replyTargetOf = (raw: unknown): string | undefined => (raw === undefined || raw === null || raw === '' ? undefined : messageIdOf(raw, 'replyTo'));
+
+function bodyOf(text: string, replyTo: string | undefined): string {
+  const body = replyTo === undefined ? text : quoted(replyTo, text);
+  if (Buffer.byteLength(body, 'utf8') > MAX_TEXT_BYTES)
+    throw new TrainError('threema_message_too_long', `Threema carries at most ${MAX_TEXT_BYTES} bytes of text per message; split it up`, { retryable: false });
+  return body;
+}
+
+interface Sent {
+  ids: string[];
+  labels: string[];
+}
+
+const resultOf = (acct: Account, sent: Sent): Record<string, unknown> => ({
+  messageId: sent.ids[0] ?? '',
+  account: acct.cfg.id,
+  ...(sent.ids.length > 1 ? { messageIds: sent.ids } : {}),
+  ...(sent.labels.length > 0 ? { attachments: sent.labels } : {}),
+});
+
+export async function send(id: string, args: Args): Promise<void> {
+  const a = args as unknown as SendArgs;
+  const files = filesOf(a.attachments);
+  const text = textOf(a, files);
+  const replyTo = replyTargetOf(a.replyTo);
+  const { acct, target } = targetOf(a.line, a.account);
+  const body = bodyOf(text, replyTo);
+  const sent: Sent =
+    files.length === 0
+      ? { ids: await fanOut(acct, target, encodeText(body), (g) => encodeGroupText(g, body)), labels: [] }
+      : await sendFiles(acct, target, files, body === '' ? null : body);
+  emitOutbound(acct.cfg.id, a.line, sent.ids[0] ?? '', text === '' ? `[${sent.labels.join(', ')}]` : text, replyTo);
+  respond(id, { result: resultOf(acct, sent) });
+}
+
+interface ReactArgs {
+  line: string;
+  messageId?: unknown;
+  emoji?: unknown;
+  account?: string;
+  action?: unknown;
+}
+
+export async function react(id: string, args: Args): Promise<void> {
+  const a = args as unknown as ReactArgs;
+  const emoji = typeof a.emoji === 'string' ? a.emoji.trim() : '';
+  if (emoji === '') throw new TrainError('threema_emoji_required', 'react needs an emoji', { retryable: false });
+  const messageId = messageIdOf(a.messageId, 'messageId');
+  const removed = a.action === 'removed';
+  const { acct, target } = targetOf(a.line, a.account);
+  const ids = await fanOut(acct, target, encodeReaction(messageId, emoji, removed), (g) => encodeGroupReaction(g, messageId, emoji, removed));
+  emitOutboundReaction(acct.cfg.id, a.line, ids[0] ?? '', emoji, messageId, removed);
+  respond(id, { result: { messageId: ids[0] ?? '', account: acct.cfg.id, emoji, removed } });
+}

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

@@ -0,0 +1,13 @@
+import type { Station, Verb } from '@metro-labs/core/stations/types';
+import { groupFiles } from './groups.js';
+
+export const threemaStation: Station = {
+  name: 'threema',
+  hasAccounts: true,
+  hasTrain: true,
+  messageVerbs: new Set<Verb>(['send', 'reply', 'react', 'unreact']),
+  attachmentMode: 'canonical',
+  forget: groupFiles.forget,
+  forgetExcept: groupFiles.forgetExcept,
+  tools: [],
+};

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

@@ -0,0 +1,117 @@
+import { createPrivateKey, createPublicKey } from 'node:crypto';
+import {
+  GATEWAY_API,
+  isGatewayId,
+  normalizeThreemaId,
+  parsePrivateKey,
+} from './ids.js';
+
+export { parsePrivateKey } from './ids.js';
+
+export class ThreemaGatewayError extends Error {}
+
+export interface ThreemaCredentials {
+  gatewayId: string;
+  secret: string;
+  privateKey: string;
+}
+
+export interface ThreemaGatewayIdentity {
+  gatewayId: string;
+  publicKey: string;
+  credits: number;
+}
+
+const PKCS8_X25519_PREFIX = Buffer.from(
+  '302e020100300506032b656e04220420',
+  'hex',
+);
+const TIMEOUT_MS = 10_000;
+const PUBLIC_KEY_RE = /^[0-9a-f]{64}$/;
+
+export function publicKeyOf(privateKeyHex: string): string {
+  const der = Buffer.concat([
+    PKCS8_X25519_PREFIX,
+    Buffer.from(privateKeyHex, 'hex'),
+  ]);
+  const key = createPrivateKey({ key: der, format: 'der', type: 'pkcs8' });
+  const jwk = createPublicKey(key).export({ format: 'jwk' });
+  return Buffer.from(String(jwk.x), 'base64url').toString('hex');
+}
+
+async function gatewayGet(
+  path: string,
+  gatewayId: string,
+  secret: string,
+): Promise<Response> {
+  const query = new URLSearchParams({ from: gatewayId, secret });
+  try {
+    return await fetch(`${GATEWAY_API}${path}?${query.toString()}`, {
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+  } catch {
+    throw new ThreemaGatewayError(
+      'could not reach the Threema Gateway to check those credentials',
+    );
+  }
+}
+
+function refused(res: Response, what: string): ThreemaGatewayError {
+  if (res.status === 401)
+    return new ThreemaGatewayError(
+      'Threema rejected that Gateway ID or API secret',
+    );
+  if (res.status === 404)
+    return new ThreemaGatewayError(`Threema does not know ${what}`);
+  return new ThreemaGatewayError(
+    `the Threema Gateway answered ${res.status} while checking ${what}`,
+  );
+}
+
+async function fetchCredits(gatewayId: string, secret: string): Promise<number> {
+  const res = await gatewayGet('/credits', gatewayId, secret);
+  if (!res.ok) throw refused(res, 'the credit balance');
+  const credits = Number((await res.text()).trim());
+  if (!Number.isInteger(credits))
+    throw new ThreemaGatewayError(
+      'the Threema Gateway gave an unexpected answer for the credit balance',
+    );
+  return credits;
+}
+
+async function fetchPublicKey(gatewayId: string, secret: string): Promise<string> {
+  const res = await gatewayGet(
+    `/pubkeys/${encodeURIComponent(gatewayId)}`,
+    gatewayId,
+    secret,
+  );
+  if (!res.ok) throw refused(res, `the public key of ${gatewayId}`);
+  const hex = (await res.text()).trim().toLowerCase();
+  if (!PUBLIC_KEY_RE.test(hex))
+    throw new ThreemaGatewayError(
+      'the Threema Gateway gave an unexpected answer for the public key',
+    );
+  return hex;
+}
+
+export async function verifyThreemaGateway(
+  input: ThreemaCredentials,
+): Promise<ThreemaGatewayIdentity> {
+  const gatewayId = normalizeThreemaId(input.gatewayId);
+  if (!isGatewayId(gatewayId))
+    throw new ThreemaGatewayError(
+      'a Threema Gateway ID is a * followed by 7 letters or digits, as in *ABCDEFG',
+    );
+  const privateKey = parsePrivateKey(input.privateKey);
+  if (privateKey === null)
+    throw new ThreemaGatewayError(
+      'the private key is the 64 hex characters from the key file Threema gave you, with or without its private: prefix',
+    );
+  const credits = await fetchCredits(gatewayId, input.secret);
+  const registered = await fetchPublicKey(gatewayId, input.secret);
+  if (registered !== publicKeyOf(privateKey))
+    throw new ThreemaGatewayError(
+      `that private key does not belong to ${gatewayId}: the Gateway holds a different public key for it`,
+    );
+  return { gatewayId, publicKey: registered, credits };
+}