@stage-labs/metro 0.1.0-beta.202 → 0.1.0-beta.203

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.202",
+  "version": "0.1.0-beta.203",
   "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.202",
+  "version": "0.1.0-beta.203",
   "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

@@ -5,7 +5,7 @@ description: How this box's agent works on metro. Acknowledge, delegate, relay,
 
 You are the main thread of a Claude Code session that is connected to chat through metro, on a machine nobody watches. The main thread is an orchestrator: it may only delegate and talk. A guard in the metro plugin denies every other tool on this thread, so this is the shape of the work, not a preference.
 
-**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.
+**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. When the answer will take more than a few seconds, call `typing` on that `line` right after the 👀: metro keeps "typing…" showing until you send or reply there (or 2 minutes pass). Only WhatsApp and the Telegram bot support it; elsewhere 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.
 

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

@@ -7,7 +7,8 @@ export type Verb =
   | 'unreact'
   | 'edit'
   | 'delete'
-  | 'read';
+  | 'read'
+  | 'typing';
 
 export interface ToolResult {
   content: { type: 'text'; text: string }[];
@@ -104,6 +105,7 @@ export interface Station {
   hasAccounts: boolean;
   hasTrain: boolean;
   messageVerbs: ReadonlySet<Verb>;
+  typingRefreshMs?: number;
   groupOps?: ReadonlySet<GroupOp>;
   resolvesSenders?: boolean;
   profileFields?: ReadonlySet<ProfileField>;

package/runtime/node_modules/@metro-labs/daemon/src/claude/setup.ts

@@ -133,6 +133,7 @@ const PRIOR_WORKER: ReadonlySet<string> = new Set(['08a0cd8710df285d6512245246bb
 const PRIOR_SKILL: ReadonlySet<string> = new Set([
   '0b3d122ed95beff09d579cf912cd4238e1db524c41fce4b314de57d6ff5908ad',
   '36f4fb57f231a119d717b5e3d6ccb654f94960fcca708683f376679aead8df25',
+  '3840bc50253e51f431691376cf29a925b8245d87b77b8b20804a159e378a6e67',
 ]);
 
 const digest = (text: string): string => createHash('sha256').update(text).digest('hex');

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

@@ -10,6 +10,7 @@ import { errResult, makeCtx, ok, toErr } from './ctx.js';
 import { runRead } from './read-tool.js';
 import { allowedAgents, currentIdentity } from './request-identity.js';
 import { str } from '@metro-labs/core/str';
+import { startTyping, stopTyping, TYPING_MAX_MS } from './typing.js';
 
 type Station = NonNullable<ReturnType<typeof stationForLine>>;
 
@@ -186,14 +187,31 @@ function makeVerbHandler(verb: string, spec: VerbSpec): MessageHandler {
   };
 }
 
+const handleTyping = async ({ line, a, ctx, station }: MessageArgs): Promise<ToolResult> => {
+  if (a.on === false) {
+    stopTyping(line);
+    return ok('typing stopped');
+  }
+  await startTyping(line, (on) => ctx.call('typing', { line, on }), station.typingRefreshMs);
+  return ok(`typing shown; it stops when you send or reply here, or after ${String(TYPING_MAX_MS / 60_000)} minutes`);
+};
+
 const MESSAGE_HANDLERS: Record<string, MessageHandler> = {
   send: handleSend,
   read: handleRead,
+  typing: handleTyping,
   ...Object.fromEntries(
     Object.entries(MESSAGE_VERBS).map(([verb, spec]) => [verb, makeVerbHandler(verb, spec)]),
   ),
 };
 
+const SENDS = new Set(['send', 'reply']);
+
+function endTypingOnSend(name: string, line: string, result: ToolResult): ToolResult {
+  if (SENDS.has(name) && result.isError !== true) stopTyping(line);
+  return result;
+}
+
 export interface ToolHooks {
   onSent?: (messageId: string) => void;
 }
@@ -219,7 +237,7 @@ export async function dispatchMessageTool(
       `${station.name} does not support ${name}; it supports ${[...verbs].join(', ')}.`,
     );
   try {
-    return await handler({ line, a, ctx: makeCtx(station.name), station, onSent: hooks.onSent });
+    return endTypingOnSend(name, line, await handler({ line, a, ctx: makeCtx(station.name), station, onSent: hooks.onSent }));
   } catch (e) {
     return toErr(name, e);
   }

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

@@ -85,6 +85,20 @@ export const COMMON_TOOLS: ToolDef[] = [
       required: ['line', 'message_id', 'emoji'],
     },
   },
+  {
+    name: 'typing',
+    group: 'write',
+    description:
+      'Show "typing…" in a chat while you prepare an answer that takes more than a few seconds. Call it once: metro keeps it alive and stops it when you send or reply on that line, when you call it with on: false, or after 2 minutes. Args: line, on (default true).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: lineProp,
+        on: { type: 'boolean', description: 'false stops it. Default true.' },
+      },
+      required: ['line'],
+    },
+  },
   {
     name: 'unreact',
     group: 'write',

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

@@ -0,0 +1,46 @@
+import { errMsg, log } from '@metro-labs/core/log';
+
+export const TYPING_MAX_MS = 120_000;
+const DEFAULT_REFRESH_MS = 5_000;
+
+export type TypingCall = (on: boolean) => Promise<unknown>;
+
+interface Held {
+  timer: ReturnType<typeof setInterval>;
+  call: TypingCall;
+}
+
+const held = new Map<string, Held>();
+
+const quietly = (line: string, run: Promise<unknown>): void => {
+  run.catch((err: unknown) => {
+    log.debug({ line, err: errMsg(err) }, 'typing: a refresh failed');
+  });
+};
+
+export function stopTyping(line: string): void {
+  const current = held.get(line);
+  if (current === undefined) return;
+  clearInterval(current.timer);
+  held.delete(line);
+  quietly(line, current.call(false));
+}
+
+export async function startTyping(line: string, call: TypingCall, refreshMs = DEFAULT_REFRESH_MS, now = Date.now): Promise<void> {
+  const previous = held.get(line);
+  if (previous !== undefined) clearInterval(previous.timer);
+  held.delete(line);
+  await call(true);
+  const stopAt = now() + TYPING_MAX_MS;
+  const timer = setInterval(() => {
+    if (now() >= stopAt) {
+      stopTyping(line);
+      return;
+    }
+    quietly(line, call(true));
+  }, refreshMs);
+  timer.unref();
+  held.set(line, { timer, call });
+}
+
+export const typingLines = (): string[] => [...held.keys()];

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

@@ -157,6 +157,17 @@ async function react(id: string, args: Record<string, unknown>): Promise<void> {
   respond(id, { result: { ok: true, account: accountId } });
 }
 
+async function typing(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, on, account } = args as { line: string; on?: boolean; account?: string };
+  const { accountId, chatId, topicId } = targetOf(line, account);
+  if (on !== false) {
+    const body: Record<string, unknown> = { chat_id: chatId, action: 'typing' };
+    if (topicId !== undefined) body.message_thread_id = topicId;
+    await tg(accountId, 'sendChatAction', body);
+  }
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
 async function edit(id: string, args: Record<string, unknown>): Promise<void> {
   const { line, messageId, text, account } = args as {
     line: string;
@@ -217,6 +228,7 @@ const HANDLERS: Record<string, StationHandler> = {
   accounts: (id) => listAccounts(id),
   send,
   react,
+  typing,
   edit,
   delete: remove,
   listMembers,

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

@@ -12,7 +12,9 @@ export const telegramBotStation: Station = {
     'unreact',
     'edit',
     'delete',
+    'typing',
   ]),
+  typingRefreshMs: 4_000,
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
   readsProfiles: true,

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

@@ -127,6 +127,14 @@ function makeReact(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeTyping(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, jid } = resolve(args, clientFor);
+    await guard(() => client.setTyping(jid, args.on !== false));
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
 function makeEdit(clientFor: ClientFor): StationHandler {
   return async (id, args) => {
     const { accountId, client, jid } = resolve(args, clientFor);
@@ -201,6 +209,7 @@ export function makeHandleCall(
       accounts: makeAccounts(clientFor),
       send: makeSend(clientFor),
       react: makeReact(clientFor),
+      typing: makeTyping(clientFor),
       edit: makeEdit(clientFor),
       delete: makeDelete(clientFor),
       resolve_sender: makeResolveSender(clientFor),

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

@@ -50,6 +50,7 @@ export interface WAClient {
   sendText(jid: string, text: string, quotedId?: string): Promise<string>;
   sendMedia(jid: string, media: WAMedia, quotedId?: string): Promise<string>;
   sendReaction(jid: string, messageId: string, emoji: string): Promise<void>;
+  setTyping(jid: string, on: boolean): Promise<void>;
   editMessage(jid: string, messageId: string, text: string): Promise<void>;
   deleteMessage(jid: string, messageId: string): Promise<void>;
   reuploadMedia(m: WAMessage): Promise<WAMessage>;
@@ -339,6 +340,10 @@ export function createClient(account: WhatsAppAccount): WAClient {
         quotedId ? quotedOpts(st, jid, quotedId) : undefined,
       );
     },
+    async setTyping(jid, on) {
+      const sock = await ready(st);
+      await sock.sendPresenceUpdate(on ? 'composing' : 'paused', jid);
+    },
     async sendReaction(jid, messageId, emoji) {
       const target = targetKey(st.keys, jid, messageId, 'react to');
       await send(st, jid, { react: { text: emoji, key: target } });

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

@@ -13,7 +13,9 @@ export const whatsappStation: Station = {
     'unreact',
     'edit',
     'delete',
+    'typing',
   ]),
+  typingRefreshMs: 20_000,
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
   readsProfiles: true,

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.202"
+  "version": "0.1.0-beta.203"
 }