@stage-labs/metro 0.1.0-beta.157 → 0.1.0-beta.158

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.157",
+  "version": "0.1.0-beta.158",
   "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.157",
+  "version": "0.1.0-beta.158",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

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

@@ -17,8 +17,8 @@ async function call(
 ): Promise<Response> {
   try {
     return await fetch(`${GATEWAY_API}${path}`, {
-      ...init,
       signal: AbortSignal.timeout(TIMEOUT_MS),
+      ...init,
     });
   } catch (err) {
     throw new TrainError(
@@ -130,3 +130,23 @@ export async function sendE2E(
     );
   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());
+}

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

@@ -90,3 +90,11 @@ export function unquote(text: string): { replyTo?: string; text: string } {
   const body = m?.[2];
   return replyTo === undefined || body === undefined ? { text } : { replyTo, text: body };
 }
+
+const FILE_NONCE = new Uint8Array([...new Array<number>(23).fill(0), 1]);
+
+export const newBlobKey = (): Uint8Array => nacl.randomBytes(nacl.secretbox.keyLength);
+
+export const sealBlob = (data: Uint8Array, key: Uint8Array): Uint8Array => nacl.secretbox(data, FILE_NONCE, key);
+
+export const openBlob = (data: Uint8Array, key: Uint8Array): Uint8Array | null => nacl.secretbox.open(data, FILE_NONCE, key);

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

@@ -0,0 +1,93 @@
+import { readFile } from 'node:fs/promises';
+import { emit, mintId } from '@metro-labs/core/stations/station-runtime';
+import { assertAttachmentSize, isImageMime, kindOf, saveBufferToCache } from '@metro-labs/core/stations/attachments';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { Account } from './accounts.js';
+import { downloadBlob, uploadBlob } from './api.js';
+import { bytesToHex, hexToBytes, newBlobKey, openBlob, sealBlob } from './crypto.js';
+import { emitInbound, textEnvelope, type InboundMeta, type Room } from './format.js';
+import { encodeFile, encodeGroupFile, type FileData, type GroupRef } from './messages.js';
+
+export const MAX_BLOB_BYTES = 50 * 1024 * 1024;
+const SELF_URI = process.env.METRO_SELF_URI ?? '';
+
+export interface OutgoingFile {
+  path: string;
+  mime: string;
+  name: string;
+}
+
+export async function packFile(acct: Account, file: OutgoingFile, caption: string | null): Promise<FileData> {
+  const data = await readFile(file.path);
+  assertAttachmentSize(data.length);
+  if (data.length > MAX_BLOB_BYTES) throw new TrainError('threema_file_too_big', `Threema carries files up to 50 MB; ${file.name} is bigger`, { retryable: false });
+  const key = newBlobKey();
+  const blobId = await uploadBlob(acct.cfg, sealBlob(new Uint8Array(data), key));
+  return { blobId, key: bytesToHex(key), mime: file.mime, name: file.name, size: data.length, caption, media: isImageMime(file.mime) };
+}
+
+export const encodeFileFor = (group: GroupRef | null, file: FileData): Uint8Array => (group === null ? encodeFile(file) : encodeGroupFile(group, file));
+
+export const fileLabel = (file: OutgoingFile): string => kindOf(file.mime, file.path);
+
+function savedEnvelope(accountId: string, line: string, forId: string, file: FileData, path: string, bytes: number): Record<string, unknown> {
+  return {
+    kind: 'inbound',
+    id: mintId(),
+    ts: new Date().toISOString(),
+    station: 'threema',
+    line,
+    from: SELF_URI,
+    text: `📎 saved: ${path}`,
+    payload: {
+      account: accountId,
+      contentType: 'attachmentSaved',
+      attachmentFor: forId,
+      index: 0,
+      kind: kindOf(file.mime, file.name),
+      attachmentPath: path,
+      localPath: path,
+      mime: file.mime,
+      name: file.name,
+      size: bytes,
+    },
+  };
+}
+
+function failedEnvelope(accountId: string, line: string, forId: string, file: FileData, reason: string): Record<string, unknown> {
+  return {
+    kind: 'inbound',
+    id: mintId(),
+    ts: new Date().toISOString(),
+    station: 'threema',
+    line,
+    from: SELF_URI,
+    text: `📎 not fetched: ${reason}`,
+    payload: { account: accountId, contentType: 'attachmentFailed', attachmentFor: forId, index: 0, kind: kindOf(file.mime, file.name), reason },
+  };
+}
+
+async function fetchFile(acct: Account, m: InboundMeta, file: FileData): Promise<{ path: string; bytes: number }> {
+  const sealed = await downloadBlob(acct.cfg, file.blobId);
+  const plain = openBlob(sealed, hexToBytes(file.key, 'blob key'));
+  if (plain === null) throw new TrainError('threema_bad_blob', 'the file did not decrypt with the key in the message', { retryable: false });
+  const saved = await saveBufferToCache(plain, m.messageId, 0, { mime: file.mime, name: file.name });
+  return { path: saved.path, bytes: saved.bytes };
+}
+
+export function deliverFile(acct: Account, m: InboundMeta, file: FileData, room: Room, sentByUs: (id: string) => boolean): void {
+  const env = textEnvelope(acct.cfg.id, m, file.caption ?? '', sentByUs, room);
+  const line = String(env.line);
+  const forId = String(env.id);
+  const payload = { ...(env.payload as Record<string, unknown>), attachments: [{ kind: kindOf(file.mime, file.name), name: file.name, mime: file.mime, ...(file.size === null ? {} : { size: file.size }) }] };
+  emitInbound(acct.cfg.id, acct.cfg.owner, { ...env, payload });
+  fetchFile(acct, m, file)
+    .then(({ path, bytes }) => {
+      emit(savedEnvelope(acct.cfg.id, line, forId, file, path, bytes));
+    })
+    .catch((err: unknown) => {
+      const reason = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`threema[${acct.cfg.id}]: could not fetch ${file.name} from ${m.from}: ${reason}\n`);
+      emit(failedEnvelope(acct.cfg.id, line, forId, file, reason));
+    });
+}

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

