@stage-labs/metro 0.1.0-beta.273 → 0.1.0-beta.275

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.273",
+  "version": "0.1.0-beta.275",
   "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.273",
+  "version": "0.1.0-beta.275",
   "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/xmtp/src/actions-conv.ts

@@ -1,5 +1,5 @@
 import { IdentifierKind, type DecodedMessage } from '@xmtp/node-sdk';
-import { accountForCall, convOf, lineOf, parseLine } from './accounts.js';
+import { accountForCall, convOf, lineOf, type Account } from './accounts.js';
 import { respond } from '@metro-labs/core/stations/station-runtime';
 import { resolveMsgId } from './wire.js';
 import { TrainError } from '@metro-labs/core/train-error';
@@ -17,6 +17,7 @@ import { updateChannelMeta } from './actions-meta.js';
 import { deletedByRequests, isDeleteRequest, superAdminCheck } from './delete-requests.js';
 import { isCallSignal } from './codecs.js';
 import { syncConversation } from './network.js';
+import { readAttachments } from './read-attachments.js';
 
 type Args = Record<string, unknown>;
 type Handler = (id: string, args: Args) => Promise<void>;
@@ -56,27 +57,37 @@ function textOf(m: DecodedMessage): string {
 
 const DELETED = { text: '[deletedMessage]', contentType: 'deletedMessage' };
 
+function messageOf(acct: Account, m: DecodedMessage, deleted: Set<string>): Record<string, unknown> {
+  return {
+    id: m.id,
+    ts: new Date(Number(m.sentAtNs / 1_000_000n)).toISOString(),
+    from: `metro://xmtp/${acct.cfg.id}/user/${m.senderInboxId}`,
+    ...(m.senderInboxId === acct.inboxId ? { self: true } : {}),
+    ...(deleted.has(m.id) ? DELETED : { text: textOf(m), contentType: m.contentType?.typeId ?? 'unknown' }),
+  };
+}
+
 async function read(id: string, args: Args): Promise<void> {
-  const { line, limit, before } = args as { line: string; limit?: number; before?: string };
+  const { line, limit, before, messageId } = args as { line: string; limit?: number; before?: string; messageId?: string };
   const { acct, conv } = await convOf(line);
   if (!conv)
     throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
-  const lim = Math.min(Math.max(1, limit ?? 20), 200);
   await syncConversation(acct.client, conv);
   const all = await conv.messages();
+  if (messageId) {
+    const target = resolveMsgId(messageId);
+    const message = acct.client.conversations.getMessageById(target);
+    if (message?.conversationId !== conv.id || isDeleteRequest(message) || isCallSignal(message))
+      throw new TrainError('NOT_FOUND', `message ${messageId} is not in this conversation`);
+    const deleted = deletedByRequests([...all, message], superAdminCheck(conv));
+    const attachments = deleted.has(message.id) ? [] : await readAttachments(message);
+    respond(id, { result: { line, account: acct.cfg.id, message: { ...messageOf(acct, message, deleted), attachments } } });
+    return;
+  }
+  const lim = Math.min(Math.max(1, limit ?? 20), 200);
   const deleted = deletedByRequests(all, superAdminCheck(conv));
   const slice = upTo(all.filter((m) => !isDeleteRequest(m) && !isCallSignal(m)), before).slice(-lim);
-  const parsed = parseLine(line);
-  if (!parsed)
-    throw new TrainError('NOT_FOUND', `could not parse line ${line}`);
-  const acctId = parsed.accountId;
-  const messages = slice.map((m) => ({
-    id: m.id,
-    ts: new Date(Number(m.sentAtNs / 1_000_000n)).toISOString(),
-    from: `metro://xmtp/${acctId}/user/${m.senderInboxId}`,
-    ...(m.senderInboxId === acct.inboxId ? { self: true } : {}),
-    ...(deleted.has(m.id) ? DELETED : { text: textOf(m), contentType: m.contentType?.typeId ?? 'unknown' }),
-  }));
+  const messages = slice.map((m) => messageOf(acct, m, deleted));
   respond(id, { result: { line, count: messages.length, messages } });
 }
 

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

@@ -0,0 +1,37 @@
+import type { DecodedMessage } from '@xmtp/node-sdk';
+import { kindOf } from '@metro-labs/core/stations/attachments';
+import { saveInlineAttachment, saveRemoteAttachment, type RemoteEntry, type SavedAttachment } from './attachments.js';
+
+interface ReadAttachment {
+  name?: string;
+  mime?: string;
+  kind: string;
+  size: number;
+  local_path: string;
+}
+
+function fileOf(saved: SavedAttachment): ReadAttachment {
+  return {
+    name: saved.name,
+    mime: saved.mime,
+    kind: kindOf(saved.mime ?? '', saved.path),
+    size: saved.bytes,
+    local_path: saved.path,
+  };
+}
+
+export async function readAttachments(message: DecodedMessage): Promise<ReadAttachment[]> {
+  const type = message.contentType?.typeId;
+  if (type === 'attachment') {
+    const content = message.content as { filename?: string; mimeType?: string; content: Uint8Array };
+    return [fileOf(await saveInlineAttachment(content, message.id))];
+  }
+  if (type === 'remoteStaticAttachment')
+    return [fileOf(await saveRemoteAttachment(message.content as RemoteEntry, message.id))];
+  if (type === 'multiRemoteStaticAttachment' || type === 'multiRemoteAttachment') {
+    const content = message.content as { attachments: RemoteEntry[] };
+    return Promise.all(content.attachments.map(async (entry, index) =>
+      fileOf(await saveRemoteAttachment(entry, message.id, index))));
+  }
+  return [];
+}

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

@@ -7,6 +7,7 @@ export const xmtpStation: Station = {
   hasAccounts: true,
   hasTrain: true,
   messageVerbs: new Set<Verb>(['send', 'reply', 'react', 'unreact', 'delete', 'read']),
+  readFilters: new Set(['message_id']),
   groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
   attachmentMode: 'native',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.273"
+  "version": "0.1.0-beta.275"
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.273",
+  "version": "0.1.0-beta.275",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",

package/runtime/sdk-runner/src/runner.ts

@@ -2,6 +2,7 @@ import { query, type CanUseTool, type Options, type Query, type SDKMessage, type
 import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
 import type { Activity } from './activity.js';
+import { ActivityTasks } from './activity-tasks.js';
 import { RunnerCalls } from './calls.js';
 import { channelText, type ChannelEvent } from './channel-text.js';
 import type { RunnerConfig } from './config.js';
@@ -14,6 +15,7 @@ import { METRO_SERVER, type MetroTools } from './tool-proxy.js';
 
 const STARTUP_WAIT = 'CLAUDE_CODE_MCP_STARTUP_WAIT_MS';
 export const COMPACT_AT = 120_000;
+export const COMPACT_IDLE_MS = 60_000;
 
 const MODEL_PINS: ReadonlySet<string> = new Set(['ANTHROPIC_MODEL', 'CLAUDE_CODE_SUBAGENT_MODEL']);
 
@@ -85,6 +87,8 @@ export class Runner {
   readonly inbox: Inbox;
   readonly calls: RunnerCalls;
   private readonly watch: SessionWatch;
+  private readonly tasks = new ActivityTasks(() => undefined);
+  private compactTimer: ReturnType<typeof setTimeout> | null = null;
   private session: Query | null = null;
   private sessionId: string | null = null;
   private compactAsked: Uuid | null = null;
@@ -101,7 +105,7 @@ export class Runner {
     this.inbox = new Inbox((unanswered) => { this.keep(unanswered); }, {
       ready: () => this.watch.admitting,
       dispatch: (message) => { this.watch.dispatched(message.uuid); },
-      input: (input) => { parts.activity?.input(input); },
+      input: (input) => { this.cancelCompact(); parts.activity?.input(input); },
       queue: (count, oldest) => { parts.activity?.pending(count, oldest); },
     });
     this.calls = new RunnerCalls(this.inbox, parts.activity);
@@ -133,15 +137,19 @@ export class Runner {
     if (this.session === null) throw new Error('the runner was not started');
     try {
       for await (const message of this.session) {
+        this.cancelCompact();
+        if (message.type === 'system') this.tasks.observe(message);
         const m: Record<string, unknown> = { ...message };
         this.trackInput(m);
         this.watch.observe(m);
         this.note(m);
         this.parts.activity?.observe(message);
         this.inbox.notify();
+        this.maybeCompact();
         observe?.(message);
       }
     } finally {
+      this.cancelCompact();
       this.ended = true;
     }
   }
@@ -163,10 +171,12 @@ export class Runner {
   }
 
   close(cancelActive = true): void {
+    this.cancelCompact();
     this.calls.close();
     try {
       if (cancelActive && !this.ended) this.inbox.finished();
     } finally {
+      this.ended = true;
       this.inbox.close();
       this.session?.close();
     }
@@ -218,7 +228,6 @@ export class Runner {
     if (m.type === 'result') this.turnDone(m);
     if (m.type !== 'system') return;
     if (m.subtype === 'init') this.started(m);
-    else if (m.subtype === 'session_state_changed' && m.state === 'idle') this.maybeCompact();
     else if (m.subtype === 'compact_boundary') {
       this.compacted = true;
       this.compactFloor = null;
@@ -239,16 +248,33 @@ export class Runner {
       this.compactFloor = context;
       this.compacted = false;
     }
-    this.maybeCompact();
+  }
+
+  private compactReady(resuming = false): boolean {
+    const busy = this.ended || this.compactAsked !== null || !this.watch.safe || !this.watch.admitting || (!resuming && (this.calls.live || this.inbox.pending > 0 || this.tasks.running > 0));
+    return compactDue({ context: this.watch.context, floor: this.compactFloor, limit: this.parts.compactAt ?? COMPACT_AT, busy });
   }
 
   private maybeCompact(resuming = false): void {
-    const busy = this.compactAsked !== null || !this.watch.safe || !this.watch.admitting || (!resuming && (this.calls.live || this.inbox.pending > 0));
-    if (!compactDue({ context: this.watch.context, floor: this.compactFloor, limit: this.parts.compactAt ?? COMPACT_AT, busy })) return;
+    if (!this.compactReady(resuming)) return;
+    if (resuming) { this.askCompact(true); return; }
+    this.compactTimer = setTimeout(() => {
+      this.compactTimer = null;
+      if (this.compactReady()) this.askCompact(false);
+    }, COMPACT_IDLE_MS);
+    this.compactTimer.unref();
+  }
+
+  private askCompact(resuming: boolean): void {
     this.compactAsked = this.inbox.compact();
     log.info({ context: this.watch.context, resuming }, 'sdk-runner: compacting at a safe idle boundary');
   }
 
+  private cancelCompact(): void {
+    if (this.compactTimer !== null) clearTimeout(this.compactTimer);
+    this.compactTimer = null;
+  }
+
   private started(m: Record<string, unknown>): void {
     const id = typeof m.session_id === 'string' ? m.session_id : null;
     if (id === null || id === this.sessionId) return;