@stage-labs/metro 0.1.0-beta.115 → 0.1.0-beta.116

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.115",
+  "version": "0.1.0-beta.116",
   "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.115",
+  "version": "0.1.0-beta.116",
   "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, the standing rules loaded at each session start, and a refresh skill for when the daemon could not keep the server list current. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

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

@@ -97,6 +97,7 @@ export interface Station {
   hasTrain: boolean;
   messageVerbs: ReadonlySet<Verb>;
   groupOps?: ReadonlySet<GroupOp>;
+  resolvesSenders?: boolean;
   attachmentMode: AttachmentMode;
   sendAttachments?(
     line: string,

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

@@ -0,0 +1,70 @@
+import { isStationName, parseAccountId } from './account-attach.js';
+import type { StationName } from '@metro-labs/core/station-names';
+import { ATTACH_ID_RE } from '../stations/attach-session.js';
+
+export type AccountRoute =
+  | { kind: 'start' }
+  | { kind: 'session'; attachId: string }
+  | { kind: 'step'; attachId: string }
+  | { kind: 'account'; station: StationName; accountId: string }
+  | { kind: 'allowlist'; station: StationName; accountId: string }
+  | { kind: 'senders'; station: StationName; accountId: string }
+  | { kind: 'resolve'; station: StationName; accountId: string }
+  | { kind: 'enabled'; station: StationName; accountId: string };
+
+const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
+  start: ['POST'],
+  session: ['GET', 'DELETE'],
+  step: ['POST'],
+  account: ['DELETE'],
+  allowlist: ['PUT'],
+  senders: ['GET'],
+  resolve: ['GET'],
+  enabled: ['PUT'],
+};
+
+const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled'] as const;
+
+type SubRoute = (typeof SUB_ROUTES)[number];
+
+const isSubRoute = (value: string | undefined): value is SubRoute =>
+  SUB_ROUTES.some((sub) => sub === value);
+
+function twoSegmentRoute(head: string, tail: string): AccountRoute | null {
+  if (ATTACH_ID_RE.test(head))
+    return tail === 'step' ? { kind: 'step', attachId: head } : null;
+  if (!isStationName(head)) return null;
+  const accountId = parseAccountId(tail);
+  return accountId === null ? null : { kind: 'account', station: head, accountId };
+}
+
+function accountSubRoute(
+  head: string,
+  tail: string,
+  sub: string | undefined,
+): AccountRoute | null {
+  if (!isStationName(head) || !isSubRoute(sub)) return null;
+  const accountId = parseAccountId(tail);
+  return accountId === null ? null : { kind: sub, station: head, accountId };
+}
+
+export function accountRoute(rest: string[]): AccountRoute | null {
+  const [head, tail] = rest;
+  if (head === undefined) return null;
+  if (rest.length === 1)
+    return head === 'start'
+      ? { kind: 'start' }
+      : ATTACH_ID_RE.test(head)
+        ? { kind: 'session', attachId: head }
+        : null;
+  if (rest.length === 3 && tail !== undefined) return accountSubRoute(head, tail, rest[2]);
+  if (rest.length !== 2 || tail === undefined) return null;
+  return twoSegmentRoute(head, tail);
+}
+
+export function accountRouteAllows(
+  route: AccountRoute,
+  method: string | undefined,
+): boolean {
+  return ROUTE_METHODS[route.kind].includes(method ?? '');
+}

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

@@ -10,11 +10,9 @@ import {
   sendJson,
   type ApiSession,
 } from '@metro-labs/http/api-http';
-import {
-  isStationName,
-  parseAccountId,
-  type AccountRef,
-} from './account-attach.js';
+import { type AccountRef } from './account-attach.js';
+import { type AccountRoute } from './account-routes.js';
+import { stationByName } from '../stations/registry.js';
 import type { StationName } from '@metro-labs/core/station-names';
 import {
   ATTACHABLE_STATIONS,
@@ -30,7 +28,6 @@ import {
   type InteractiveStation,
 } from '../stations/attach-interactive.js';
 import {
-  ATTACH_ID_RE,
   type AttachOwner,
   type AttachView,
 } from '../stations/attach-session.js';
@@ -75,6 +72,11 @@ export interface AccountApiDeps {
     allowlist: string[],
   ) => Promise<string[]>;
   recentSenders: (station: StationName, accountId: string) => RecentSender[];
+  resolveSender: (
+    station: StationName,
+    accountId: string,
+    query: string,
+  ) => Promise<unknown>;
   setAccountEnabled: (
     subject: string,
     agentId: string,
@@ -84,63 +86,28 @@ export interface AccountApiDeps {
   ) => Promise<boolean>;
 }
 
-export type AccountRoute =
-  | { kind: 'start' }
-  | { kind: 'session'; attachId: string }
-  | { kind: 'step'; attachId: string }
-  | { kind: 'account'; station: StationName; accountId: string }
-  | { kind: 'allowlist'; station: StationName; accountId: string }
-  | { kind: 'senders'; station: StationName; accountId: string }
-  | { kind: 'enabled'; station: StationName; accountId: string };
-
 export const ATTACHABLE: string[] = [
   ...ATTACHABLE_STATIONS,
   ...INTERACTIVE_STATIONS,
 ];
 
-const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
-  start: ['POST'],
-  session: ['GET', 'DELETE'],
-  step: ['POST'],
-  account: ['DELETE'],
-  allowlist: ['PUT'],
-  senders: ['GET'],
-  enabled: ['PUT'],
-};
-
-function twoSegmentRoute(head: string, tail: string): AccountRoute | null {
-  if (ATTACH_ID_RE.test(head))
-    return tail === 'step' ? { kind: 'step', attachId: head } : null;
-  if (!isStationName(head)) return null;
-  const accountId = parseAccountId(tail);
-  return accountId === null ? null : { kind: 'account', station: head, accountId };
-}
-
-export function accountRoute(rest: string[]): AccountRoute | null {
-  const [head, tail] = rest;
-  if (head === undefined) return null;
-  if (rest.length === 1)
-    return head === 'start'
-      ? { kind: 'start' }
-      : ATTACH_ID_RE.test(head)
-        ? { kind: 'session', attachId: head }
-        : null;
-  if (rest.length === 3 && tail !== undefined) return accountSubRoute(head, tail, rest[2]);
-  if (rest.length !== 2 || tail === undefined) return null;
-  return twoSegmentRoute(head, tail);
+function lookupQuery(req: IncomingMessage): string {
+  const params = new URLSearchParams((req.url ?? '').split('?')[1] ?? '');
+  return (params.get('q') ?? '').trim();
 }
 
-function accountSubRoute(head: string, tail: string, sub: string | undefined): AccountRoute | 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 };
-}
-
-export function accountRouteAllows(
-  route: AccountRoute,
-  method: string | undefined,
-): boolean {
-  return ROUTE_METHODS[route.kind].includes(method ?? '');
+async function handleResolve(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AccountApiDeps,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  if (stationByName(target.station)?.resolvesSenders !== true)
+    throw new ApiError(`metro cannot look a sender up on ${target.station}`, 400);
+  const query = lookupQuery(req);
+  if (query === '') throw new ApiError('a number to look up is required', 400);
+  const found = await deps.resolveSender(target.station, target.accountId, query);
+  sendJson(req, res, 200, found);
 }
 
 async function activate(
@@ -374,6 +341,7 @@ async function dispatchRoute(
     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 === 'resolve') return handleResolve(req, res, deps, 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/api.ts

@@ -11,14 +11,12 @@ import {
   sendJson,
   type ApiSession,
 } from '@metro-labs/http/api-http';
+import { ATTACHABLE, handleAccountRoute, type AccountApiDeps } from './accounts-api.js';
 import {
   accountRoute,
   accountRouteAllows,
-  ATTACHABLE,
-  handleAccountRoute,
-  type AccountApiDeps,
   type AccountRoute,
-} from './accounts-api.js';
+} from './account-routes.js';
 import {
   type AgentSummary,
   type CreatedAgent,

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

@@ -2,6 +2,7 @@ import { ApiError } from '@metro-labs/http/api-error';
 import { errMsg, log } from '@metro-labs/core/log';
 import { AttachSessions } from '../stations/attach-session.js';
 import { recentSenders } from '../agents/senders.js';
+import { forwardTrainCall } from '../stations/train-call.js';
 import { syncPluginServers } from '../connectors/plugin-sync.js';
 import type { AgentApiDeps } from '../agents/api.js';
 import { ATTACHABLE, type AccountApiDeps } from '../agents/accounts-api.js';
@@ -106,6 +107,7 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
     setAllowlist: localSetAllowlist,
     setAccountEnabled: localSetAccountEnabled,
     recentSenders,
+    resolveSender,
     reloadAgents: deps.reloadAgents,
   };
 }
@@ -179,6 +181,27 @@ function localModeInfo(): ModeInfo {
   return { mode: 'local', owner: localOwner(), project: LOCAL_PROJECT_ID, version: METRO_VERSION };
 }
 
+async function resolveSender(
+  station: StationName,
+  accountId: string,
+  query: string,
+): Promise<unknown> {
+  let response;
+  try {
+    response = await forwardTrainCall(station, 'resolve_sender', {
+      account: accountId,
+      query,
+    });
+  } catch (err) {
+    throw new ApiError(
+      `metro could not reach the ${station} train: ${errMsg(err)}`,
+      503,
+    );
+  }
+  if (response.error !== undefined) throw new ApiError(response.error, 400);
+  return response.result;
+}
+
 export function localSessionApis(deps: LocalModeDeps): SessionApis {
   allowLocalConnectors(true);
   return {

package/runtime/node_modules/@metro-labs/whatsapp/src/actions.ts

@@ -9,6 +9,7 @@ import {
 } from '@metro-labs/core/stations/station-runtime';
 import { accountFor, accounts, targetOf } from './accounts.js';
 import { normalizeWhatsApp } from './normalize.js';
+import { phoneNumberOf, senderLookup } from './resolve.js';
 import type { WAClient } from './client.js';
 
 type Args = Record<string, unknown>;
@@ -162,6 +163,16 @@ function makeAccounts(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeResolveSender(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const query = str(args.query) ?? '';
+    const number = phoneNumberOf(query);
+    const found = await guard(() => clientFor(accountId).lookupSender(number));
+    respond(id, { result: { account: accountId, ...senderLookup(query, number, found) } });
+  };
+}
+
 export function makeHandleCall(
   clientFor: ClientFor,
 ): (msg: CallMsg) => Promise<void> {
@@ -172,6 +183,7 @@ export function makeHandleCall(
       react: makeReact(clientFor),
       edit: makeEdit(clientFor),
       delete: makeDelete(clientFor),
+      resolve_sender: makeResolveSender(clientFor),
     },
     normalize: normalizeWhatsApp,
   });

package/runtime/node_modules/@metro-labs/whatsapp/src/client.ts

@@ -12,6 +12,7 @@ import { TrainError } from '@metro-labs/core/train-error';
 import { errMsg } from '@metro-labs/core/log';
 import type { WhatsAppAccount } from './types.js';
 import type { InboundMessage, ReactionInput } from './format.js';
+import type { SenderFound } from './resolve.js';
 import { toInbound, toReaction, type ReactionEvent, type SelfRef } from './parse.js';
 import { baileysLogger } from './logger.js';
 import { useAccountAuthState } from './auth-state.js';
@@ -49,6 +50,7 @@ export interface WAClient {
   editMessage(jid: string, messageId: string, text: string): Promise<void>;
   deleteMessage(jid: string, messageId: string): Promise<void>;
   reuploadMedia(m: WAMessage): Promise<WAMessage>;
+  lookupSender(number: string): Promise<SenderFound>;
   disconnect(): Promise<void>;
 }
 
@@ -200,6 +202,17 @@ async function connect(st: State): Promise<void> {
   bindDelivery(st, sock);
 }
 
+async function lidFor(st: State, sock: WASocket, jid: string): Promise<string | null> {
+  try {
+    return await sock.signalRepository.lidMapping.getLIDForPN(jid);
+  } catch (e) {
+    process.stderr.write(
+      `whatsapp[${st.account.id}] no lid on file for ${jid}: ${errMsg(e)}\n`,
+    );
+    return null;
+  }
+}
+
 async function ready(st: State): Promise<WASocket> {
   await st.openPromise;
   if (!st.sock) throw new TrainError('whatsapp_call', 'socket not connected');
@@ -315,6 +328,13 @@ export function createClient(account: WhatsAppAccount): WAClient {
       const sock = await ready(st);
       return sock.updateMediaMessage(m);
     },
+    async lookupSender(number) {
+      const sock = await ready(st);
+      const found = (await sock.onWhatsApp(number))?.[0];
+      if (found?.exists !== true) return { exists: false, jid: null, lid: null };
+      const jid = jidNormalizedUser(found.jid);
+      return { exists: true, jid, lid: await lidFor(st, sock, jid) };
+    },
     async disconnect() {
       st.closed = true;
       try {

package/runtime/node_modules/@metro-labs/whatsapp/src/resolve.ts

@@ -0,0 +1,52 @@
+import { TrainError } from '@metro-labs/core/train-error';
+
+const INTERNATIONAL = /^[1-9]\d{5,17}$/;
+
+export interface SenderFound {
+  exists: boolean;
+  jid: string | null;
+  lid: string | null;
+}
+
+export interface SenderLookup extends SenderFound {
+  query: string;
+  number: string;
+  id: string | null;
+}
+
+function refuse(query: string, why: string): never {
+  throw new TrainError('bad_request', `'${query}' ${why}`);
+}
+
+function international(query: string, digits: string): string {
+  if (digits.startsWith('00')) return digits.slice(2);
+  if (digits.startsWith('0'))
+    refuse(
+      query,
+      'is a national number, so metro cannot tell which country it is in; write it in full international form, as in 41791234567 for a Swiss 079 123 45 67',
+    );
+  return digits;
+}
+
+export function phoneNumberOf(raw: string): string {
+  const query = raw.trim();
+  if (query.toLowerCase().endsWith('@lid'))
+    refuse(query, 'is already a sender id, so add it directly instead of looking it up');
+  const local = query.split('@')[0] ?? '';
+  const digits = local.replace(/\D/g, '');
+  const number = local.startsWith('+') ? digits : international(query, digits);
+  if (!INTERNATIONAL.test(number))
+    refuse(query, 'is not a phone number metro can look up; write it in full international form, as in 41791234567');
+  return number;
+}
+
+export function senderLookup(query: string, number: string, found: SenderFound): SenderLookup {
+  return {
+    query: query.trim(),
+    number,
+    exists: found.exists,
+    jid: found.jid,
+    lid: found.lid,
+    id: found.lid ?? found.jid,
+  };
+}

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

@@ -13,5 +13,6 @@ export const whatsappStation: Station = {
     'delete',
   ]),
   attachmentMode: 'canonical',
+  resolvesSenders: true,
   tools: [],
 };

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.115"
+  "version": "0.1.0-beta.116"
 }