@stage-labs/metro 0.1.0-beta.161 → 0.1.0-beta.163

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.161",
+  "version": "0.1.0-beta.163",
   "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.161",
+  "version": "0.1.0-beta.163",
   "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/core/package.json

@@ -24,7 +24,8 @@
     "./stations/account-store": "./src/stations/account-store.ts",
     "./stations/attachments": "./src/stations/attachments.ts",
     "./stations/messaging-normalize": "./src/stations/messaging-normalize.ts",
-    "./stations/profile": "./src/stations/profile.ts"
+    "./stations/profile": "./src/stations/profile.ts",
+    "./stations/sender-profile": "./src/stations/sender-profile.ts"
   },
   "scripts": {
     "build": "tsc",

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

@@ -0,0 +1,64 @@
+export interface SenderProfile {
+  id: string;
+  name?: string;
+  display_name?: string;
+  about?: string;
+  avatar?: string;
+  address?: string;
+}
+
+export interface ProfileCacheOptions {
+  ttlMs?: number;
+  max?: number;
+  onError: (key: string, err: unknown) => void;
+}
+
+export interface ProfileCache<T> {
+  get(key: string): Promise<T | null>;
+  peek(key: string): T | null;
+}
+
+const TTL_MS = 10 * 60_000;
+const MAX = 2000;
+
+interface Held<T> {
+  at: number;
+  value: Promise<T | null>;
+  settled: T | null;
+}
+
+export const nonEmpty = (v: unknown): string | undefined => (typeof v === 'string' && v.trim() !== '' ? v.trim() : undefined);
+
+export function makeProfileCache<T>(lookup: (key: string) => Promise<T | null>, opts: ProfileCacheOptions): ProfileCache<T> {
+  const ttl = opts.ttlMs ?? TTL_MS;
+  const max = opts.max ?? MAX;
+  const cache = new Map<string, Held<T>>();
+  const fresh = (key: string): Held<T> | undefined => {
+    const held = cache.get(key);
+    return held !== undefined && Date.now() - held.at < ttl ? held : undefined;
+  };
+  const start = (key: string): Held<T> => {
+    const held: Held<T> = { at: Date.now(), settled: null, value: Promise.resolve(null) };
+    held.value = lookup(key)
+      .then((value) => {
+        held.settled = value;
+        return value;
+      })
+      .catch((err: unknown) => {
+        opts.onError(key, err);
+        cache.delete(key);
+        return null;
+      });
+    cache.set(key, held);
+    while (cache.size > max) {
+      const oldest = cache.keys().next();
+      if (oldest.done) break;
+      cache.delete(oldest.value);
+    }
+    return held;
+  };
+  return {
+    get: (key) => (fresh(key) ?? start(key)).value,
+    peek: (key) => (fresh(key) ?? start(key)).settled,
+  };
+}

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

@@ -102,6 +102,7 @@ export interface Station {
   resolvesSenders?: boolean;
   profileFields?: ReadonlySet<ProfileField>;
   claimsName?: boolean;
+  readsProfiles?: boolean;
   attachmentMode: AttachmentMode;
   sendAttachments?(
     line: string,

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

@@ -0,0 +1,21 @@
+export const MCP_INSTRUCTIONS =
+  'Messages from Metro chat arrive as <channel source="metro" line="..." from="..." ' +
+  'station="..." message_id="...">. To respond, use the messaging tools, always passing the ' +
+  '`line` attribute verbatim (the station is derived from it): `send` (text and/or media via ' +
+  '`attachments`, optional `reply_to`), `reply` (quote a `message_id` with `text`), `react`/' +
+  '`unreact` (emoji on a `message_id`), `edit`/`delete` (a `message_id`), and `read` (recent ' +
+  "history). Station support varies - the tool returns the daemon's reason if a verb is " +
+  'unsupported on that line. An inbound attachment is surfaced as a note carrying the ' +
+  "sender's own text alongside a `Public URL` - fetch that url to read the file; the note's " +
+  '`local_path` resolves on the DAEMON host, not on yours, so the Read tool works on it only ' +
+  'for an agent running there. To send a file OUT, call `create_upload`, ' +
+  'run the one curl line it hands back (that step needs a shell; the bytes go from your disk ' +
+  'straight to metro and never through this conversation), then `send` with ' +
+  'attachments:[{upload:"<upload_id>"}]. Inline `data` is for tiny files only, `url` only for ' +
+  'an already-public file, and `path` is read on the DAEMON host, not yours. Tool-approval ' +
+  'prompts are relayed to the same chat - answer "yes <id>"/"no <id>". A message meant for you ' +
+  'carries addressed="direct" (a private chat), "mention" (you were named) or "reply" (it ' +
+  'answers one of your own messages); one without `addressed` merely happened in a room you ' +
+  'watch, so treat it as context and do not answer unless the person plainly wants you. The ' +
+  'meta names the sender (`from_name`, `from_display_name`) when the station knows them; ' +
+  '`get_profile` with the `from` tells you more about a person (name, bio, avatar, address).';

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

@@ -0,0 +1,58 @@
+import { Line } from '@metro-labs/core/lines';
+import type { Station, ToolResult } from '@metro-labs/core/stations/types';
+import { str } from '@metro-labs/core/str';
+import { stationByName } from '../stations/registry.js';
+import { errResult, makeCtx, okJson, toErr } from './ctx.js';
+
+export const GET_PROFILE_TOOL = {
+  name: 'get_profile',
+  description:
+    'Who is this person? Give the `from` attribute of one of their messages verbatim ' +
+    '(`metro://<station>/<account>/user/<id>`) and get what their network says about them: ' +
+    '{id, name, display_name, about, avatar, address}. XMTP answers the Basename ' +
+    '(<label>.stage.base.eth), its name, description and avatar records, and the wallet address; ' +
+    'WhatsApp the about line and the picture; Telegram the handle, the name and the bio; Discord ' +
+    'the username, the global name and the avatar. Fields the network does not have are absent. ' +
+    'The answer is cached for ten minutes, so ask when you want to know someone, not on every message.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      from: { type: 'string', description: 'The `from` of a message, exactly as received.' },
+    },
+    required: ['from'],
+  },
+};
+
+export interface ProfileTarget {
+  station: Station;
+  account: string;
+  user: string;
+}
+
+export function profileTarget(a: Record<string, unknown>): ProfileTarget | { refused: string } {
+  const from = str(a.from);
+  if (!from) return { refused: 'get_profile requires `from`' };
+  const parsed = Line.parse(from);
+  const at = parsed?.path.indexOf('user') ?? -1;
+  if (parsed === null || at < 0 || at + 1 >= parsed.path.length) return { refused: `${from} is not a person: expected metro://<station>/<account>/user/<id>` };
+  const station = stationByName(parsed.station);
+  if (!station) return { refused: `no station named ${parsed.station}` };
+  if (station.readsProfiles !== true) return { refused: `${station.name} has no profile metro can read` };
+  return { station, account: at === 0 ? 'default' : parsed.path.slice(0, at).join('/'), user: parsed.path.slice(at + 1).join('/') };
+}
+
+export const profileScopeLine = (a: Record<string, unknown>): string | undefined => {
+  const target = profileTarget(a);
+  return 'refused' in target ? undefined : `metro://${target.station.name}/${target.account}/user/${target.user}`;
+};
+
+export async function dispatchGetProfile(a: Record<string, unknown>): Promise<ToolResult> {
+  const target = profileTarget(a);
+  if ('refused' in target) return errResult(target.refused);
+  try {
+    const { result } = await makeCtx(target.station.name).call('profile', { account: target.account, user: target.user });
+    return okJson(result);
+  } catch (e) {
+    return toErr('get_profile', e);
+  }
+}

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

@@ -8,7 +8,7 @@ import {
   senderMatchesAllowlist,
 } from '../agents/map.js';
 import { accountStationNames } from '../stations/registry.js';
-import { MCP_INSTRUCTIONS } from './tool-schemas.js';
+import { MCP_INSTRUCTIONS } from './instructions.js';
 import { ChannelOwner } from './channel-owner.js';
 import { BoundedEventStore } from './event-store.js';
 import { registerPermissionRelay } from './permission-relay.js';

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

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { Line } from '@metro-labs/core/lines';
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import {
   ListToolsRequestSchema,
@@ -22,6 +23,7 @@ import {
 } from './group-tools.js';
 import { dispatchCreateUpload } from './upload-tool.js';
 import { dispatchSetProfile, profileCapabilities, SET_PROFILE_TOOL } from './profile-tool.js';
+import { dispatchGetProfile, GET_PROFILE_TOOL, profileScopeLine } from './profile-lookup.js';
 import { callTargetDenied, lineTargetDenied } from '../agents/scope.js';
 import { SOURCE_KEYS } from '../stations/attach-resolve.js';
 import { decodedLengthOf } from '../stations/attach-inline.js';
@@ -51,6 +53,7 @@ const CORE_DISPATCH: Record<
   export_invite: dispatchInviteLink,
   create_upload: dispatchCreateUpload,
   set_profile: dispatchSetProfile,
+  get_profile: dispatchGetProfile,
 };
 
 const toolList = (): { tools: unknown[] } => ({
@@ -65,6 +68,7 @@ const toolList = (): { tools: unknown[] } => ({
     ),
     LIST_ACCOUNTS_TOOL,
     SET_PROFILE_TOOL,
+    GET_PROFILE_TOOL,
   ],
 });
 
@@ -106,6 +110,10 @@ export function scopeDenied(
   args: Record<string, unknown>,
 ): boolean {
   const allowed = allowedAgents(identity);
+  if (name === 'get_profile') {
+    const line = profileScopeLine(args);
+    return line === undefined || callTargetDenied(allowed, Line.station(line) ?? '', { line });
+  }
   const station = stationForTool(name, args);
   if (station !== undefined) return callTargetDenied(allowed, station, args);
   return lineTargetDenied(allowed, args);

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

@@ -378,23 +378,3 @@ export const LIST_ACCOUNTS_TOOL = {
     'verb need not be discovered by trial and error.',
   inputSchema: { type: 'object', properties: {} },
 };
-
-export const MCP_INSTRUCTIONS =
-  'Messages from Metro chat arrive as <channel source="metro" line="..." from="..." ' +
-  'station="..." message_id="...">. To respond, use the messaging tools, always passing the ' +
-  '`line` attribute verbatim (the station is derived from it): `send` (text and/or media via ' +
-  '`attachments`, optional `reply_to`), `reply` (quote a `message_id` with `text`), `react`/' +
-  '`unreact` (emoji on a `message_id`), `edit`/`delete` (a `message_id`), and `read` (recent ' +
-  "history). Station support varies - the tool returns the daemon's reason if a verb is " +
-  'unsupported on that line. An inbound attachment is surfaced as a note carrying the ' +
-  "sender's own text alongside a `Public URL` - fetch that url to read the file; the note's " +
-  '`local_path` resolves on the DAEMON host, not on yours, so the Read tool works on it only ' +
-  'for an agent running there. To send a file OUT, call `create_upload`, ' +
-  'run the one curl line it hands back (that step needs a shell; the bytes go from your disk ' +
-  'straight to metro and never through this conversation), then `send` with ' +
-  'attachments:[{upload:"<upload_id>"}]. Inline `data` is for tiny files only, `url` only for ' +
-  'an already-public file, and `path` is read on the DAEMON host, not yours. Tool-approval ' +
-  'prompts are relayed to the same chat - answer "yes <id>"/"no <id>". A message meant for you ' +
-  'carries addressed="direct" (a private chat), "mention" (you were named) or "reply" (it ' +
-  'answers one of your own messages); one without `addressed` merely happened in a room you ' +
-  'watch, so treat it as context and do not answer unless the person plainly wants you.';

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

@@ -27,7 +27,7 @@ import {
 } from '@metro-labs/core/stations/station-runtime';
 import { joinVoice, leaveVoice, voiceDebug, voiceTranscribe } from './voice.js';
 import { speak } from './voice-speak.js';
-import { setProfile } from './profile.js';
+import { readProfile, setProfile } from './profile.js';
 import { discordMembers } from './members.js';
 import {
   groupAddHandler,
@@ -377,6 +377,7 @@ const HANDLERS: Record<string, StationHandler> = {
   listMembers,
   set_presence: presence,
   set_profile: setProfile,
+  profile: readProfile,
   joinVoice,
   leaveVoice,
   speak,

package/runtime/node_modules/@metro-labs/discord-bot/src/format.ts

@@ -74,6 +74,11 @@ function addressing(accountId: string, m: Message): { mentions_self: boolean; re
   };
 }
 
+const senderOf = (m: Message): Record<string, string | undefined> => ({
+  from_name: m.author.username,
+  from_display_name: m.member?.displayName ?? m.author.globalName ?? undefined,
+});
+
 export function messageEnvelope(
   accountId: string,
   m: Message,
@@ -115,8 +120,7 @@ export function messageEnvelope(
     line,
     line_name: 'name' in m.channel ? m.channel.name : undefined,
     from: `metro://discord-bot/${accountId}/user/${m.author.id}`,
-    from_name: m.author.username,
-    from_display_name: m.author.globalName ?? undefined,
+    ...senderOf(m),
     message_id: m.id,
     text,
     is_private: m.guildId == null,

package/runtime/node_modules/@metro-labs/discord-bot/src/profile.ts

@@ -8,6 +8,7 @@ import {
   type ProfileApplied,
   type ProfileChange,
 } from '@metro-labs/core/stations/profile';
+import type { SenderProfile } from '@metro-labs/core/stations/sender-profile';
 import { accountFor, accounts } from './accounts.js';
 import { respond } from './wire.js';
 
@@ -46,3 +47,22 @@ export async function setProfile(
   const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
   respond(id, { result });
 }
+
+export async function readProfile(id: string, args: Record<string, unknown>): Promise<void> {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const acct = accounts.get(accountId);
+  if (!acct) {
+    respond(id, { error: `unknown account '${accountId}'` });
+    return;
+  }
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  if (!/^\d+$/.test(user)) throw new TrainError('discord_user_required', 'profile needs the Discord id of the person', { retryable: false });
+  const found = await acct.client.users.fetch(user);
+  const result: SenderProfile = {
+    id: user,
+    name: found.username,
+    ...(found.globalName === null ? {} : { display_name: found.globalName }),
+    avatar: found.displayAvatarURL({ size: 256 }),
+  };
+  respond(id, { result });
+}

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

@@ -17,5 +17,6 @@ export const discordBotStation: Station = {
   groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   tools: [],
 };

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

@@ -14,7 +14,7 @@ import {
   type CanonicalAttachment,
 } from './media-actions.js';
 import { clampLimit, shapeHistory } from './history.js';
-import { makeSetProfile } from './profile.js';
+import { makeReadProfile, makeSetProfile } from './profile.js';
 import { fetchMembers, isRestricted, restrictedMemberList } from './members.js';
 import {
   groupAddMembers,
@@ -250,6 +250,7 @@ export function makeHandleCall(
       groupRemoveMembers: makeGroupRemove(clientFor),
       groupInviteLink: makeGroupInvite(clientFor),
       set_profile: makeSetProfile(clientFor),
+      profile: makeReadProfile(clientFor),
     },
     normalize: normalizeTelegramUser,
   });

package/runtime/node_modules/@metro-labs/telegram/src/format.ts

@@ -13,8 +13,9 @@ export function senderName(peer: Peer): string | undefined {
 }
 
 export function displayName(peer: Peer): string | undefined {
-  if (isUser(peer)) return peer.firstName;
-  return peer.title;
+  if (!isUser(peer)) return peer.title;
+  const name = [peer.firstName, peer.lastName].filter((part) => typeof part === 'string' && part !== '').join(' ');
+  return name === '' ? undefined : name;
 }
 
 function chatName(peer: Peer): string | undefined {

package/runtime/node_modules/@metro-labs/telegram/src/profile.ts

@@ -8,6 +8,8 @@ import {
 } from '@metro-labs/core/stations/profile';
 import { respond, type StationHandler } from '@metro-labs/core/stations/station-runtime';
 import { str } from '@metro-labs/core/str';
+import { makeProfileCache, nonEmpty, type ProfileCache, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { TrainError } from '@metro-labs/core/train-error';
 import { accountFor } from './accounts.js';
 import type { UserClient } from './client.js';
 
@@ -34,3 +36,35 @@ export function makeSetProfile(clientFor: (accountId: string) => UserClient): St
     respond(id, { result });
   };
 }
+
+const senders = new Map<string, ProfileCache<SenderProfile>>();
+
+function sendersOf(client: UserClient): ProfileCache<SenderProfile> {
+  const held = senders.get(client.account.id);
+  if (held !== undefined) return held;
+  const made = makeProfileCache<SenderProfile>(
+    async (user) => {
+      const full = await client.tg.getFullUser(Number(user));
+      const handle = nonEmpty(full.username);
+      const display = nonEmpty([full.firstName, full.lastName].filter((part) => typeof part === 'string').join(' '));
+      return {
+        id: user,
+        ...(handle === undefined ? {} : { name: `@${handle}` }),
+        ...(display === undefined ? {} : { display_name: display }),
+        ...(nonEmpty(full.bio) === undefined ? {} : { about: nonEmpty(full.bio) }),
+      };
+    },
+    { onError: (user, err) => process.stderr.write(`telegram[${client.account.id}] could not read the profile of ${user}: ${err instanceof Error ? err.message : String(err)}\n`) },
+  );
+  senders.set(client.account.id, made);
+  return made;
+}
+
+export function makeReadProfile(clientFor: (accountId: string) => UserClient): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const user = str(args.user) ?? '';
+    if (!/^\d+$/.test(user)) throw new TrainError('telegram_user_required', 'profile needs the numeric Telegram id of the person', { retryable: false });
+    respond(id, { result: (await sendersOf(clientFor(accountId)).get(user)) ?? { id: user } });
+  };
+}

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

@@ -22,5 +22,6 @@ export const telegramStation: Station = {
   ]),
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   tools: [],
 };

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

