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

package/package.json

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

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

@@ -105,7 +105,6 @@ 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

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

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

@@ -10,7 +10,6 @@ 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>>;
 
@@ -187,13 +186,9 @@ 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 handleTyping = async ({ line, ctx }: MessageArgs): Promise<ToolResult> => {
+  await ctx.call('typing', { line });
+  return ok('typing shown');
 };
 
 const MESSAGE_HANDLERS: Record<string, MessageHandler> = {
@@ -205,13 +200,6 @@ const MESSAGE_HANDLERS: Record<string, MessageHandler> = {
   ),
 };
 
-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;
 }
@@ -237,7 +225,7 @@ export async function dispatchMessageTool(
       `${station.name} does not support ${name}; it supports ${[...verbs].join(', ')}.`,
     );
   try {
-    return endTypingOnSend(name, line, await handler({ line, a, ctx: makeCtx(station.name), station, onSent: hooks.onSent }));
+    return 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

@@ -89,12 +89,11 @@ export const COMMON_TOOLS: ToolDef[] = [
     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).',
+      'Show "typing…" once in a chat while you prepare an answer. The network clears it by itself after its own time (about 5 s on the Telegram bot, 10 s on Discord, 25 s on WhatsApp) or when you send. Call it again to show it again. Args: line.',
     inputSchema: {
       type: 'object',
       properties: {
         line: lineProp,
-        on: { type: 'boolean', description: 'false stops it. Default true.' },
       },
       required: ['line'],
     },

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

@@ -92,6 +92,13 @@ function listAccounts(id: string): void {
   });
 }
 
+async function typing(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, channelId } = routeOf(line, account);
+  await rest(accountId, 'POST', `/channels/${channelId}/typing`);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
 async function react(id: string, args: Record<string, unknown>): Promise<void> {
   const { line, messageId, emoji, account } = args as {
     line: string;
@@ -198,6 +205,7 @@ const HANDLERS: Record<string, StationHandler> = {
   groupRemoveMembers: groupRemoveHandler,
   send,
   react,
+  typing,
   edit,
   delete: remove,
   read,

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

@@ -13,6 +13,7 @@ export const discordBotStation: Station = {
     'edit',
     'delete',
     'read',
+    'typing',
   ]),
   groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
   attachmentMode: 'canonical',

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

@@ -158,13 +158,11 @@ async function react(id: string, args: Record<string, unknown>): Promise<void> {
 }
 
 async function typing(id: string, args: Record<string, unknown>): Promise<void> {
-  const { line, on, account } = args as { line: string; on?: boolean; account?: string };
+  const { line, account } = args as { line: string; 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);
-  }
+  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 } });
 }
 

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

@@ -14,7 +14,6 @@ export const telegramBotStation: Station = {
     '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

@@ -130,7 +130,7 @@ 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));
+    await guard(() => client.showTyping(jid));
     respond(id, { result: { ok: true, account: accountId } });
   };
 }

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

@@ -50,7 +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>;
+  showTyping(jid: string): Promise<void>;
   editMessage(jid: string, messageId: string, text: string): Promise<void>;
   deleteMessage(jid: string, messageId: string): Promise<void>;
   reuploadMedia(m: WAMessage): Promise<WAMessage>;
@@ -340,9 +340,9 @@ export function createClient(account: WhatsAppAccount): WAClient {
         quotedId ? quotedOpts(st, jid, quotedId) : undefined,
       );
     },
-    async setTyping(jid, on) {
+    async showTyping(jid) {
       const sock = await ready(st);
-      await sock.sendPresenceUpdate(on ? 'composing' : 'paused', jid);
+      await sock.sendPresenceUpdate('composing', jid);
     },
     async sendReaction(jid, messageId, emoji) {
       const target = targetKey(st.keys, jid, messageId, 'react to');

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

@@ -15,7 +15,6 @@ export const whatsappStation: Station = {
     '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.203"
+  "version": "0.1.0-beta.205"
 }

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

@@ -1,46 +0,0 @@
-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()];