@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.300

package/runtime/node_modules/@metro-labs/xmtp/src/tools.ts

@@ -0,0 +1,235 @@
+import type { StationTool } from '@metro-labs/core/stations/types';
+import { PRIORITIES } from './labels.js';
+import {
+  str,
+  setChannelMetadata,
+  xmtpSendAttachments,
+} from './tools-handlers.js';
+
+export { xmtpSendAttachments };
+
+const lineProp = {
+  type: 'string',
+  description:
+    'The metro:// line (from the inbound <channel> tag). The station is derived from it.',
+} as const;
+
+export const XMTP_TOOLS: StationTool[] = [
+  {
+    name: 'ask',
+    group: 'write',
+    description:
+      'Ask a question as a poll in an XMTP conversation (mirrors Claude AskUserQuestion). ' +
+      'Single-question form: question (required), options? (string[]), header?, multiSelect?, ' +
+      'open? (true => free-text answer, options optional). Multi-question form: questions ' +
+      '(array of {question, options?, header?, multiSelect?, open?}). Args: line (required) + ' +
+      'the above. xmtp-only (the daemon `ask` action). Returns the poll messageId + pollId.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: lineProp,
+        question: {
+          type: 'string',
+          description: 'The question text (single-question form).',
+        },
+        options: {
+          type: 'array',
+          description: 'Answer options for a single question.',
+          items: { type: 'string' },
+        },
+        header: {
+          type: 'string',
+          description: 'Optional header/title for the poll.',
+        },
+        multiSelect: {
+          type: 'boolean',
+          description: 'Allow selecting multiple options.',
+        },
+        open: {
+          type: 'boolean',
+          description: 'Free-text answer (options optional).',
+        },
+        questions: {
+          type: 'array',
+          description:
+            'Multiple questions (multi-question form). Each is {question, options?, header?, multiSelect?, open?}.',
+          items: { type: 'object' },
+        },
+      },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('ask requires `line`');
+      const args: Record<string, unknown> = { line };
+      for (const k of [
+        'question',
+        'options',
+        'header',
+        'multiSelect',
+        'open',
+        'questions',
+      ] as const) {
+        if (a[k] !== undefined) args[k] = a[k];
+      }
+      if (a.question === undefined && a.questions === undefined) {
+        return ctx.err(
+          'ask requires `question` (single) or `questions` (multi)',
+        );
+      }
+      return ctx.okJson(await ctx.call('ask', args));
+    },
+  },
+  {
+    name: 'dm',
+    group: 'write',
+    description:
+      'Open (or reuse) a 1:1 XMTP DM with an Ethereum address. Args: address (required, 0x...), ' +
+      'account? (defaults to your only XMTP account). Returns the new metro:// line and ' +
+      'convId. xmtp-only ' +
+      '(daemon `newDm`). For a group, use create_group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        address: {
+          type: 'string',
+          description: 'Recipient Ethereum 0x address.',
+        },
+        account: {
+          type: 'string',
+          description: 'XMTP account to DM from. Omit when you have only one.',
+        },
+      },
+      required: ['address'],
+    },
+    async handle(a, ctx) {
+      const address = str(a.address);
+      if (!address) return ctx.err('dm requires `address`');
+      const dmArgs: Record<string, unknown> = { address };
+      if (a.account) dmArgs.account = str(a.account);
+      return ctx.okJson(await ctx.call('newDm', dmArgs));
+    },
+  },
+  {
+    name: 'group_info',
+    group: 'read',
+    description:
+      "Read an XMTP channel's current metadata + membership. Args: line (required). Returns " +
+      '{line, id, account, version (dm|group), name, memberCount, labels, category, status, priority, github, preview, ' +
+      'assigned, appData (stored JSON object), rawAppData (stored JSON string), ' +
+      'members:[{inboxId, address}]}. Syncs first and fails if metadata cannot be read. ' +
+      'xmtp-only (daemon `groupInfo`). Use before ' +
+      'set_channel_metadata/add_members to see current state.',
+    inputSchema: {
+      type: 'object',
+      properties: { line: lineProp },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('group_info requires `line`');
+      return ctx.okJson(await ctx.call('groupInfo', { line }));
+    },
+  },
+  {
+    name: 'close_channel',
+    group: 'write',
+    destructive: true,
+    description:
+      'Remove members from an XMTP group, and optionally leave it. Args: line (required), ' +
+      'removeInboxIds? (inbox ids to remove; your own is ignored here), removeSelf? (true to ' +
+      'leave the group yourself). With neither, nothing changes. xmtp-only (daemon ' +
+      '`closeGroup`). Returns {removed, leftSelf}.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: lineProp,
+        removeInboxIds: {
+          type: 'array',
+          description: 'Inbox ids of the members to remove.',
+          items: { type: 'string' },
+        },
+        removeSelf: {
+          type: 'boolean',
+          description: 'Leave the group after removing the others.',
+        },
+      },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('close_channel requires `line`');
+      const args: Record<string, unknown> = { line };
+      if (Array.isArray(a.removeInboxIds)) args.removeInboxIds = a.removeInboxIds.map(String);
+      if (a.removeSelf === true) args.removeSelf = true;
+      return ctx.okJson(await ctx.call('closeGroup', args));
+    },
+  },
+  {
+    name: 'set_channel_metadata',
+    group: 'write',
+    description:
+      "Update an existing channel's metadata. Args: line (required, the metro:// line), and " +
+      'any of metadata? (JSON object), github? (url), preview? (url), name? (string). ' +
+      'metadata is a shallow appData patch: omitted keys are preserved, supplied nested ' +
+      'values replace that key, and null deletes custom keys. v is reserved. Put labels, ' +
+      'assigned, category, status and priority inside metadata. assigned replaces the array with normalized lowercase ' +
+      'Ethereum addresses of current members. Read group_info and union existing IDs to ' +
+      'add assignees. category and status are each one free-form string per channel, trimmed, ' +
+      'whitespace collapsed and truncated to 24 characters. priority is trimmed and must be Urgent, High, Medium or Low. ' +
+      '"" or null clears category, status or priority. labels remains a legacy top-level alias. Duplicate top-level/metadata ' +
+      'label/link aliases are refused. All fields use one updateChannelMeta call. xmtp-only. ' +
+      'Returns updated metadata. Reread group_info to verify persistence.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: lineProp,
+        metadata: {
+          type: 'object',
+          description: 'Shallow JSON appData patch. Omitted keys stay unchanged. v is reserved.',
+          properties: {
+            labels: { type: 'array', items: { type: 'string' } },
+            assigned: {
+              type: 'array',
+              description: 'Replacement assignee list. Current member Ethereum addresses only. [] clears.',
+              items: { type: 'string', pattern: '^0x[0-9a-fA-F]{40}$' },
+            },
+            category: {
+              type: ['string', 'null'],
+              description: 'One free-form category, trimmed, whitespace collapsed, truncated to 24 characters. "" or null clears it.',
+            },
+            status: {
+              type: ['string', 'null'],
+              description: 'One free-form status, trimmed, whitespace collapsed, truncated to 24 characters. "" or null clears it.',
+            },
+            priority: {
+              type: ['string', 'null'],
+              enum: [...PRIORITIES, '', null],
+              description: 'One priority: Urgent, High, Medium or Low. Surrounding whitespace is trimmed; empty or null clears it.',
+            },
+            github: { type: 'string' },
+            preview: { type: 'string' },
+          },
+          additionalProperties: true,
+        },
+        labels: {
+          type: 'array',
+          description: 'Legacy alias. Prefer metadata.labels.',
+          items: { type: 'string' },
+        },
+        github: {
+          type: 'string',
+          description: 'Linked GitHub URL ("" to clear).',
+        },
+        preview: {
+          type: 'string',
+          description: 'Linked preview URL ("" to clear).',
+        },
+        name: { type: 'string', description: 'New channel name.' },
+      },
+      required: ['line'],
+    },
+    handle: (a, ctx) => setChannelMetadata(a, ctx),
+  },
+];
+