@@ -23,7 +23,7 @@ import {
   sendLocation,
   sendMedia,
 } from './media-actions.js';
-import { setProfile } from './profile.js';
+import { readProfile, setProfile } from './profile.js';
 
 
 
@@ -273,6 +273,7 @@ const HANDLERS: Record<string, StationHandler> = {
   delete: remove,
   listMembers,
   set_profile: setProfile,
+  profile: readProfile,
   send_photo: (id, args) =>
     media(id, 'sendPhoto', 'photo', ((args.caption as string) ?? '') + ' [image]', args),
   send_document: (id, args) =>

package/runtime/node_modules/@metro-labs/telegram-bot/src/format.ts

@@ -2,7 +2,7 @@ import { errMsg } from '@metro-labs/core/log';
 import { accounts, lineOf } from './accounts.js';
 import { mintId, SELF_URI } from './wire.js';
 import { mediaRefOf, saveTelegramMedia } from './attachments.js';
-import type { TgMsg, TgReaction, TgReactionCount } from './types.js';
+import type { TgMsg, TgReaction, TgReactionCount, TgUser } from './types.js';
 
 export type { TgMsg, TgReaction, TgReactionCount };
 
@@ -72,6 +72,11 @@ function addressing(accountId: string, m: TgMsg): Record<string, unknown> {
   };
 }
 
