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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.97",
+  "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.97",
+  "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,
@@ -74,6 +75,13 @@ export interface AccountApiDeps {
     allowlist: string[],
   ) => Promise<string[]>;
   recentSenders: (station: StationName, accountId: string) => RecentSender[];
+  setAccountEnabled: (
+    subject: string,
+    agentId: string,
+    station: StationName,
+    accountId: string,
+    enabled: boolean,
+  ) => Promise<boolean>;
 }
 
 export type AccountRoute =
@@ -82,7 +90,8 @@ export type AccountRoute =
   | { kind: 'step'; attachId: string }
   | { kind: 'account'; station: StationName; accountId: string }
   | { kind: 'allowlist'; station: StationName; accountId: string }
-  | { kind: 'senders'; station: StationName; accountId: string };
+  | { kind: 'senders'; station: StationName; accountId: string }
+  | { kind: 'enabled'; station: StationName; accountId: string };
 
 export const ATTACHABLE: string[] = [
   ...ATTACHABLE_STATIONS,
@@ -96,6 +105,7 @@ const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
   account: ['DELETE'],
   allowlist: ['PUT'],
   senders: ['GET'],
+  enabled: ['PUT'],
 };
 
 function twoSegmentRoute(head: string, tail: string): AccountRoute | null {
@@ -121,7 +131,7 @@ export function accountRoute(rest: string[]): AccountRoute | null {
 }
 
 function accountSubRoute(head: string, tail: string, sub: string | undefined): AccountRoute | null {
-  if (!isStationName(head) || (sub !== 'allowlist' && sub !== 'senders')) return null;
+  if (!isStationName(head) || (sub !== 'allowlist' && sub !== 'senders' && sub !== 'enabled')) return null;
   const accountId = parseAccountId(tail);
   return accountId === null ? null : { kind: sub, station: head, accountId };
 }
@@ -210,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 },
@@ -294,6 +301,27 @@ async function handleAllowlist(
   });
 }
 