package/runtime/node_modules/@metro-labs/xmtp/src/transcribe.ts

@@ -0,0 +1,88 @@
+import { errMsg } from '@metro-labs/core/log';
+import { emitInbound, selfUri } from '@metro-labs/core/stations/train-events';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
+
+const WHISPER_BIN = process.env.METRO_WHISPER_BIN ?? 'whisper-cli';
+const WHISPER_MODEL =
+  process.env.METRO_WHISPER_MODEL ??
+  `${process.env.HOME}/.cache/whisper-cpp/ggml-base.bin`;
+const FFMPEG_BIN = process.env.METRO_FFMPEG_BIN ?? 'ffmpeg';
+
+export async function transcribeAndEmit(
+  audio: Uint8Array,
+  line: string,
+  accountId: string,
+  sourceMsgId: string,
+): Promise<void> {
+  const {
+    existsSync: ex,
+    readFileSync: rf,
+    writeFileSync: wf,
+    unlinkSync,
+    mkdtempSync,
+  } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const path = await import('node:path');
+  const j = (...parts: string[]): string => path.join(...parts);
+  const { spawn } = await import('node:child_process');
+  if (!ex(WHISPER_MODEL)) return;
+  const dir = mkdtempSync(j(tmpdir(), 'xmtp-tx-'));
+  const inFile = j(dir, 'in.m4a');
+  const wav = j(dir, 'in.wav');
+  const out = j(dir, 'in');
+  const run = (bin: string, args: string[]): Promise<void> =>
+    new Promise((res, rej) => {
+      const p = spawn(bin, args, { stdio: 'ignore' });
+      p.on('error', rej);
+      p.on('exit', (c) => {
+        if (c === 0) res();
+        else rej(new Error(`${bin} ${String(c)}`));
+      });
+    });
+  try {
+    wf(inFile, audio);
+    await run(FFMPEG_BIN, [
+      '-y',
+      '-i',
+      inFile,
+      '-ar',
+      '16000',
+      '-ac',
+      '1',
+      wav,
+    ]);
+    await run(WHISPER_BIN, [
+      '-m',
+      WHISPER_MODEL,
+      '-f',
+      wav,
+      '--output-txt',
+      '-of',
+      out,
+    ]);
+    const text = rf(`${out}.txt`, 'utf8').trim();
+    if (!text) return;
+    emitInbound(accountId, {
+      id: mintId(),
+      ts: new Date().toISOString(),
+      station: 'xmtp',
+      line,
+      from: selfUri(),
+      text: `🎙️ ${text}`,
+      payload: {
+        contentType: 'transcript',
+        transcribeFor: sourceMsgId,
+        transcript: text,
+      },
+    });
+  } catch (err) {
+    process.stderr.write(`xmtp transcribe failed: ${errMsg(err)}\n`);
+  } finally {
+    for (const f of [inFile, wav, `${out}.txt`]) {
+      try {
+        unlinkSync(f);
+      } catch {
+      }
+    }
+  }
+}

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

