@stage-labs/metro 0.1.0-beta.194 → 0.1.0-beta.195

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.194",
+  "version": "0.1.0-beta.195",
   "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.194",
+  "version": "0.1.0-beta.195",
   "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/daemon/src/agents/account-lookups.ts

@@ -0,0 +1,55 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { StationName } from '@metro-labs/core/station-names';
+import { ApiError } from '@metro-labs/http/api-error';
+import { bodyField, readJsonBody, sendJson } from '@metro-labs/http/api-http';
+import { stationByName } from '../stations/registry.js';
+import type { AccountRoute } from './account-routes.js';
+import { handleSenderCards, type SenderCardDeps } from './sender-cards.js';
+
+interface Target {
+  station: StationName;
+  accountId: string;
+}
+
+export interface LookupDeps extends SenderCardDeps {
+  resolveSender: (station: StationName, accountId: string, query: string) => Promise<unknown>;
+}
+
+type Lookup = (req: IncomingMessage, res: ServerResponse, deps: LookupDeps, target: Target) => Promise<void>;
+
+function lookupQuery(req: IncomingMessage): string {
+  const params = new URLSearchParams((req.url ?? '').split('?')[1] ?? '');
+  return (params.get('q') ?? '').trim();
+}
+
+async function handleResolve(req: IncomingMessage, res: ServerResponse, deps: LookupDeps, target: Target): 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);
+  sendJson(req, res, 200, await deps.resolveSender(target.station, target.accountId, query));
+}
+
+async function handleName(req: IncomingMessage, res: ServerResponse, deps: LookupDeps, target: Target): Promise<void> {
+  if (stationByName(target.station)?.claimsName !== true)
+    throw new ApiError(`${target.station} accounts have no name to claim`, 400);
+  if (req.method === 'GET') {
+    sendJson(req, res, 200, await deps.accountCall(target.station, 'name', { account: target.accountId }));
+    return;
+  }
+  const label = bodyField(await readJsonBody(req), 'label');
+  if (typeof label !== 'string' || label.trim() === '') throw new ApiError('a label is required', 400);
+  sendJson(req, res, 200, await deps.accountCall(target.station, 'claim_name', { account: target.accountId, label }));
+}
+
+function handleRecent(req: IncomingMessage, res: ServerResponse, deps: LookupDeps, target: Target): Promise<void> {
+  sendJson(req, res, 200, { senders: deps.recentSenders(target.station, target.accountId) });
+  return Promise.resolve();
+}
+
+export const LOOKUPS: Partial<Record<AccountRoute['kind'], Lookup>> = {
+  profiles: handleSenderCards,
+  resolve: handleResolve,
+  name: handleName,
+  senders: handleRecent,
+};

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

@@ -12,6 +12,7 @@ export type AccountRoute =
   | { kind: 'resolve'; station: StationName; accountId: string }
   | { kind: 'enabled'; station: StationName; accountId: string }
   | { kind: 'policy'; station: StationName; accountId: string }
+  | { kind: 'profiles'; station: StationName; accountId: string }
   | { kind: 'name'; station: StationName; accountId: string };
 
 const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
@@ -24,10 +25,11 @@ const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
   resolve: ['GET'],
   enabled: ['PUT'],
   policy: ['PUT'],
+  profiles: ['GET'],
   name: ['GET', 'POST'],
 };
 
-const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled', 'name', 'policy'] as const;
+const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled', 'name', 'policy', 'profiles'] as const;
 
 type SubRoute = (typeof SUB_ROUTES)[number];
 

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

@@ -5,15 +5,11 @@ import { approversForAccount } from './map.js';
 import { isRecord } from '@metro-labs/core/is-record';
 import type { RecentSender } from './senders.js';
 import { ApiError } from '@metro-labs/http/api-error';
-import {
-  apiFailure,
-  bodyField,
-  readJsonBody,
-  sendJson,
-} from '@metro-labs/http/api-http';
+import { apiFailure, bodyField, readJsonBody, sendJson } from '@metro-labs/http/api-http';
 import { type AccountRef } from './account-attach.js';
 import { type AccountRoute } from './account-routes.js';
 import { handlePolicy, type SetPolicy } from './policy-route.js';
+import { LOOKUPS } from './account-lookups.js';
 import { stationByName } from '../stations/registry.js';
 import type { StationName } from '@metro-labs/core/station-names';
 import {
@@ -92,46 +88,7 @@ export interface AccountApiDeps {
   ) => Promise<boolean>;
 }
 
