@stage-labs/metro 0.1.0-beta.204 → 0.1.0-beta.206

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.204",
+  "version": "0.1.0-beta.206",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.204",
+  "version": "0.1.0-beta.206",
   "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/marketplace/plugin/orchestrator.md

@@ -7,6 +7,8 @@ You are the main thread of a Claude Code session that is connected to chat throu
 
 **Inbound.** A message arrives as a `<channel source="metro" …>` block. Read `addressed` first: `direct`, `mention` or `reply` means it is for you; without it the message merely happened in a room you watch, so treat it as context and stay silent unless the person plainly wants you. For a message that is for you, the first tool call is `react` on it (👀, then 👍 or ✅ once done) so the person knows you saw it, and any reply goes on the same `line`, passed verbatim.
 
+**Typing.** Whenever you are about to send a message on a line within the next 10 seconds, call `typing` on that `line` first, so the person sees "typing…" while you write. It shows once and fades by itself (about 5 s on the Telegram bot, 10 s on Discord, 25 s on WhatsApp) or when your message arrives, so there is nothing to stop. Only WhatsApp, the Telegram bot and Discord support it; on other channels skip it.
+
 **Delegate everything that is work.** Reading files, running commands, searching, fetching pages, editing, and every connector tool: hand it to a subagent with the `Agent` tool, `subagent_type: "worker"`, always `run_in_background: true`, then keep answering chat while it runs and relay the result when the task notification arrives. A foreground subagent blinds you to chat and the guard refuses it. You may read image files yourself, so a screenshot someone sends is yours to look at.
 
 **Never wait on the terminal.** `AskUserQuestion`, plan mode and anything that blocks for a person at the keyboard are denied everywhere, main thread and subagents alike. When something is ambiguous, do what does not depend on it, choose the most reasonable reading, say so in your reply, and if a real decision is needed ask over chat with `send` and carry on. Tool-approval prompts reach the chat too; the person answers `yes <id>` or `no <id>` there.

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

@@ -11,6 +11,7 @@ export interface SenderCard {
   id: string;
   name?: string;
   handle?: string;
+  avatar?: string;
 }
 
 export interface SenderCardDeps {
@@ -28,10 +29,12 @@ function cardOf(id: string, profile: unknown, seenName: string | undefined): Sen
   const display = filled(p.display_name);
   const handle = filled(p.name);
   const name = display ?? seenName ?? handle;
+  const avatar = filled(p.avatar);
   return {
     id,
     ...(name === undefined ? {} : { name }),
     ...(handle === undefined || handle === name ? {} : { handle }),
+    ...(avatar?.startsWith('https://') === true ? { avatar } : {}),
   };
 }
 

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

@@ -17,7 +17,7 @@ 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 { makeNameBook, phoneOf, type NameBook } from './names.js';
+import { makeNameBook, nameFiles, phoneOf, type NameBook } from './names.js';
 import { useAccountAuthState } from './auth-state.js';
 import { knownKey, makeKeyCache, targetKey, type KeyCache } from './keys.js';
 import { makeOutbox, type Outbox } from './outbox.js';
@@ -301,7 +301,7 @@ export function createClient(account: WhatsAppAccount): WAClient {
     keys: makeKeyCache(),
     outbox: makeOutbox(),
     acks: makeAckWatch(),
-    names: makeNameBook(),
+    names: makeNameBook(nameFiles.path(account.id)),
   };
   resetGate(st);
   const senders = makeProfileCache<SenderProfile>((jid) => readProfile(st, jid), {

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

@@ -1,22 +1,56 @@
+import { readFileSync } from 'node:fs';
+import { accountFiles } from '@metro-labs/core/stations/account-files';
+import { writeSecure } from '@metro-labs/core/secure-fs';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg } from '@metro-labs/core/log';
+
 const MAX_NAMES = 2000;
+const SAVE_DELAY_MS = 2000;
+
+export const nameFiles = accountFiles('WHATSAPP_TOKEN_DIR', 'whatsapp-names-');
 
 export interface NameBook {
   note(jid: string | null | undefined, name: string | null | undefined): void;
   get(jid: string): string | undefined;
 }
 
-export function makeNameBook(): NameBook {
-  const names = new Map<string, string>();
+function loaded(file: string | undefined): Map<string, string> {
+  if (file === undefined) return new Map();
+  try {
+    const raw: unknown = JSON.parse(readFileSync(file, 'utf8'));
+    if (!isRecord(raw)) return new Map();
+    return new Map(Object.entries(raw).filter((e): e is [string, string] => typeof e[1] === 'string' && e[1] !== ''));
+  } catch {
+    return new Map();
+  }
+}
+
+export function makeNameBook(file?: string): NameBook {
+  const names = loaded(file);
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const save = (): void => {
+    timer = null;
+    if (file === undefined) return;
+    try {
+      writeSecure(file, JSON.stringify(Object.fromEntries(names)));
+    } catch (err) {
+      process.stderr.write(`whatsapp: could not save the names: ${errMsg(err)}\n`);
+    }
+  };
   return {
     note(jid, name) {
       const clean = name?.trim() ?? '';
-      if (!jid || clean === '') return;
+      if (!jid || clean === '' || names.get(jid) === clean) return;
       names.delete(jid);
       names.set(jid, clean);
       if (names.size > MAX_NAMES) {
         const oldest = names.keys().next().value;
         if (oldest !== undefined) names.delete(oldest);
       }
+      if (file !== undefined && timer === null) {
+        timer = setTimeout(save, SAVE_DELAY_MS);
+        timer.unref();
+      }
     },
     get: (jid) => names.get(jid),
   };

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

@@ -1,6 +1,7 @@
 import type { Station, Verb } from '@metro-labs/core/stations/types';
 import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
 import { tokenFiles } from './token-store.js';
+import { nameFiles } from './names.js';
 
 export const whatsappStation: Station = {
   name: 'whatsapp',
@@ -19,7 +20,13 @@ export const whatsappStation: Station = {
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
   readsProfiles: true,
   resolvesSenders: true,
-  forget: tokenFiles.forget,
-  forgetExcept: tokenFiles.forgetExcept,
+  forget: (accountId) => {
+    tokenFiles.forget(accountId);
+    nameFiles.forget(accountId);
+  },
+  forgetExcept: (kept) => {
+    tokenFiles.forgetExcept(kept);
+    nameFiles.forgetExcept(kept);
+  },
   tools: [],
 };

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.204"
+  "version": "0.1.0-beta.206"
 }