@@ -0,0 +1,98 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { Client, type ClientOptions, type Signer } from '@xmtp/node-sdk';
+import { expandHome, identityFor, signerFor, XMTP_ENV } from './identity.js';
+import { ensureDeployed } from './smart.js';
+
+export class XmtpVerifyError extends Error {}
+
+export interface XmtpVerified {
+  inboxId: string;
+  address: string;
+  installationId: string;
+  dbPath: string;
+  smart: boolean;
+}
+
+interface RegisteredClient {
+  inboxId: string;
+  installationId: string;
+  isRegistered: boolean;
+}
+
+export type CreateXmtpClient = (
+  signer: Signer,
+  dbPath: string,
+) => Promise<RegisteredClient>;
+
+const openInbox: CreateXmtpClient = (signer, dbPath) => {
+  const options: ClientOptions = { env: XMTP_ENV, dbPath };
+  return Client.create(signer, options);
+};
+
+const reason = (err: unknown): string =>
+  err instanceof Error && err.message !== '' ? err.message : 'no reason given';
+
+export async function verifyXmtpKey(
+  privateKey: string,
+  dbPath: string,
+  smart = false,
+  create: CreateXmtpClient = openInbox,
+): Promise<XmtpVerified> {
+  let identity: Awaited<ReturnType<typeof identityFor>>;
+  try {
+    signerFor(privateKey);
+  } catch {
+    throw new XmtpVerifyError('that is not a usable XMTP private key');
+  }
+  try {
+    identity = await identityFor(privateKey, smart);
+  } catch (err) {
+    throw new XmtpVerifyError(`could not build the smart account on Base: ${reason(err)}`);
+  }
+  const { signer, address } = identity;
+  if (identity.smart !== null)
+    await ensureDeployed(identity.smart).catch((err: unknown) => {
+      throw new XmtpVerifyError(`could not deploy the smart account on Base (is the ZeroDev sponsorship still on?): ${reason(err)}`);
+    });
+  const resolved = expandHome(dbPath);
+  mkdirSync(dirname(resolved), { recursive: true });
+  const client = await create(signer, resolved).catch((err: unknown) => {
+    throw new XmtpVerifyError(
+      `XMTP would not open an inbox for that key: ${reason(err)}`,
+    );
+  });
+  if (!client.isRegistered)
+    throw new XmtpVerifyError('XMTP did not register an inbox for that key');
+  if (client.inboxId === '')
+    throw new XmtpVerifyError('XMTP returned no inbox id for that key');
+  return {
+    inboxId: client.inboxId,
+    address,
+    installationId: client.installationId,
+    dbPath: resolved,
+    smart,
+  };
+}
+
+async function runCli(): Promise<void> {
+  let out: Record<string, unknown>;
+  try {
+    const input = JSON.parse(readFileSync(0, 'utf8')) as {
+      privateKey?: unknown;
+      dbPath?: unknown;
+      smart?: unknown;
+    };
+    if (typeof input.privateKey !== 'string' || typeof input.dbPath !== 'string')
+      throw new XmtpVerifyError('xmtp verify needs a privateKey and a dbPath');
+    out = { ok: true, ...(await verifyXmtpKey(input.privateKey, input.dbPath, input.smart === true)) };
+  } catch (err) {
+    out = { ok: false, error: reason(err) };
+  }
+  writeFileSync(1, `${JSON.stringify(out)}\n`);
+}
+
+if (import.meta.main) {
+  await runCli();
+  process.exit(0);
+}