+async function handleEnabled(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AccountApiDeps,
+  session: ApiSession,
+  agentId: string,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  const wanted = bodyField(await readJsonBody(req), 'enabled');
+  if (typeof wanted !== 'boolean') throw new ApiError('enabled must be true or false', 400);
+  const enabled = await deps.setAccountEnabled(session.subject, agentId, target.station, target.accountId, wanted);
+  log.info({ agentId, station: target.station, account: target.accountId, enabled }, 'account-api: account enabled flag set');
+  sendJson(req, res, 200, {
+    agentId,
+    station: target.station,
+    accountId: target.accountId,
+    enabled,
+    activated: await activate(deps, target.station),
+  });
+}
+
 async function handleSession(
   req: IncomingMessage,
   res: ServerResponse,
@@ -345,6 +373,7 @@ async function dispatchRoute(
   if (route.kind === 'step')
     return handleStep(req, res, deps, ownerOf(session, agentId), route.attachId);
   if (route.kind === 'allowlist') return handleAllowlist(req, res, deps, session, agentId, route);
+  if (route.kind === 'enabled') return handleEnabled(req, res, deps, session, agentId, route);
   if (route.kind === 'senders') {
     sendJson(req, res, 200, { senders: deps.recentSenders(route.station, route.accountId) });
     return;

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

@@ -47,7 +47,7 @@ function stationOf(raw: unknown): LoadedAccount {
   const allowlist = Array.isArray(raw.allowlist)
     ? raw.allowlist.filter((s): s is string => typeof s === 'string')
     : null;
-  return { station: raw.station as LoadedAccount['station'], id: raw.id, allowlist, config: raw.config };
+  return { station: raw.station as LoadedAccount['station'], id: raw.id, allowlist, enabled: raw.enabled !== false, config: raw.config };
 }
 
 function connectorOf(raw: unknown): LoadedConnector {

package/runtime/node_modules/@metro-labs/daemon/src/agents/file-admin.ts

@@ -305,7 +305,7 @@ export async function localAttachAccount(
   if (typeof token === 'string') assertTokenFree(storedAgents(dir), station, token);
   const taken = new Set(stored.file.stations.map((a) => a.id));
   const accountId = freshId(taken);
-  stored.file.stations.push({ station, id: accountId, allowlist: ['*'], config });
+  stored.file.stations.push({ station, id: accountId, allowlist: ['*'], enabled: true, config });
   save(stored);
   return Promise.resolve({ agentId, station, accountId });
 }
@@ -326,6 +326,22 @@ export async function localSetAllowlist(
   return Promise.resolve(allowlist);
 }
 
+export async function localSetAccountEnabled(
+  subject: string,
+  agentId: string,
+  station: StationName,
+  accountId: string,
+  enabled: boolean,
+  dir = agentsDir(),
+): Promise<boolean> {
+  const stored = ownedOrThrow(subject, agentId, dir);
+  const account = stored.file.stations.find((a) => a.station === station && a.id === accountId);
+  if (account === undefined) throw new AgentAdminError('no such account on this agent', 404);
+  account.enabled = enabled;
+  save(stored);
+  return Promise.resolve(enabled);
+}
+
 export async function localDetachAccount(
   subject: string,
   agentId: string,

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

@@ -56,7 +56,7 @@ function stationOf(raw: unknown, path: string, index: number): LoadedAccount {
   if (typeof id !== 'string' || !ID_RE.test(id))
     fail(path, `${where}.id is not an 11-character id`);
   if (!isRecord(config)) fail(path, `${where}.config is not an object`);
-  return { station, id, allowlist: allowlistOf(raw.allowlist, path, where), config };
+  return { station, id, allowlist: allowlistOf(raw.allowlist, path, where), enabled: raw.enabled !== false, config };
 }
 
 function optionalMatch(

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

@@ -8,6 +8,7 @@ const mapKey = (station: string, accountId: string): string =>
 let agentMap: AgentMap = {};
 let agentNames: AgentNameMap = {};
 let allowlistMap: AllowlistMap = {};
+let disabledAccounts = new Set<string>();
 
 export function setAgentMap(map: AgentMap, names: AgentNameMap): void {
   agentMap = map;
@@ -18,6 +19,12 @@ export function setAllowlistMap(map: AllowlistMap): void {
   allowlistMap = map;
 }
 
+export function setDisabledAccounts(ids: Set<string>): void {
+  disabledAccounts = ids;
+}
+
+export const accountEnabled = (station: string, accountId: string): boolean => !disabledAccounts.has(mapKey(station, accountId));
+
 export function accountFromLine(
   line: string,
 ): { station: string; accountId: string } | undefined {

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

@@ -4,8 +4,8 @@ import {
   stationByName,
 } from '../stations/registry.js';
 import { listEndpoints } from '../net/tunnel.js';
-import { hookUrl } from '../stations/attach.js';
-import { agentIdForAccount, allowlistForAccount, knownAccounts, type KnownAccount } from '../agents/map.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 => {
   const id = (acc as { id?: unknown }).id;
@@ -25,7 +25,8 @@ function withAgentId(station: string, acc: unknown): unknown {
   const agentId = agentIdForAccount(station, id);
   if (agentId === undefined) return acc;
   const allowlist = allowlistForAccount(station, id);
-  return allowlist === undefined ? { ...rec, agentId } : { ...rec, agentId, allowlist };
+  const tagged = allowlist === undefined ? { ...rec, agentId } : { ...rec, agentId, allowlist };
+  return accountEnabled(station, id) ? tagged : { ...tagged, enabled: false };
 }
 
 export function attachAgentIds(
@@ -71,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[];
@@ -84,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/local-mode.ts

@@ -36,6 +36,7 @@ import {
   localDeleteAgent,
   localDetachAccount,
   localSetAllowlist,
+  localSetAccountEnabled,
   localImportAgent,
   localListAgents,
   localOwnedAgentOrThrow,
@@ -103,6 +104,7 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
     detachAccount: localDetachAccount,
     syncStations: deps.syncStations,
     setAllowlist: localSetAllowlist,
+    setAccountEnabled: localSetAccountEnabled,
     recentSenders,
     reloadAgents: deps.reloadAgents,
   };

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

@@ -13,6 +13,7 @@ import { trainsDir } from '../boot/paths.js';
 import {
   setAgentMap,
   setAllowlistMap,
+  setDisabledAccounts,
   type AgentMap,
   type AgentNameMap,
   type AllowlistMap,
@@ -30,6 +31,7 @@ export interface LoadedAccount {
   station: StationName;
   id: string;
   allowlist: string[] | null;
+  enabled?: boolean;
   config: Record<string, unknown>;
 }
 
@@ -77,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',
@@ -84,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);
 }
@@ -126,6 +133,7 @@ function writeStations(list: LoadedAgent[]): WrittenStations {
   const map: AgentMap = {};
   const names: AgentNameMap = {};
   const allow: AllowlistMap = {};
+  const disabled = new Set<string>();
   for (const agent of list) {
     names[agent.id] = agent.name;
     for (const a of agent.accounts) {
@@ -138,6 +146,10 @@ function writeStations(list: LoadedAgent[]): WrittenStations {
       }
       map[`${a.station}/${a.id}`] = agent.id;
       if (a.allowlist) allow[`${a.station}/${a.id}`] = a.allowlist;
+      if (a.enabled === false) {
+        disabled.add(`${a.station}/${a.id}`);
+        continue;
+      }
       const cur = byStation.get(a.station);
       if (cur) cur.push(a);
       else byStation.set(a.station, [a]);
@@ -145,6 +157,7 @@ function writeStations(list: LoadedAgent[]): WrittenStations {
   }
   setAgentMap(map, names);
   setAllowlistMap(allow);
+  setDisabledAccounts(disabled);
 
   const active = new Map<StationName, number>();
   const changed: StationName[] = [];

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,
 ];