@stage-labs/metro 0.1.0-beta.98 → 0.1.0-beta.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.98",
+  "version": "0.1.0-beta.99",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.98",
+  "version": "0.1.0-beta.99",
   "description": "Metro connectors for Claude Code. Runs beside the metro daemon on this machine: each connector the agent holds is one MCP server relayed through the daemon, the daemon keeps that list current on its own, and /reload-plugins picks up a new one without leaving your session. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

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

@@ -25,6 +25,8 @@ function parseAccountScoped(
 }
 
 const isSnowflake = (s: string): boolean => /^\d+$/.test(s);
+const isThreemaId = (s: string): boolean =>
+  /^(?:[A-Z0-9]{8}|\*[A-Z0-9]{7})$/i.test(s);
 const isSignedInt = (s: string): boolean => /^-?\d+$/.test(s);
 
 function splitTelegramAccount(path: string[]): { accountId: string; rest: string[] } {
@@ -79,4 +81,7 @@ export const Line = {
     parseAccountScoped(line, 'discord-bot', isSnowflake),
 
   parseTelegram: (line: Line | string) => parseTelegramLine(line),
+
+  parseThreema: (line: Line | string) =>
+    parseAccountScoped(line, 'threema', isThreemaId),
 };

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

@@ -4,6 +4,7 @@ export const STATIONS = [
   'telegram',
   'discord-bot',
   'whatsapp',
+  'threema',
   'webhook',
 ] as const;
 

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

@@ -28,6 +28,7 @@
     "@metro-labs/discord-bot": "workspace:*",
     "@metro-labs/telegram": "workspace:*",
     "@metro-labs/telegram-bot": "workspace:*",
+    "@metro-labs/threema": "workspace:*",
     "@metro-labs/webhook": "workspace:*",
     "@metro-labs/whatsapp": "workspace:*",
     "@metro-labs/xmtp": "workspace:*",

package/runtime/node_modules/@metro-labs/daemon/src/agents/accounts-api.ts

@@ -18,6 +18,7 @@ import {
 import type { StationName } from '@metro-labs/core/station-names';
 import {
   ATTACHABLE_STATIONS,
+  attachInputOf,
   isAttachStation,
   type AttachInput,
   type OneTimeSecret,
@@ -219,10 +220,7 @@ async function handleStart(
   }
   if (!isAttachStation(station))
     throw new ApiError(`station must be one of ${ATTACHABLE.join(', ')}`, 400);
-  const prepared = await deps.prepareAccount({
-    station,
-    token: bodyField(body, 'token'),
-  });
+  const prepared = await deps.prepareAccount(attachInputOf(station, body));
   const ref = await storeAccount(deps, session, agentId, station, prepared);
   log.info(
     { agentId: ref.agentId, station, account: ref.accountId },

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

@@ -4,7 +4,7 @@ import {
   stationByName,
 } from '../stations/registry.js';
 import { listEndpoints } from '../net/tunnel.js';
-import { hookUrl } from '../stations/attach.js';
+import { hookUrl, threemaCallbackUrl } from '../stations/attach.js';
 import { accountEnabled, agentIdForAccount, allowlistForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
 
 const accountId = (acc: unknown): string | undefined => {
@@ -72,6 +72,17 @@ function inCoreAccounts(station: string): unknown[] {
   );
 }
 
+function withCallbackUrl(acc: unknown): unknown {
+  const rec = asRecord(acc);
+  if (rec === undefined) return acc;
+  const { callbackId, callbackToken, ...rest } = rec;
+  if (typeof callbackId !== 'string' || typeof callbackToken !== 'string') return rest;
+  return { ...rest, callback: threemaCallbackUrl(callbackId, callbackToken) };
+}
+
+const decorate = (station: string, rows: unknown[]): unknown[] =>
+  station === 'threema' ? rows.map(withCallbackUrl) : rows;
+
 export interface ScopedAccounts {
   accounts: Record<string, unknown[]>;
   unavailable: string[];
@@ -85,7 +96,7 @@ async function liveAccounts(
   try {
     const resp = await forwardTrainCall(station, 'accounts', {});
     const list = (resp.result as { accounts?: unknown[] } | undefined)?.accounts;
-    return { rows: Array.isArray(list) ? list : [], reachable: true };
+    return { rows: decorate(station, Array.isArray(list) ? list : []), reachable: true };
   } catch {
     return { rows: [], reachable: false };
   }

package/runtime/node_modules/@metro-labs/daemon/src/routes/body.ts

@@ -0,0 +1,24 @@
+import type { IncomingMessage } from 'node:http';
+
+export const WEBHOOK_BODY_MAX = 25 * 1024 * 1024;
+
+export class BodyTooLargeError extends Error {
+  constructor(readonly limit: number) {
+    super(`request body exceeds ${limit} bytes`);
+  }
+}
+
+export async function readBody(
+  req: IncomingMessage,
+  maxBytes: number,
+): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  for await (const c of req) {
+    const buf = c as Buffer;
+    total += buf.length;
+    if (total > maxBytes) throw new BodyTooLargeError(maxBytes);
+    chunks.push(buf);
+  }
+  return Buffer.concat(chunks);
+}

package/runtime/node_modules/@metro-labs/daemon/src/routes/http.ts

@@ -1,6 +1,10 @@
 import { handleSessionApis, type SessionApis } from './session-apis.js';
 import { handleGatewayRequest } from '../gateway/gateway.js';
 import { handleRelayRequest } from '../connectors/relay.js';
+import { handleThreemaCallback } from './threema-callback.js';
+import { BodyTooLargeError, readBody, WEBHOOK_BODY_MAX } from './body.js';
+
+export { BodyTooLargeError, readBody } from './body.js';
 import {
   createServer,
   type IncomingMessage,
@@ -214,29 +218,6 @@ function isMcpPath(req: IncomingMessage): boolean {
   return path === '/' || path === '/mcp';
 }
 
-export const WEBHOOK_BODY_MAX = 25 * 1024 * 1024;
-
-export class BodyTooLargeError extends Error {
-  constructor(readonly limit: number) {
-    super(`request body exceeds ${limit} bytes`);
-  }
-}
-
-export async function readBody(
-  req: IncomingMessage,
-  maxBytes: number,
-): Promise<Buffer> {
-  const chunks: Buffer[] = [];
-  let total = 0;
-  for await (const c of req) {
-    const buf = c as Buffer;
-    total += buf.length;
-    if (total > maxBytes) throw new BodyTooLargeError(maxBytes);
-    chunks.push(buf);
-  }
-  return Buffer.concat(chunks);
-}
-
 function flatHeaders(req: IncomingMessage): Record<string, string> {
   return Object.fromEntries(
     Object.entries(req.headers).map(([k, v]) => [
@@ -368,6 +349,7 @@ async function handlePreMcpRoutes(
   if (handleAttachRequest(req, res)) return true;
   if (apis.relayApi && handleRelayRequest(req, res, apis.relayApi)) return true;
   if (await handleWebhookRoute(req, res, emit)) return true;
+  if (await handleThreemaCallback(req, res)) return true;
   return Boolean(monitorCall && handleMonitorRequest(req, res, monitorCall));
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/routes/threema-callback.ts

@@ -0,0 +1,103 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from '@metro-labs/core/log';
+import { tokenMatches } from '../net/tunnel.js';
+import {
+  findThreemaCallback,
+  type ThreemaCallback,
+} from '../stations/threema-callbacks.js';
+import { forwardTrainCall, type TrainCallBackend } from '../stations/train-call.js';
+import { BodyTooLargeError, readBody } from './body.js';
+
+const PREFIX = '/api/threema/';
+const CALLBACK_PATH = /^\/api\/threema\/([0-9]{17,20})\/([A-Za-z0-9_-]{32,128})$/;
+const BODY_MAX = 64 * 1024;
+const REQUIRED = ['from', 'to', 'messageId', 'date', 'nonce', 'box', 'mac'] as const;
+
+function callbackTarget(path: string): ThreemaCallback | null {
+  const m = CALLBACK_PATH.exec(path);
+  const callbackId = m?.[1];
+  const token = m?.[2];
+  if (callbackId === undefined || token === undefined) return null;
+  const row = findThreemaCallback(callbackId);
+  return row !== undefined && tokenMatches(row.callbackToken, token) ? row : null;
+}
+
+function parseFields(raw: Buffer): Record<string, string> | null {
+  const params = new URLSearchParams(raw.toString('utf8'));
+  const out: Record<string, string> = {};
+  for (const key of REQUIRED) {
+    const value = params.get(key)?.trim() ?? '';
+    if (value === '') return null;
+    out[key] = value;
+  }
+  const nickname = params.get('nickname')?.trim() ?? '';
+  if (nickname !== '') out.nickname = nickname;
+  return out;
+}
+
+async function deliver(
+  res: ServerResponse,
+  target: ThreemaCallback,
+  fields: Record<string, string>,
+  forward: TrainCallBackend,
+): Promise<void> {
+  let response;
+  try {
+    response = await forward('threema', 'callback', { account: target.id, ...fields });
+  } catch (err) {
+    log.warn(
+      { account: target.id, err: errMsg(err) },
+      'threema: the callback could not reach the train, so Threema is asked to retry',
+    );
+    res.writeHead(503).end('threema train unavailable');
+    return;
+  }
+  if (response.error !== undefined) {
+    log.warn({ account: target.id, err: response.error }, 'threema: callback refused');
+    res.writeHead(400).end('refused');
+    return;
+  }
+  res.writeHead(200).end('ok');
+}
+
+async function readFields(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<Record<string, string> | null> {
+  let raw: Buffer;
+  try {
+    raw = await readBody(req, BODY_MAX);
+  } catch (err) {
+    if (!(err instanceof BodyTooLargeError)) throw err;
+    res.writeHead(413).end('payload too large');
+    return null;
+  }
+  const fields = parseFields(raw);
+  if (fields === null) res.writeHead(400).end('missing callback fields');
+  return fields;
+}
+
+export async function handleThreemaCallback(
+  req: IncomingMessage,
+  res: ServerResponse,
+  forward: TrainCallBackend = forwardTrainCall,
+): Promise<boolean> {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (!path.startsWith(PREFIX)) return false;
+  const target = callbackTarget(path);
+  if (target === null) {
+    res.writeHead(404).end();
+    return true;
+  }
+  if (req.method === 'GET') {
+    res.writeHead(200).end(`metro threema callback ${target.callbackId} ready\n`);
+    return true;
+  }
+  if (req.method !== 'POST') {
+    res.writeHead(405).end();
+    return true;
+  }
+  const fields = await readFields(req, res);
+  if (fields !== null) await deliver(res, target, fields, forward);
+  return true;
+}

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

@@ -7,7 +7,13 @@ import {
   TelegramTokenError,
   verifyTelegramBotToken,
 } from '@metro-labs/telegram-bot/verify';
+import {
+  parsePrivateKey,
+  ThreemaGatewayError,
+  verifyThreemaGateway,
+} from '@metro-labs/threema/verify';
 import { ApiError } from '@metro-labs/http/api-error';
+import { bodyField } from '@metro-labs/http/api-http';
 import { ensureStationDeps } from './runtime-deps.js';
 import { publicBaseOrDefault } from '../files/attach-serve.js';
 import {
@@ -21,6 +27,7 @@ import {
 export const ATTACHABLE_STATIONS = [
   'discord-bot',
   'telegram-bot',
+  'threema',
   'xmtp',
   'webhook',
 ] as const;
@@ -32,6 +39,9 @@ export class StationAttachError extends ApiError {}
 export interface AttachInput {
   station: AttachStation;
   token?: unknown;
+  gatewayId?: unknown;
+  secret?: unknown;
+  privateKey?: unknown;
 }
 
 export interface OneTimeSecret {
@@ -53,6 +63,16 @@ const SECP256K1_ORDER = BigInt(
   '0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141',
 );
 
+export function attachInputOf(station: AttachStation, body: unknown): AttachInput {
+  return {
+    station,
+    token: bodyField(body, 'token'),
+    gatewayId: bodyField(body, 'gatewayId'),
+    secret: bodyField(body, 'secret'),
+    privateKey: bodyField(body, 'privateKey'),
+  };
+}
+
 export function isAttachStation(raw: unknown): raw is AttachStation {
   return (
     typeof raw === 'string' &&
@@ -163,6 +183,49 @@ export function newWebhookId(): string {
   return String(WEBHOOK_ID_FLOOR + (raw % (9n * WEBHOOK_ID_FLOOR)));
 }
 
+export const threemaCallbackUrl = (callbackId: string, token: string): string =>
+  `${publicBaseOrDefault().replace(/\/+$/, '')}/api/threema/${callbackId}/${token}`;
+
+function requireText(raw: unknown, label: string): string {
+  const text = typeof raw === 'string' ? raw.trim() : '';
+  if (text === '')
+    throw new StationAttachError(`the Threema ${label} is required`, 400);
+  return text;
+}
+
+async function prepareThreema(input: AttachInput): Promise<PreparedAccount> {
+  const gatewayId = requireText(input.gatewayId, 'Gateway ID');
+  const secret = requireText(input.secret, 'API secret');
+  const privateKey = requireText(input.privateKey, 'private key');
+  try {
+    const identity = await verifyThreemaGateway({ gatewayId, secret, privateKey });
+    const callbackId = newWebhookId();
+    const callbackToken = randomBytes(48).toString('base64url');
+    return {
+      config: {
+        gatewayId: identity.gatewayId,
+        secret,
+        privateKey: parsePrivateKey(privateKey) ?? privateKey,
+        callbackId,
+        callbackToken,
+        createdAt: new Date().toISOString(),
+      },
+      identity: {
+        gatewayId: identity.gatewayId,
+        credits: String(identity.credits),
+        callback: threemaCallbackUrl(callbackId, callbackToken),
+      },
+    };
+  } catch (err) {
+    if (err instanceof StationAttachError) throw err;
+    return rejected(
+      err,
+      err instanceof ThreemaGatewayError,
+      'Threema rejected those Gateway credentials',
+    );
+  }
+}
+
 function prepareWebhook(): PreparedAccount {
   const secret = randomBytes(48).toString('base64url');
   const webhookId = newWebhookId();
@@ -180,5 +243,6 @@ export async function prepareAccount(
   if (input.station === 'discord-bot') return prepareDiscord(input.token);
   if (input.station === 'telegram-bot') return prepareTelegram(input.token);
   if (input.station === 'webhook') return prepareWebhook();
+  if (input.station === 'threema') return prepareThreema(input);
   return prepareXmtp(verify);
 }

package/runtime/node_modules/@metro-labs/daemon/src/stations/materialize.ts

@@ -79,6 +79,11 @@ const STATION_TARGETS: Record<StationName, StationTarget> = {
     fileEnv: 'WHATSAPP_ACCOUNTS_FILE',
     trainImport: '@metro-labs/whatsapp/train',
   },
+  threema: {
+    file: 'threema-accounts.json',
+    fileEnv: 'THREEMA_ACCOUNTS_FILE',
+    trainImport: '@metro-labs/threema/train',
+  },
   webhook: {
     file: 'webhook-accounts.json',
     fileEnv: 'WEBHOOK_ACCOUNTS_FILE',
@@ -86,7 +91,7 @@ const STATION_TARGETS: Record<StationName, StationTarget> = {
   },
 };
 
-function accountFilePath(station: StationName): string {
+export function accountFilePath(station: StationName): string {
   const target = STATION_TARGETS[station];
   return process.env[target.fileEnv] ?? join(METRO_DIR, target.file);
 }

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

@@ -5,6 +5,7 @@ import { telegramBotStation } from '@metro-labs/telegram-bot';
 import { telegramStation } from '@metro-labs/telegram';
 import { discordBotStation } from '@metro-labs/discord-bot';
 import { whatsappStation } from '@metro-labs/whatsapp';
+import { threemaStation } from '@metro-labs/threema';
 import { webhookStation } from '@metro-labs/webhook';
 
 export const STATIONS: readonly Station[] = [
@@ -13,6 +14,7 @@ export const STATIONS: readonly Station[] = [
   telegramStation,
   discordBotStation,
   whatsappStation,
+  threemaStation,
   webhookStation,
 ];
 

package/runtime/node_modules/@metro-labs/daemon/src/stations/threema-callbacks.ts

@@ -0,0 +1,32 @@
+import { readJson } from '@metro-labs/core/secure-fs';
+import { accountFilePath } from './materialize.js';
+
+export interface ThreemaCallback {
+  id: string;
+  callbackId: string;
+  callbackToken: string;
+}
+
+const str = (v: unknown): string | undefined =>
+  typeof v === 'string' && v !== '' ? v : undefined;
+
+function toCallback(row: unknown): ThreemaCallback | null {
+  if (typeof row !== 'object' || row === null) return null;
+  const rec = row as Record<string, unknown>;
+  const id = str(rec.id);
+  const callbackId = str(rec.callbackId);
+  const callbackToken = str(rec.callbackToken);
+  if (id === undefined || callbackId === undefined || callbackToken === undefined) return null;
+  return { id, callbackId, callbackToken };
+}
+
+export function listThreemaCallbacks(): ThreemaCallback[] {
+  const raw = readJson<unknown[]>(accountFilePath('threema'), [], {
+    warn: 'threema-accounts.json: malformed, ignoring',
+  });
+  if (!Array.isArray(raw)) return [];
+  return raw.map(toCallback).filter((c): c is ThreemaCallback => c !== null);
+}
+
+export const findThreemaCallback = (callbackId: string): ThreemaCallback | undefined =>
+  listThreemaCallbacks().find((c) => c.callbackId === callbackId);

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,100 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+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';
+
+const ACCOUNTS_FILE =
+  process.env.THREEMA_ACCOUNTS_FILE ??
+  join(homedir(), '.metro', 'threema-accounts.json');
+
+export interface AccountConfig {
+  id: string;
+  gatewayId: string;
+  secret: string;
+  privateKey: string;
+  callbackId?: string;
+  callbackToken?: string;
+  owner?: string;
+}
+
+function checkAccount(a: AccountConfig, die: Die): void {
+  if (!a.id) die('account missing id');
+  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',
+  file: ACCOUNTS_FILE,
+  validate(raw, die) {
+    const seenId = new Set<string>();
+    const seenGateway = new Set<string>();
+    for (const a of raw) {
+      checkAccount(a, die);
+      if (seenId.has(a.id)) die(`duplicate account id '${a.id}'`);
+      if (seenGateway.has(a.gatewayId))
+        die(`account '${a.id}' reuses the Gateway ID of another account`);
+      seenId.add(a.id);
+      seenGateway.add(a.gatewayId);
+    }
+  },
+});
+
+export interface Account {
+  cfg: AccountConfig;
+  keys: KeyPair;
+  publicKeys: Map<string, Uint8Array>;
+}
+
+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() };
+}
+
+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; to: string } {
+  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,
+  );
+  return { acct: accountFor(id), to: normalizeThreemaId(parsed.resource) };
+}
+
+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;
+}