package/runtime/node_modules/@metro-labs/xmtp/src/wallet.ts

@@ -0,0 +1,28 @@
+import type { EncodedContent } from '@xmtp/content-type-primitives';
+import {
+  SignatureReferenceCodec,
+  SignatureRequestCodec,
+  TransactionReferenceCodec,
+  WalletSendCallsCodec,
+} from './codecs.js';
+import { bad, isNode, parseJson } from './frames.js';
+
+const WALLET_TYPES: Record<string, { codec: { encode(c: Record<string, unknown>): EncodedContent }; needs: string[] }> = {
+  walletSendCalls: { codec: new WalletSendCallsCodec(), needs: ['version', 'chainId', 'from', 'calls'] },
+  transactionReference: { codec: new TransactionReferenceCodec(), needs: ['networkId', 'reference'] },
+  signatureRequest: { codec: new SignatureRequestCodec(), needs: ['id', 'kind'] },
+  signatureReference: { codec: new SignatureReferenceCodec(), needs: ['requestId', 'signature', 'signer'] },
+};
+
+export function buildWalletContent(raw: unknown): { encoded: EncodedContent; summary: string } {
+  const args = parseJson(raw, 'wallet');
+  const type = isNode(args) && typeof args.type === 'string' ? args.type : '';
+  const spec = Object.hasOwn(WALLET_TYPES, type) ? WALLET_TYPES[type] : undefined;
+  if (!isNode(args) || !spec) throw bad(`wallet type must be one of ${Object.keys(WALLET_TYPES).join(', ')}`);
+  const content = parseJson(args.content, 'wallet content');
+  if (!isNode(content)) throw bad(`wallet content must be the ${type} JSON object`);
+  const missing = spec.needs.filter((key) => content[key] === undefined);
+  if (missing.length > 0) throw bad(`${type} content needs ${missing.join(', ')}`);
+  const encoded = spec.codec.encode(content);
+  return { encoded, summary: encoded.fallback ?? type };
+}

package/runtime/node_modules/@metro-labs/xmtp/src/wire.ts

@@ -0,0 +1,49 @@
+const UID_MAP_MAX = 5000;
+const uidToXmtp = new Map<string, string>();
+
+const INBOX_ETH_CACHE_MAX = 5000;
+export const inboxEthCache = new Map<string, string>();
+
+export function cacheInboxEth(inboxId: string, eth: string): void {
+  inboxEthCache.set(inboxId, eth);
+  if (inboxEthCache.size > INBOX_ETH_CACHE_MAX) {
+    const oldest = inboxEthCache.keys().next().value;
+    if (oldest !== undefined) inboxEthCache.delete(oldest);
+  }
+}
+
+export function rememberUid(
+  uid: string | undefined,
+  xmtpId: string | undefined,
+): void {
+  if (!uid || !xmtpId || !uid.startsWith('msg_')) return;
+  uidToXmtp.set(uid, xmtpId);
+  if (uidToXmtp.size > UID_MAP_MAX) {
+    const oldest = uidToXmtp.keys().next().value;
+    if (oldest !== undefined) uidToXmtp.delete(oldest);
+  }
+}
+
+export function resolveMsgId(rawId: string): string {
+  if (!rawId.startsWith('msg_')) return rawId;
+  const mapped = uidToXmtp.get(rawId);
+  if (mapped) return mapped;
+  throw new Error(
+    `could not resolve universal id ${rawId} to an xmtp message id ` +
+      '(not seen by this train; pass the raw xmtp message_id)',
+  );
+}
+
+const SENT_MAX = 5000;
+const sentIds = new Set<string>();
+
+export function rememberSent(xmtpId: string | undefined): void {
+  if (!xmtpId) return;
+  sentIds.add(xmtpId);
+  if (sentIds.size > SENT_MAX) {
+    const oldest = sentIds.values().next().value;
+    if (oldest !== undefined) sentIds.delete(oldest);
+  }
+}
+
+export const sentByMe = (xmtpId: string): boolean => sentIds.has(xmtpId);