+export const fullName = (u: TgUser | undefined): string | undefined => {
+  const name = [u?.first_name, u?.last_name].filter((part) => typeof part === 'string' && part !== '').join(' ');
+  return name === '' ? undefined : name;
+};
+
 export function envelope(accountId: string, m: TgMsg): Record<string, unknown> {
   const { line } = lineForMsg(accountId, m);
   return {
@@ -83,7 +88,7 @@ export function envelope(accountId: string, m: TgMsg): Record<string, unknown> {
     line_name: m.chat.title ?? m.chat.first_name ?? undefined,
     from: `metro://telegram-bot/${accountId}/user/${m.from?.id ?? 'unknown'}`,
     from_name: m.from?.username ? `@${m.from.username}` : m.from?.first_name,
-    from_display_name: m.from?.first_name,
+    from_display_name: fullName(m.from),
     message_id: String(m.message_id),
     text: projectText(m),
     payload: m,
@@ -113,7 +118,7 @@ export function reactionEnvelope(
     line: lineOf(accountId, r.chat.id),
     from: `metro://telegram-bot/${accountId}/user/${r.user?.id ?? 'unknown'}`,
     from_name: r.user?.username ? `@${r.user.username}` : r.user?.first_name,
-    from_display_name: r.user?.first_name,
+    from_display_name: fullName(r.user),
     message_id: String(r.message_id),
     emoji: added[0],
     event: { type: 'react', emoji: added[0], targetId: String(r.message_id) },

package/runtime/node_modules/@metro-labs/telegram-bot/src/profile.ts

@@ -7,6 +7,8 @@ import {
   type ProfileAvatar,
   type ProfileChange,
 } from '@metro-labs/core/stations/profile';
+import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { TrainError } from '@metro-labs/core/train-error';
 import { accountFor, tg, tgForm } from './accounts.js';
 import { respond } from './wire.js';
 
@@ -31,3 +33,33 @@ export async function setProfile(id: string, args: Record<string, unknown>): Pro
   const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
   respond(id, { result });
 }
+
+interface TgChat {
+  username?: unknown;
+  first_name?: unknown;
+  last_name?: unknown;
+  bio?: unknown;
+}
+
+const senders = makeProfileCache<SenderProfile>(
+  async (key) => {
+    const [accountId, user] = key.split(':', 2) as [string, string];
+    const chat = await tg<TgChat>(accountId, 'getChat', { chat_id: Number(user) }, 10_000);
+    const handle = nonEmpty(chat.username);
+    const display = nonEmpty([chat.first_name, chat.last_name].filter((part) => typeof part === 'string').join(' '));
+    return {
+      id: user,
+      ...(handle === undefined ? {} : { name: `@${handle}` }),
+      ...(display === undefined ? {} : { display_name: display }),
+      ...(nonEmpty(chat.bio) === undefined ? {} : { about: nonEmpty(chat.bio) }),
+    };
+  },
+  { onError: (key, err) => process.stderr.write(`telegram-bot: could not read the profile of ${key}: ${err instanceof Error ? err.message : String(err)}\n`) },
+);
+
+export async function readProfile(id: string, args: Record<string, unknown>): Promise<void> {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  if (!/^\d+$/.test(user)) throw new TrainError('telegram_user_required', 'profile needs the numeric Telegram id of the person', { retryable: false });
+  respond(id, { result: (await senders.get(`${accountId}:${user}`)) ?? { id: user } });
+}

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

@@ -15,5 +15,6 @@ export const telegramBotStation: Station = {
   ]),
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   tools: [],
 };

package/runtime/node_modules/@metro-labs/telegram-bot/src/types.ts

@@ -5,6 +5,14 @@ export interface TgEntity {
   user?: { id: number };
 }
 
+export interface TgUser {
+  id: number;
+  username?: string;
+  first_name?: string;
+  last_name?: string;
+  is_bot?: boolean;
+}
+
 export interface TgMsg {
   entities?: TgEntity[];
   caption_entities?: TgEntity[];
@@ -12,12 +20,7 @@ export interface TgMsg {
   message_id: number;
   date: number;
   chat: { id: number; type: string; title?: string; first_name?: string };
-  from?: {
-    id: number;
-    username?: string;
-    first_name?: string;
-    is_bot?: boolean;
-  };
+  from?: TgUser;
   text?: string;
   caption?: string;
   message_thread_id?: number;
@@ -36,12 +39,7 @@ export interface TgMsg {
 export interface TgReaction {
   chat: { id: number; type: string };
   message_id: number;
-  user?: {
-    id: number;
-    username?: string;
-    first_name?: string;
-    is_bot?: boolean;
-  };
+  user?: TgUser;
   date: number;
   old_reaction: { type: string; emoji?: string }[];
   new_reaction: { type: string; emoji?: string }[];

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

@@ -185,6 +185,16 @@ function makeSetProfile(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeProfile(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const user = str(args.user) ?? '';
+    if (user === '') throw new TrainError('whatsapp_user_required', 'profile needs the jid of the person', { retryable: false });
+    const profile = await guard(() => clientFor(accountId).senderProfile(user));
+    respond(id, { result: profile ?? { id: user } });
+  };
+}
+
 export function makeHandleCall(
   clientFor: ClientFor,
 ): (msg: CallMsg) => Promise<void> {
@@ -197,6 +207,7 @@ export function makeHandleCall(
       delete: makeDelete(clientFor),
       resolve_sender: makeResolveSender(clientFor),
       set_profile: makeSetProfile(clientFor),
+      profile: makeProfile(clientFor),
     },
     normalize: normalizeWhatsApp,
   });

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

@@ -14,6 +14,7 @@ import type { WhatsAppAccount } from './types.js';
 import type { InboundMessage, ReactionInput } from './format.js';
 import type { SenderFound } from './resolve.js';
 import type { ProfileChange } from '@metro-labs/core/stations/profile';
+import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
 import { toInbound, toReaction, type ReactionEvent, type SelfRef } from './parse.js';
 import { baileysLogger } from './logger.js';
 import { useAccountAuthState } from './auth-state.js';
@@ -53,6 +54,7 @@ export interface WAClient {
   reuploadMedia(m: WAMessage): Promise<WAMessage>;
   lookupSender(number: string): Promise<SenderFound>;
   setProfile(change: ProfileChange): Promise<void>;
+  senderProfile(jid: string): Promise<SenderProfile | null>;
   disconnect(): Promise<void>;
 }
 
@@ -278,6 +280,16 @@ export function createClient(account: WhatsAppAccount): WAClient {
     acks: makeAckWatch(),
   };
   resetGate(st);
+  const senders = makeProfileCache<SenderProfile>(
+    async (jid) => {
+      const sock = await ready(st);
+      const [statuses, avatar] = await Promise.all([sock.fetchStatus(jid).catch(() => undefined), sock.profilePictureUrl(jid, 'image').catch(() => undefined)]);
+      const about = nonEmpty((statuses?.[0]?.status as { status?: unknown } | undefined)?.status);
+      const picture = nonEmpty(avatar);
+      return { id: jid, ...(about === undefined ? {} : { about }), ...(picture === undefined ? {} : { avatar: picture }) };
+    },
+    { onError: (jid, err) => process.stderr.write(`whatsapp[${st.account.id}] could not read the profile of ${jid}: ${errMsg(err)}\n`) },
+  );
   return {
     account,
     self() {
@@ -347,6 +359,7 @@ export function createClient(account: WhatsAppAccount): WAClient {
         await sock.updateProfilePicture(me, { url: change.avatar.path });
       }
     },
+    senderProfile: (jid) => senders.get(jid),
     async disconnect() {
       st.closed = true;
       try {

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

@@ -15,6 +15,7 @@ export const whatsappStation: Station = {
   ]),
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   resolvesSenders: true,
   tools: [],
 };

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

@@ -22,6 +22,7 @@ import { convHandlers } from './actions-conv.js';
 import { normalizeXmtp } from '@metro-labs/core/stations/messaging-normalize';
 import { TrainError } from '@metro-labs/core/train-error';
 import { claimNameAction, nameAction, setProfile } from './profile.js';
+import { profileAction } from './sender.js';
 import { makeStation, type CallMsg } from '@metro-labs/core/stations/station-runtime';
 
 type Args = Record<string, unknown>;
@@ -358,6 +359,7 @@ const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
   set_profile: setProfile,
   claim_name: claimNameAction,
   name: nameAction,
+  profile: profileAction,
   send,
   ask,
   sendPoll: ask,

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

@@ -39,7 +39,7 @@ export async function createGroupWithMembers(
   return created;
 }
 
-async function resolveAddresses(
+export async function resolveAddresses(
   acct: Account,
   inboxIds: string[],
 ): Promise<Record<string, string>> {

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

@@ -8,6 +8,7 @@ import {
 } from './accounts.js';
 import { emitInbound, envelope } from './emit.js';
 import { groupNameFor } from './conv-helpers.js';
+import { senderFieldsNow } from './sender.js';
 import { handleControlDm, pushInbound } from './push.js';
 import { readCalls } from '@metro-labs/core/trains/protocol';
 import { handleCall } from './actions.js';
@@ -65,6 +66,7 @@ async function handleStreamMessage(
   );
   if (!conv) return;
   const env = envelope(id, msg, conv);
+  Object.assign(env, senderFieldsNow(acct, msg.senderInboxId));
   const name = await groupNameFor(msg.conversationId, conv);
   if (name) {
     env.line_name = name;

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

@@ -23,7 +23,7 @@ const STAMP_CLEAR_URL = 'https://stamp.fyi/clear/';
 const ZERO = '0x0000000000000000000000000000000000000000';
 const TEXT_KEYS = { name: 'name', bio: 'description', avatar: 'avatar' } as const;
 
-const REGISTRY_ABI = [
+export const REGISTRY_ABI = [
   { name: 'resolver', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'address' }] },
 ] as const;
 
@@ -42,7 +42,7 @@ const REVERSE_ABI = [
   { name: 'setName', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'name', type: 'string' }], outputs: [{ name: '', type: 'bytes32' }] },
 ] as const;
 
-const NAME_ABI = [
+export const NAME_ABI = [
   { name: 'name', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'string' }] },
 ] as const;
 

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

@@ -0,0 +1,108 @@
+import { namehash, type Hex } from 'viem';
+import { normalize } from 'viem/ens';
+import { makeProfileCache, type SenderProfile as Profile } from '@metro-labs/core/stations/sender-profile';
+import { respond } from './wire.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountForCall, accounts, type Account } from './accounts.js';
+import { resolveAddresses } from './conv-helpers.js';
+import { nameOf } from './names.js';
+import { BASENAME_L2_RESOLVER, BASENAME_REGISTRY, NAME_ABI, REGISTRY_ABI, reverseNodeOf } from './profile.js';
+import { makePublicClient, type BaseClient } from './smart.js';
+
+export interface SenderProfile {
+  address: string;
+  name: string | null;
+  displayName: string | null;
+  about: string | null;
+  avatar: string | null;
+}
+
+const BASE_RPC = 'https://mainnet.base.org';
+const ZERO = '0x0000000000000000000000000000000000000000';
+const AVATAR_RE = /^(https?:\/\/|ipfs:\/\/|data:image\/)/i;
+
+const TEXT_ABI = [
+  { name: 'addr', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'address' }] },
+  {
+    name: 'text',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ name: 'node', type: 'bytes32' }, { name: 'key', type: 'string' }],
+    outputs: [{ name: '', type: 'string' }],
+  },
+] as const;
+
+export const baseRpc = (): string => process.env.METRO_BASE_RPC ?? BASE_RPC;
+
+let reader: BaseClient | null = null;
+const readerFor = (): BaseClient => (reader ??= makePublicClient(baseRpc()));
+
+const trimmed = (v: string): string | null => (v.trim() === '' ? null : v.trim());
+
+async function resolverOf(client: BaseClient, node: Hex): Promise<Hex> {
+  const found: Hex = await client.readContract({ address: BASENAME_REGISTRY, abi: REGISTRY_ABI, functionName: 'resolver', args: [node] }).catch(() => ZERO);
+  return found === ZERO ? BASENAME_L2_RESOLVER : found;
+}
+
+async function primaryName(client: BaseClient, address: string): Promise<string | null> {
+  const node = reverseNodeOf(address);
+  const found = await client.readContract({ address: await resolverOf(client, node), abi: NAME_ABI, functionName: 'name', args: [node] }).catch(() => '');
+  return found === '' ? null : found;
+}
+
+async function recordsOf(client: BaseClient, name: string, address: string): Promise<SenderProfile | null> {
+  const node = namehash(normalize(name));
+  const resolver = { address: await resolverOf(client, node), abi: TEXT_ABI } as const;
+  const text = (key: string): Promise<string> => client.readContract({ ...resolver, functionName: 'text', args: [node, key] }).catch(() => '');
+  const [forward, displayName, about, avatar] = await Promise.all([
+    client.readContract({ ...resolver, functionName: 'addr', args: [node] }).catch(() => ZERO),
+    text('name'),
+    text('description'),
+    text('avatar'),
+  ]);
+  if (forward.toLowerCase() !== address.toLowerCase()) return null;
+  return { address, name, displayName: trimmed(displayName), about: trimmed(about), avatar: AVATAR_RE.test(avatar.trim()) ? avatar.trim() : null };
+}
+
+export async function profileOf(address: string, client: BaseClient = readerFor(), fetchImpl: typeof fetch = fetch): Promise<SenderProfile> {
+  const bare: SenderProfile = { address, name: null, displayName: null, about: null, avatar: null };
+  const name = (await primaryName(client, address)) ?? (await nameOf(address, fetchImpl).catch(() => null));
+  if (name === null) return bare;
+  return (await recordsOf(client, name, address).catch(() => null)) ?? bare;
+}
+
+const key = (acct: Account, inboxId: string): string => `${acct.cfg.id}:${inboxId}`;
+
+const senders = makeProfileCache<SenderProfile>(
+  async (k) => {
+    const [accountId, inboxId] = k.split(':', 2) as [string, string];
+    const acct = accounts.get(accountId);
+    if (acct === undefined) return null;
+    const address = (await resolveAddresses(acct, [inboxId]))[inboxId];
+    return address === undefined ? null : profileOf(address);
+  },
+  { onError: (k, err) => process.stderr.write(`xmtp: could not resolve the sender ${k}: ${err instanceof Error ? err.message : String(err)}\n`) },
+);
+
+export const senderFields = (p: SenderProfile | null): Record<string, string> =>
+  p === null ? {} : { from_name: p.name ?? p.address, ...(p.displayName === null ? {} : { from_display_name: p.displayName }) };
+
+export const senderFieldsNow = (acct: Account, inboxId: string): Record<string, string> => senderFields(senders.peek(key(acct, inboxId)));
+
+export const senderProfile = (acct: Account, inboxId: string): Promise<SenderProfile | null> => senders.get(key(acct, inboxId));
+
+export const profileView = (inboxId: string, p: SenderProfile | null): Profile => ({
+  id: inboxId,
+  ...(p === null ? {} : { address: p.address }),
+  ...(p?.name == null ? {} : { name: p.name }),
+  ...(p?.displayName == null ? {} : { display_name: p.displayName }),
+  ...(p?.about == null ? {} : { about: p.about }),
+  ...(p?.avatar == null ? {} : { avatar: p.avatar }),
+});
+
+export async function profileAction(id: string, args: Record<string, unknown>): Promise<void> {
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  if (user === '') throw new TrainError('xmtp_user_required', 'profile needs the inbox id of the person', { retryable: false });
+  const acct = accountForCall({ account: typeof args.account === 'string' ? args.account : undefined });
+  respond(id, { result: profileView(user, await senderProfile(acct, user)) });
+}

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

@@ -18,7 +18,7 @@ const ENTRY_POINT = getEntryPoint('0.7');
 export const zerodevRpc = (): string =>
   `https://rpc.zerodev.app/api/v3/${process.env.METRO_ZERODEV_PROJECT ?? STAGE_ZERODEV_PROJECT}/chain/${String(SMART_CHAIN_ID)}`;
 
-const makePublicClient = (rpc: string) => createPublicClient({ chain: base, transport: http(rpc) });
+export const makePublicClient = (rpc: string) => createPublicClient({ chain: base, transport: http(rpc) });
 
 export type BaseClient = ReturnType<typeof makePublicClient>;
 

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

@@ -10,6 +10,7 @@ export const xmtpStation: Station = {
   groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
   attachmentMode: 'native',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   claimsName: true,
   sendAttachments: xmtpSendAttachments,
   tools: XMTP_TOOLS,

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.161"
+  "version": "0.1.0-beta.163"
 }