@stage-labs/metro 0.1.0-beta.30 → 0.1.0-beta.301

package/runtime/node_modules/@metro-labs/{mcp → daemon}/src/channels/inbound.ts

@@ -1,6 +1,5 @@
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { str } from '../mcp/str.js';
-import { dedupeKey } from './dedupe.js';
+import { str } from '@metro-labs/core/str';
 import {
   buildMediaFailureNote,
   buildMediaNote,
@@ -8,9 +7,12 @@ import {
   type SavedMedia,
 } from './media-note.js';
 import { buildWebhookNote } from './webhook-note.js';
+import { replyMeta } from './addressed.js';
+import { reactContent, reactionEmoji } from './react-note.js';
 import {
   capSet,
   displayNameMeta,
+  missingAttachmentNames,
   senderMeta,
   tsMeta,
   takeMediaCtx,
@@ -18,31 +20,43 @@ import {
   type PendingAtt,
   type PendingMsg,
 } from './pending.js';
+import { agentUser } from '../agent-user/user.js';
+
+const PERMISSION_REPLY_RE = /^\s*(y|yes|n|no)\s+([a-km-z]{5})\s*$/i;
+
+const accountStrippedLine = (line: string): string => {
+  const parts = line.split('/');
+  if (parts.length < 5) return line;
+  return [parts[0], parts[1], parts[2], ...parts.slice(4)].join('/');
+};
+
+const dedupeKey = (station: string, line: string, kind: string, messageId: string): string =>
+  `${station} ${accountStrippedLine(line)} ${kind} ${messageId}`;
 
 interface InboundDeps {
   mcp: Server;
   log: (...a: unknown[]) => void;
   getStations: () => Set<string>;
-  senderAllowed: (from: string, line: string) => boolean;
+  senderAllowed: (from: string, line: string, verified?: boolean) => boolean;
+  approves?: (station: string) => boolean;
+  noteDirect?: (line: string, from: string) => void;
+  callMeta?: (event: Record<string, unknown>) => () => Record<string, string>;
+  answerPermission?: (requestId: string, behavior: 'allow' | 'deny', line: string, from: string) => Promise<boolean>;
 }
 
 const ATTACH_TIMEOUT_MS = 15_000;
+const LATE_ATTACH_WINDOW_MS = 15 * 60_000;
 const DEDUPE_TTL_MS = 30_000;
 const DEDUPE_MAX = 2_000;
 const ALLOWED_LINES_MAX = 2_000;
-const PENDING_PERMISSIONS_MAX = 500;
-
-const PERMISSION_REPLY_RE = /^\s*(y|yes|n|no)\s+([a-km-z]{5})\s*$/i;
-
-const shortId = (id: string): string =>
-  id.length > 10 ? `${id.slice(0, 6)}…` : id;
+const SENT_IDS_MAX = 2_000;
 
 export class InboundRelay {
   private readonly deps: InboundDeps;
   private readonly pendingAttachments = new Map<string, PendingMsg>();
   private readonly seenEvents = new Map<string, number>();
   private readonly allowedLines = new Set<string>();
-  private readonly pendingPermissions = new Set<string>();
+  private readonly sentIds = new Set<string>();
   private lastLine: string | undefined;
 
   constructor(deps: InboundDeps) {
@@ -53,21 +67,22 @@ export class InboundRelay {
     return this.lastLine;
   }
 
-  registerPermission(requestId: string): void {
-    this.pendingPermissions.add(requestId);
-    capSet(this.pendingPermissions, PENDING_PERMISSIONS_MAX);
+  dropPending(): void {
+    for (const e of this.pendingAttachments.values()) clearTimeout(e.timer);
+    this.pendingAttachments.clear();
+  }
+
+  noteSent(messageId: string): void {
+    if (!messageId) return;
+    this.sentIds.add(messageId);
+    capSet(this.sentIds, SENT_IDS_MAX);
   }
 
   private notify(method: string, params: Record<string, unknown>): Promise<void> {
     return this.deps.mcp.notification({ method, params });
   }
 
-  private isDuplicate(
-    station: string,
-    line: string,
-    kind: string,
-    messageId: string,
-  ): boolean {
+  private isDuplicate(station: string, line: string, kind: string, messageId: string): boolean {
     if (!messageId) return false;
     const key = dedupeKey(station, line, kind, messageId);
     const now = Date.now();
@@ -95,20 +110,23 @@ export class InboundRelay {
         from: ctx.from,
         station: ctx.station,
         ...senderMeta(ctx),
+        ...ctx.reply,
         kind: note.kind,
         mime: p.mime ?? '',
         name: note.name,
         ...extra,
+        ...ctx.callMeta?.(),
       },
     });
   }
 
   private async surfaceMedia(ctx: MediaCtx, p: SavedMedia): Promise<void> {
-    const note = await buildMediaNote(p, ctx.text ?? '');
+    const ownUser = agentUser() !== null;
+    const note = await buildMediaNote(p, ctx.text ?? '', !ownUser);
     if (!note) return;
     await this.surfaceNote(ctx, p, note, {
       ...(p.url ? { url: p.url } : {}),
-      local_path: note.path,
+      ...(ownUser ? {} : { local_path: note.path }),
     });
   }
 
@@ -121,25 +139,24 @@ export class InboundRelay {
   private async flushPendingFallback(id: string): Promise<void> {
     const e = this.pendingAttachments.get(id);
     if (!e) return;
-    this.pendingAttachments.delete(id);
-    const missing = e.attachments.filter((_, i) => !e.saved.has(i));
-    if (!missing.length) return;
-    const names = missing
-      .map((a) => a.name ?? a.kind ?? 'attachment')
-      .join(', ');
+    const missing = missingAttachmentNames(e);
+    if (!missing.length) {
+      this.pendingAttachments.delete(id);
+      return;
+    }
+    e.timer = setTimeout(() => { this.pendingAttachments.delete(id); }, LATE_ATTACH_WINDOW_MS);
+    const ctx = takeMediaCtx(e);
     await this.notify('notifications/claude/channel', {
       content:
-        (e.text ? `${e.text}\n` : '') +
-        `[attachment(s) could not be fetched in time: ${names}]`,
+        (ctx.text ? `${ctx.text}\n` : '') +
+        `[attachment(s) still downloading: ${missing.join(', ')}; they follow in a separate note]`,
       meta: {
-        line: e.line,
-        from: e.from,
-        station: e.station,
-        ...tsMeta(e.ts),
-        message_id: e.messageId,
-        line_name: e.lineName,
-        from_name: e.fromName,
-        ...displayNameMeta(e.fromDisplayName),
+        line: ctx.line,
+        from: ctx.from,
+        station: ctx.station,
+        ...senderMeta(ctx),
+        ...ctx.reply,
+        ...ctx.callMeta?.(),
       },
     });
   }
@@ -169,13 +186,14 @@ export class InboundRelay {
     };
   }
 
-  private async routeAttachment(ev: Record<string, unknown>): Promise<boolean> {
+  private async routeAttachment(ev: Record<string, unknown>, replay: boolean): Promise<boolean> {
     const p = ev.payload as SavedMedia | undefined;
     if (!p) return false;
     const type = p.contentType;
     if (type !== 'attachmentSaved' && type !== 'attachmentFailed') return false;
     const ctx = this.mediaCtxFor(ev, p);
     if (!ctx) return true;
+    if (replay) ctx.callMeta = undefined;
     if (type === 'attachmentFailed') await this.surfaceMediaFailure(ctx, p);
     else await this.surfaceMedia(ctx, p);
     return true;
@@ -183,8 +201,9 @@ export class InboundRelay {
 
   private bufferAttachments(
     ev: Record<string, unknown>,
-    base: { line: string; from: string; station: string; text: string },
+    base: EventBase,
     atts: PendingAtt[],
+    replay: boolean,
   ): void {
     const id = str(ev.id);
     if (!id) return;
@@ -197,6 +216,8 @@ export class InboundRelay {
       lineName: str(ev.lineName),
       fromName: str(ev.fromName),
       fromDisplayName: str(ev.fromDisplayName),
+      reply: replyMeta(ev, this.sentIds),
+      callMeta: !replay && base.evType === 'msg' ? this.deps.callMeta?.(ev) : undefined,
       attachments: atts.map((a) => ({ kind: a.kind, name: a.name })),
       saved: new Set<number>(),
       timer: setTimeout(() => {
@@ -224,9 +245,7 @@ export class InboundRelay {
     const removed =
       (ev.payload as { removed?: boolean } | undefined)?.removed === true ||
       / \(removed\)\]?$/.test(base.text);
-    const verb = removed ? 'removed from' : 'reacted to';
-    const label = removed ? emoji || 'reaction' : emoji || 'reacted';
-    const content = `${label} ${verb} message ${shortId(target)}`.trim();
+    const content = reactContent(emoji, target, removed);
     await this.notify('notifications/claude/channel', {
       content,
       meta: {
@@ -244,28 +263,36 @@ export class InboundRelay {
     });
   }
 
-  private async handlePermissionReply(text: string): Promise<boolean> {
-    const m = PERMISSION_REPLY_RE.exec(text);
-    if (m?.[1] === undefined || m[2] === undefined || !this.pendingPermissions.size)
-      return false;
-    const id = m[2].toLowerCase();
-    if (!this.pendingPermissions.has(id)) return false;
-    this.pendingPermissions.delete(id);
-    await this.notify('notifications/claude/channel/permission', {
-      request_id: id,
-      behavior: m[1].toLowerCase().startsWith('y') ? 'allow' : 'deny',
-    });
-    return true;
+  private async handlePermissionReply(ev: Record<string, unknown>, base: EventBase): Promise<boolean> {
+    const answer = this.deps.answerPermission;
+    if (answer === undefined || base.evType !== 'msg' || !this.approves(base.station) || ev.senderVerified === false) return false;
+    const m = PERMISSION_REPLY_RE.exec(base.text);
+    if (m?.[1] === undefined || m[2] === undefined) return false;
+    return answer(m[2].toLowerCase(), m[1].toLowerCase().startsWith('y') ? 'allow' : 'deny', base.line, base.from);
+  }
+
+  private approves(station: string): boolean {
+    return this.deps.approves?.(station) !== false;
   }
 
-  private droppedSender(from: string, line: string): boolean {
+  private noteLine(base: EventBase, direct: boolean): void {
+    if (base.evType !== 'system' && this.approves(base.station)) {
+      this.lastLine = base.line;
+      if (direct) this.deps.noteDirect?.(base.line, base.from);
+    }
+    if (!base.line) return;
+    this.allowedLines.add(base.line);
+    capSet(this.allowedLines, ALLOWED_LINES_MAX);
+  }
+
+  private droppedSender(from: string, line: string, verified: unknown): boolean {
     if (
       from.startsWith('metro://claude') ||
       from === 'metro://user' ||
       !from.startsWith('metro://')
     )
       return true;
-    if (!this.deps.senderAllowed(from, line)) {
+    if (!this.deps.senderAllowed(from, line, typeof verified === 'boolean' ? verified : undefined)) {
       this.deps.log('drop: sender not allowed', from);
       return true;
     }
@@ -284,7 +311,7 @@ export class InboundRelay {
     if (!this.deps.getStations().has(station)) return null;
     const from = str(ev.from);
     const line = str(ev.line);
-    if (this.droppedSender(from, line)) return null;
+    if (this.droppedSender(from, line, ev.senderVerified)) return null;
     const text = str(ev.text);
     if (!replay && this.isDuplicate(station, line, evType, str(ev.messageId))) {
       this.deps.log(
@@ -301,9 +328,13 @@ export class InboundRelay {
   private async emitMessage(
     ev: Record<string, unknown>,
     base: EventBase,
+    replay: boolean,
   ): Promise<void> {
-    if (base.evType === 'msg' && (await this.handlePermissionReply(base.text)))
+    if (base.evType === 'msg' && base.text.trim() === '') {
+      this.deps.log('drop: empty message', base.station, base.line, str(ev.messageId));
       return;
+    }
+    if (await this.handlePermissionReply(ev, base)) return;
     await this.notify('notifications/claude/channel', {
       content:
         base.evType === 'system'
@@ -318,6 +349,8 @@ export class InboundRelay {
         line_name: str(ev.lineName),
         from_name: str(ev.fromName),
         ...displayNameMeta(ev.fromDisplayName),
+        ...replyMeta(ev, this.sentIds),
+        ...(!replay && base.evType === 'msg' ? this.deps.callMeta?.(ev)?.() : {}),
       },
     });
   }
@@ -326,20 +359,16 @@ export class InboundRelay {
     ev: Record<string, unknown>,
     replay = false,
   ): Promise<void> {
-    if (await this.routeAttachment(ev)) return;
+    if (await this.routeAttachment(ev, replay)) return;
 
     const base = this.routable(ev, replay);
     if (!base) return;
-    if (base.evType !== 'system') this.lastLine = base.line;
-    if (base.line) {
-      this.allowedLines.add(base.line);
-      capSet(this.allowedLines, ALLOWED_LINES_MAX);
-    }
+    this.noteLine(base, ev.isPrivate === true);
 
     const atts = (ev.payload as { attachments?: PendingAtt[] } | undefined)
       ?.attachments;
     if (Array.isArray(atts) && atts.length) {
-      this.bufferAttachments(ev, base, atts);
+      this.bufferAttachments(ev, base, atts, replay);
       return;
     }
 
@@ -347,8 +376,7 @@ export class InboundRelay {
       await this.handleReact(ev, base);
       return;
     }
-
-    await this.emitMessage(ev, base);
+    await this.emitMessage(ev, base, replay);
   }
 }
 
@@ -360,8 +388,3 @@ interface EventBase {
   text: string;
 }
 
-function reactionEmoji(raw: unknown): string {
-  if (typeof raw === 'string') return raw;
-  const obj = raw as { name?: string; reaction?: string } | undefined;
-  return obj?.name ?? obj?.reaction ?? '';
-}

package/runtime/node_modules/@metro-labs/{mcp → daemon}/src/channels/media-note.ts

@@ -6,7 +6,6 @@ export interface SavedMedia {
   contentType?: string;
   attachmentFor?: string;
   attachmentPath?: string;
-  localPath?: string;
   url?: string;
   mime?: string;
   name?: string;
@@ -22,7 +21,7 @@ export interface MediaNote {
   path: string;
 }
 
-export function mediaKind(mime?: string, name?: string): string {
+function mediaKind(mime?: string, name?: string): string {
   const m = (mime ?? '').toLowerCase();
   if (m.startsWith('image/')) return 'image';
   if (m.startsWith('video/')) return 'video';
@@ -50,22 +49,27 @@ function howToRead(url: string | undefined, tooBig: boolean): string {
   return 'Fetch the Public URL to view it. The path is on the daemon host, so the Read tool works only for an agent running there.';
 }
 
+const headline = (kind: string, name: string, mime: string | undefined, size: number): string =>
+  `[${kind} attachment received: ${name}${mime ? `, ${mime}` : ''}${size ? ` (${(size / 1024 / 1024).toFixed(2)} MB)` : ''}]\n`;
+
+const whereItIs = (path: string, url: string | undefined, size: number, showPath: boolean): string =>
+  showPath ? `Daemon-host path: ${path}\n${howToRead(url, size > MAX_INLINE_BYTES)}` : 'Fetch the Public URL to get the file.';
+
 export async function buildMediaNote(
   p: SavedMedia,
   caption: string,
+  showPath = true,
 ): Promise<MediaNote | null> {
-  const path = p.attachmentPath ?? p.localPath;
+  const path = p.attachmentPath;
   if (!path) return null;
   const kind = p.kind ?? mediaKind(p.mime, p.name);
   const name = p.name ?? path.split('/').pop() ?? 'attachment';
   const size = await fileSize(path);
-  const sizeNote = size ? ` (${(size / 1024 / 1024).toFixed(2)} MB)` : '';
   const content =
     (caption ? `${caption}\n` : '') +
-    `[${kind} attachment received: ${name}${p.mime ? `, ${p.mime}` : ''}${sizeNote}]\n` +
+    headline(kind, name, p.mime, size) +
     (p.url ? `Public URL: ${p.url}\n` : '') +
-    `Daemon-host path: ${path}\n` +
-    howToRead(p.url, size > MAX_INLINE_BYTES);
+    whereItIs(path, p.url, size, showPath);
   return { content, kind, name, path };
 }
 

package/runtime/node_modules/@metro-labs/{mcp → daemon}/src/channels/pending.ts

@@ -1,4 +1,4 @@
-import { str } from '../mcp/str.js';
+import { str } from '@metro-labs/core/str';
 
 export interface PendingAtt {
   kind?: string;
@@ -15,6 +15,8 @@ export interface PendingMsg {
   lineName: string;
   fromName: string;
   fromDisplayName: string;
+  reply: Record<string, string>;
+  callMeta?: () => Record<string, string>;
   attachments: PendingAtt[];
   saved: Set<number>;
   timer: ReturnType<typeof setTimeout>;
@@ -30,6 +32,8 @@ export interface MediaCtx {
   lineName?: string;
   fromName?: string;
   fromDisplayName?: string;
+  reply?: Record<string, string>;
+  callMeta?: () => Record<string, string>;
 }
 
 export function capSet(set: Set<string>, max: number): void {
@@ -58,6 +62,12 @@ export const senderMeta = (c: MediaCtx): Record<string, string> => ({
   ...displayNameMeta(c.fromDisplayName),
 });
 
+export function missingAttachmentNames(buf: PendingMsg): string[] {
+  return buf.attachments
+    .filter((_, i) => !buf.saved.has(i))
+    .map((a) => a.name ?? a.kind ?? 'attachment');
+}
+
 export function takeMediaCtx(buf: PendingMsg): MediaCtx {
   const ctx: MediaCtx = {
     line: buf.line,
@@ -69,6 +79,8 @@ export function takeMediaCtx(buf: PendingMsg): MediaCtx {
     lineName: buf.lineName,
     fromName: buf.fromName,
     fromDisplayName: buf.fromDisplayName,
+    reply: buf.reply,
+    callMeta: buf.callMeta,
   };
   buf.text = '';
   return ctx;

package/runtime/node_modules/@metro-labs/daemon/src/channels/react-note.ts

@@ -0,0 +1,13 @@
+const shortId = (id: string): string => (id.length > 10 ? `${id.slice(0, 6)}…` : id);
+
+export function reactionEmoji(raw: unknown): string {
+  if (typeof raw === 'string') return raw;
+  const obj = raw as { name?: string; reaction?: string } | undefined;
+  return obj?.name ?? obj?.reaction ?? '';
+}
+
+export function reactContent(emoji: string, target: string, removed: boolean): string {
+  const verb = removed ? 'removed from' : 'reacted to';
+  const label = removed ? emoji || 'reaction' : emoji || 'reacted';
+  return `${label} ${verb} message ${shortId(target)}`.trim();
+}

package/runtime/node_modules/@metro-labs/{mcp → daemon}/src/channels/relay.ts

@@ -3,7 +3,7 @@ import {
   currentBusSeq,
   subscribeEvents,
   type MetroEvent,
-} from '../daemon/events.js';
+} from '@metro-labs/core/events';
 import type { InboundRelay } from './inbound.js';
 
 export interface ReplayLedger {
@@ -42,6 +42,10 @@ export class ChannelRelay {
     });
   }
 
+  whenIdle(): Promise<void> {
+    return this.chain;
+  }
+
   replayMissed(): void {
     const missed = bufferedSince(this.ledger.startAt).filter(
       (b) => !this.ledger.delivered.has(b.busSeq),
@@ -83,7 +87,7 @@ export class ChannelRelay {
   private withhold(event: MetroEvent, busSeq: number): void {
     this.ledger.delivered.delete(busSeq);
     this.deps.log(
-      'relay: withheld (line outside the channel session scope)',
+      'relay: withheld (no stream, or line outside the agent scope)',
       'busSeq',
       busSeq,
       'line',