@@ -8,6 +8,7 @@ import {
   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';
 
@@ -54,10 +55,8 @@ function control(acct: Account, m: InboundMeta, d: Decoded): string | null {
   return null;
 }
 
-export function deliver(acct: Account, m: InboundMeta, d: Decoded): string {
+function chat(acct: Account, m: InboundMeta, d: Decoded): string | null {
   const owner = acct.cfg.owner;
-  const handled = control(acct, m, d);
-  if (handled !== null) return handled;
   if (d.kind === 'text') {
     emitInbound(acct.cfg.id, owner, textEnvelope(acct.cfg.id, m, d.text, sentByUs));
     return 'text';
@@ -67,11 +66,22 @@ export function deliver(acct: Account, m: InboundMeta, d: Decoded): string {
     emitInbound(acct.cfg.id, owner, 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, owner, 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;

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

@@ -1,7 +1,9 @@
 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;
@@ -26,8 +28,19 @@ export interface GroupRef {
   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 }
@@ -74,6 +87,61 @@ export const encodeText = (text: string): Uint8Array => typed(MSG_TEXT, Buffer.f
 
 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 {
@@ -154,13 +222,18 @@ function decodeGroup(type: number, body: Uint8Array): Decoded {
   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_LEAVE, MSG_GROUP_DELIVERY_RECEIPT, MSG_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 };
@@ -171,6 +244,10 @@ function decodeControl(type: number, body: Uint8Array): Decoded {
 
 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);
@@ -180,7 +257,7 @@ function decodeDirect(type: number, body: Uint8Array): Decoded {
 export function decode(plain: Uint8Array): Decoded {
   const type = plain[0] ?? -1;
   const body = plain.subarray(1);
-  if (type === MSG_TEXT || type === MSG_TYPING || type === MSG_DELIVERY_RECEIPT || type === MSG_REACTION) return decodeDirect(type, body);
+  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

@@ -3,6 +3,7 @@ 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 {
@@ -67,15 +68,34 @@ interface SendArgs {
   text?: unknown;
   replyTo?: unknown;
   account?: string;
+  attachments?: unknown;
 }
 
-function requireText(a: SendArgs): string {
+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 === '')
-    throw new TrainError('threema_text_required', 'threema carries text only; give some text to send', { retryable: false });
+  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))
@@ -83,18 +103,40 @@ function messageIdOf(raw: unknown, field: string): string {
   return id;
 }
 
-export async function send(id: string, args: Args): Promise<void> {
-  const a = args as unknown as SendArgs;
-  const text = requireText(a);
-  const replyTo = a.replyTo === undefined || a.replyTo === null || a.replyTo === '' ? undefined : messageIdOf(a.replyTo, 'replyTo');
-  const { acct, target } = targetOf(a.line, a.account);
+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 });
-  const ids = await fanOut(acct, target, encodeText(body), (g) => encodeGroupText(g, body));
-  const messageId = ids[0] ?? '';
-  emitOutbound(acct.cfg.id, a.line, messageId, text, replyTo);
-  respond(id, { result: { messageId, account: acct.cfg.id, ...(ids.length > 1 ? { messageIds: ids } : {}) } });
+  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 {

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

@@ -5,6 +5,6 @@ export const threemaStation: Station = {
   hasAccounts: true,
   hasTrain: true,
   messageVerbs: new Set<Verb>(['send', 'reply', 'react', 'unreact']),
-  attachmentMode: 'none',
+  attachmentMode: 'canonical',
   tools: [],
 };

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.157"
+  "version": "0.1.0-beta.158"
 }