package/runtime/patches/5bca2c07d5852d3f58453cff0448dd85da13d3665b61e3d758905b298d432d7c.patch

@@ -0,0 +1,31 @@
+diff --git a/lib/Types/Events.d.ts b/lib/Types/Events.d.ts
+index f55c4c325b08b8c25dc9d17032514ce5c80ad3fd..930cb143e813b9a656533ae765f9db70f6eb7ccd 100644
+--- a/lib/Types/Events.d.ts
++++ b/lib/Types/Events.d.ts
+@@ -46,6 +46,10 @@ export type BaileysEventMap = {
+     'lid-mapping.update': LIDMapping;
+     /** delete chats with given ID */
+     'chats.delete': string[];
++    'chats.clear': {
++        id: string;
++        messageRange?: proto.SyncActionValue.ISyncActionMessageRange | null;
++    };
+     /** presence of contact in a chat updated */
+     'presence.update': {
+         id: string;
+diff --git a/lib/Utils/chat-utils.js b/lib/Utils/chat-utils.js
+index c30265d36671bacd25a8c456cafedcd9fc2fdd9a..2be37df069eda49c546eac1eb3485e649432dbeb 100644
+--- a/lib/Utils/chat-utils.js
++++ b/lib/Utils/chat-utils.js
+@@ -763,7 +763,11 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
+             }
+         ]);
+     }
++    else if (action?.clearChatAction || type === 'clearChat') {
++        ev.emit('chats.clear', { id, messageRange: action?.clearChatAction?.messageRange });
++    }
+     else if (action?.deleteChatAction || type === 'deleteChat') {
++        ev.emit('chats.clear', { id, messageRange: action?.deleteChatAction?.messageRange });
+         if (!isInitialSync) {
+             ev.emit('chats.delete', [id]);
+         }

package/runtime/runtime.json

@@ -0,0 +1,3 @@
+{
+  "version": "0.1.0-beta.300"
+}

package/runtime/sdk-runner/node_modules/@metro-labs/core/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@metro-labs/core",
+  "version": "0.1.0",
+  "private": true,
+  "description": "What every metro process shares: the logger, the event bus and its types, ids, secure file writes, the train protocol, station types and attachment handling. No HTTP, no policy.",
+  "type": "module",
+  "exports": {
+    "./log": "./src/log.ts",
+    "./connector-sync": "./src/connector-sync.ts",
+    "./events": "./src/events.ts",
+    "./is-record": "./src/is-record.ts",
+    "./runner-activity": "./src/runner-activity.ts",
+    "./automation-store": "./src/automation-store.ts",
+    "./automation-types": "./src/automation-types.ts",
+    "./call": "./src/call.ts",
+    "./secure-fs": "./src/secure-fs.ts",
+    "./skill-source": "./src/skill-source.ts",
+    "./version": "./src/version.ts",
+    "./train-error": "./src/train-error.ts",
+    "./trains/protocol": "./src/protocol.ts",
+    "./ids": "./src/ids.ts",
+    "./tickets": "./src/tickets.ts",
+    "./station-names": "./src/station-names.ts",
+    "./str": "./src/str.ts",
+    "./lines": "./src/lines.ts",
+    "./endpoints": "./src/endpoints.ts",
+    "./stations/types": "./src/stations/types.ts",
+    "./stations/channel-directory": "./src/stations/channel-directory.ts",
+    "./stations/channel-pages": "./src/stations/channel-pages.ts",
+    "./stations/account-files": "./src/stations/account-files.ts",
+    "./stations/station-runtime": "./src/stations/station-runtime.ts",
+    "./stations/account-store": "./src/stations/account-store.ts",
+    "./stations/attachments": "./src/stations/attachments.ts",
+    "./stations/mail": "./src/stations/mail.ts",
+    "./stations/mail-text": "./src/stations/mail-text.ts",
+    "./stations/mail-trust": "./src/stations/mail-trust.ts",
+    "./stations/oauth": "./src/stations/oauth.ts",
+    "./stations/messaging-normalize": "./src/stations/messaging-normalize.ts",
+    "./stations/profile": "./src/stations/profile.ts",
+    "./stations/sender-profile": "./src/stations/sender-profile.ts",
+    "./stations/train-events": "./src/stations/train-events.ts",
+    "./stations/train-boot": "./src/stations/train-boot.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && METRO_STATE_DIR=\"$(mktemp -d /tmp/metro-test.XXXXXX)\" bun test test/"
+  },
+  "dependencies": {
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.3",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}