-export const ATTACHABLE: string[] = [
-  ...ATTACHABLE_STATIONS,
-  ...INTERACTIVE_STATIONS,
-];
-
-function lookupQuery(req: IncomingMessage): string {
-  const params = new URLSearchParams((req.url ?? '').split('?')[1] ?? '');
-  return (params.get('q') ?? '').trim();
-}
-
-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 handleName(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AccountApiDeps,
-  target: { station: StationName; accountId: string },
-): Promise<void> {
-  if (stationByName(target.station)?.claimsName !== true)
-    throw new ApiError(`${target.station} accounts have no name to claim`, 400);
-  if (req.method === 'GET') {
-    sendJson(req, res, 200, await deps.accountCall(target.station, 'name', { account: target.accountId }));
-    return;
-  }
-  const label = bodyField(await readJsonBody(req), 'label');
-  if (typeof label !== 'string' || label.trim() === '') throw new ApiError('a label is required', 400);
-  sendJson(req, res, 200, await deps.accountCall(target.station, 'claim_name', { account: target.accountId, label }));
-}
+export const ATTACHABLE: string[] = [...ATTACHABLE_STATIONS, ...INTERACTIVE_STATIONS];
 
 async function activate(
   deps: AccountApiDeps,
@@ -353,6 +310,18 @@ async function handleStep(
   sendJson(req, res, 200, view);
 }
 
+async function dispatchAttach(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AccountApiDeps,
+  agentId: string,
+  route: Extract<AccountRoute, { kind: 'start' | 'session' | 'step' }>,
+): Promise<void> {
+  if (route.kind === 'start') return handleStart(req, res, deps, agentId);
+  if (route.kind === 'session') return handleSession(req, res, deps, { agentId }, route.attachId);
+  return handleStep(req, res, deps, { agentId }, route.attachId);
+}
+
 async function dispatchRoute(
   req: IncomingMessage,
   res: ServerResponse,
@@ -360,27 +329,12 @@ async function dispatchRoute(
   agentId: string,
   route: AccountRoute,
 ): Promise<void> {
-  if (route.kind === 'start')
-    return handleStart(req, res, deps, agentId);
-  if (route.kind === 'session')
-    return handleSession(
-      req,
-      res,
-      deps,
-      { agentId },
-      route.attachId,
-    );
-  if (route.kind === 'step')
-    return handleStep(req, res, deps, { agentId }, route.attachId);
+  if (route.kind === 'start' || route.kind === 'session' || route.kind === 'step') return dispatchAttach(req, res, deps, agentId, route);
   if (route.kind === 'allowlist') return handleAllowlist(req, res, deps, agentId, route);
   if (route.kind === 'enabled') return handleEnabled(req, res, deps, agentId, route);
   if (route.kind === 'policy') return handlePolicy(req, res, deps, agentId, route);
-  if (route.kind === 'resolve') return handleResolve(req, res, deps, route);
-  if (route.kind === 'name') return handleName(req, res, deps, route);
-  if (route.kind === 'senders') {
-    sendJson(req, res, 200, { senders: deps.recentSenders(route.station, route.accountId) });
-    return;
-  }
+  const lookup = LOOKUPS[route.kind];
+  if (lookup !== undefined && 'station' in route) return lookup(req, res, deps, route);
   return handleDetach(req, res, deps, agentId, route);
 }
 

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

@@ -0,0 +1,74 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { StationName } from '@metro-labs/core/station-names';
+import { errMsg, log } from '@metro-labs/core/log';
+import { sendJson } from '@metro-labs/http/api-http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { stationByName } from '../stations/registry.js';
+import { allowlistForAccount } from './map.js';
+import type { RecentSender } from './senders.js';
+
+export interface SenderCard {
+  id: string;
+  name?: string;
+  handle?: string;
+}
+
+export interface SenderCardDeps {
+  recentSenders: (station: StationName, accountId: string) => RecentSender[];
+  accountCall: (station: StationName, action: string, args: Record<string, unknown>) => Promise<unknown>;
+}
+
+const MAX_LOOKUPS = 50;
+const LOOKUP_MS = 8_000;
+
+const filled = (value: unknown): string | undefined => (typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined);
+
+function cardOf(id: string, profile: unknown, seenName: string | undefined): SenderCard {
+  const p = isRecord(profile) ? profile : {};
+  const display = filled(p.display_name);
+  const handle = filled(p.name);
+  const name = display ?? seenName ?? handle;
+  return {
+    id,
+    ...(name === undefined ? {} : { name }),
+    ...(handle === undefined || handle === name ? {} : { handle }),
+  };
+}
+
+async function lookup(deps: SenderCardDeps, station: StationName, accountId: string, user: string): Promise<unknown> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const late = new Promise<null>((resolve) => {
+    timer = setTimeout(() => {
+      resolve(null);
+    }, LOOKUP_MS);
+  });
+  try {
+    return await Promise.race([deps.accountCall(station, 'profile', { account: accountId, user }), late]);
+  } catch (err) {
+    log.info({ station, account: accountId, err: errMsg(err) }, 'account-api: could not read the profile of a listed sender');
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function senderCards(deps: SenderCardDeps, station: StationName, accountId: string): Promise<SenderCard[]> {
+  const ids = (allowlistForAccount(station, accountId) ?? []).filter((id) => id !== '*' && !id.startsWith('@'));
+  const seen = new Map(deps.recentSenders(station, accountId).map((s) => [s.id.toLowerCase(), filled(s.name)]));
+  const reads = stationByName(station)?.readsProfiles === true;
+  return Promise.all(
+    ids.map(async (id, at) => {
+      const profile = reads && at < MAX_LOOKUPS ? await lookup(deps, station, accountId, id) : null;
+      return cardOf(id, profile, seen.get(id.toLowerCase()));
+    }),
+  );
+}
+
+export async function handleSenderCards(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: SenderCardDeps,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  sendJson(req, res, 200, { senders: await senderCards(deps, target.station, target.accountId) });
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.194"
+  "version": "0.1.0-beta.195"
 }