@stage-labs/metro 0.1.0-beta.328 → 0.1.0-beta.329

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.328",
+  "version": "0.1.0-beta.329",
   "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/node_modules/@metro-labs/daemon/src/claude/api.ts

@@ -25,6 +25,7 @@ import {
   type SessionDeps,
 } from './session.js';
 import { receiveSessionFile, sessionFilePath } from './session-files.js';
+import { readToolCall } from './tool-call.js';
 import { createReadStream } from '../agent-user/agent-fs.js';
 import { pipeline } from 'node:stream/promises';
 import {
@@ -50,6 +51,11 @@ export interface ClaudeApiDeps extends SetupApiDeps {
   skillSource?: GitHubSkills;
 }
 
+function optionalProject(query: URLSearchParams): string | null {
+  const project = query.get('project');
+  return project === null || project === '' ? null : project;
+}
+
 function projectOf(query: URLSearchParams): string {
   const project = query.get('project');
   if (project === null || project === '') throw new ApiError('project is required', 400);
@@ -73,7 +79,9 @@ const COLLECTIONS: Record<string, Handler> = {
 };
 
 const ITEMS: Record<string, Handler> = {
-  sessions: (query, dir, id) => {
+  sessions: async (query, dir, id) => {
+    const tool = query.get('tool');
+    if (tool !== null) return { call: await readToolCall(optionalProject(query), id, tool, dir) };
     const { offset, limit } = pageOf(query);
     return readTranscript(projectOf(query), id, offset, limit, dir);
   },

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

@@ -15,8 +15,8 @@ const MEMORY_DEPTH = 6;
 const MEMORY_FILES_MAX = 5000;
 const EDGE_BYTES = 64 * 1024;
 const TEXT_CAP = 20_000;
-const RESULT_CAP = 8_000;
-const INPUT_CAP = 4_000;
+export const RESULT_CAP = 8_000;
+export const INPUT_CAP = 4_000;
 const FILE_CAP = 1_000_000;
 const MEMORY_MAX = 256 * 1024;
 const MEMORY_MODE = 0o644;
@@ -31,7 +31,7 @@ export function claudeDir(): string {
   return join(user === null ? homedir() : user.home, '.claude');
 }
 
-const str = (v: unknown): string | null => (typeof v === 'string' && v !== '' ? v : null);
+export const str = (v: unknown): string | null => (typeof v === 'string' && v !== '' ? v : null);
 
 export function safeName(value: string, re: RegExp, what: string): string {
   if (!re.test(value) || value === '.' || value === '..')
@@ -39,13 +39,13 @@ export function safeName(value: string, re: RegExp, what: string): string {
   return value;
 }
 
-function projectDir(project: string, dir: string): string {
+export function projectDir(project: string, dir: string): string {
   const path = join(dir, 'projects', safeName(project, PROJECT_RE, 'Claude project id'));
   if (!existsSync(path)) throw new ApiError('no such Claude project', 404);
   return path;
 }
 
-function parseLines(text: string): Record<string, unknown>[] {
+export function parseLines(text: string): Record<string, unknown>[] {
   const out: Record<string, unknown>[] = [];
   for (const line of text.split('\n')) {
     if (line.trim() === '') continue;
@@ -187,10 +187,10 @@ export interface TranscriptPage {
   next: number | null;
 }
 
-const cap = (text: string, max: number): string =>
+export const cap = (text: string, max: number): string =>
   text.length > max ? `${text.slice(0, max)}\n… (${String(text.length - max)} more characters)` : text;
 
-function resultText(content: unknown): string {
+export function resultText(content: unknown): string {
   if (typeof content === 'string') return content;
   if (!Array.isArray(content)) return '';
   return content

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

@@ -0,0 +1,73 @@
+import { createReadStream, existsSync, readdirNames } from '../agent-user/agent-fs.js';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { isRecord } from '@metro-labs/core/is-record';
+import { cap, claudeDir, INPUT_CAP, parseLines, projectDir, PROJECT_RE, RESULT_CAP, resultText, safeName, SESSION_RE, str } from './files.js';
+
+const TOOL_USE_RE = /^[A-Za-z0-9_-]{1,128}$/;
+
+export interface ToolCall {
+  name: string;
+  input: string;
+  result: string | null;
+  isError: boolean;
+  calledAt: string | null;
+  answeredAt: string | null;
+}
+
+function transcriptFiles(root: string, session: string): string[] {
+  const workers = join(root, session, 'subagents');
+  const extra = existsSync(workers) ? readdirNames(workers).filter((name) => name.endsWith('.jsonl')).map((name) => join(workers, name)) : [];
+  return [join(root, `${session}.jsonl`), ...extra].filter((path) => existsSync(path));
+}
+
+function noteBlock(found: Partial<ToolCall>, block: unknown, toolUse: string, at: string | null): void {
+  if (!isRecord(block)) return;
+  if (block.type === 'tool_use' && block.id === toolUse) {
+    found.name = str(block.name) ?? 'tool';
+    found.input = cap(JSON.stringify(block.input ?? {}, null, 1), INPUT_CAP);
+    found.calledAt = at;
+  }
+  if (block.type === 'tool_result' && block.tool_use_id === toolUse) {
+    found.result = cap(resultText(block.content), RESULT_CAP);
+    found.isError = block.is_error === true;
+    found.answeredAt = at;
+  }
+}
+
+async function scanForCall(path: string, toolUse: string): Promise<Partial<ToolCall>> {
+  const found: Partial<ToolCall> = {};
+  const lines = createInterface({ input: createReadStream(path), crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.includes(toolUse)) continue;
+    const parsed = parseLines(line)[0];
+    const content = parsed !== undefined && isRecord(parsed.message) ? parsed.message.content : null;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) noteBlock(found, block, toolUse, str(parsed?.timestamp));
+    if (found.name !== undefined && found.result !== undefined) break;
+  }
+  return found;
+}
+
+function projectHolding(session: string, dir: string): string | null {
+  const root = join(dir, 'projects');
+  if (!existsSync(root)) return null;
+  return readdirNames(root).find((name) => PROJECT_RE.test(name) && existsSync(join(root, name, `${session}.jsonl`))) ?? null;
+}
+
+function completed(name: string, found: Partial<ToolCall>): ToolCall {
+  return { name, input: found.input ?? '{}', result: found.result ?? null, isError: found.isError ?? false, calledAt: found.calledAt ?? null, answeredAt: found.answeredAt ?? null };
+}
+
+export async function readToolCall(project: string | null, session: string, toolUse: string, dir = claudeDir()): Promise<ToolCall | null> {
+  const id = safeName(session, SESSION_RE, 'session id');
+  const holder = project ?? projectHolding(id, dir);
+  if (holder === null) return null;
+  const root = projectDir(holder, dir);
+  const wanted = safeName(toolUse, TOOL_USE_RE, 'tool call id');
+  for (const path of transcriptFiles(root, id)) {
+    const found = await scanForCall(path, wanted);
+    if (found.name !== undefined) return completed(found.name, found);
+  }
+  return null;
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/relay.ts

@@ -87,9 +87,11 @@ async function relay(req: IncomingMessage, res: ServerResponse, path: string, de
     sendError(res, 503, 'api_error', NOT_ACCEPTED);
     return;
   }
-  await pipeResponse(upstream, res, watch);
+  await pipeResponse(upstream, res, watch, { site: RELAY_SITE });
 }
 
+const RELAY_SITE = { connection: 'gateway.metro.box', model: 'relayed' };
+
 function refusal(req: IncomingMessage, path: string, deps: RelayDeps): [number, string, string] | null {
   if (cameThroughProxy(req)) return [401, 'authentication_error', 'metro gateway: the agent key works only on this machine, not through its public address'];
   if (keyOf(req) === '' || !deps.identify(keyOf(req))) return [401, 'authentication_error', 'metro gateway: no agent key (x-metro-key); start the agent with metro agent'];

package/runtime/node_modules/@metro-labs/daemon/src/metro-user/install.ts

@@ -15,6 +15,7 @@ import {
 } from './helper-script.js';
 import { AGENT_NAME } from '../agent-user/user.js';
 import { hardenTailscale } from './tailscale-guard.js';
+import { liftSessionSoftLimits } from './session-scopes.js';
 
 interface InstallPaths {
   helper: string;
@@ -73,7 +74,7 @@ if (import.meta.main) {
   installRootHelper();
   installImdsGuard();
   installUpgradeUnit(node);
-  for (const note of hardenTailscale()) process.stderr.write(`metro: ${note}\n`);
+  for (const note of [...hardenTailscale(), ...liftSessionSoftLimits()]) process.stderr.write(`metro: ${note}\n`);
   process.stdout.write(
     `metro: wrote ${HELPER_PATH}, ${SUDOERS_PATH}, ${IMDS_UNIT_PATH} and ${UPGRADE_UNIT_PATH}; only root and metro reach the instance metadata service, and the root side follows every update\n`,
   );

package/runtime/node_modules/@metro-labs/daemon/src/metro-user/session-scopes.ts

@@ -0,0 +1,25 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const SYSTEM_SLICE = '/sys/fs/cgroup/system.slice';
+const SESSION_SCOPE = /^metro-claude-\d+\.scope$/;
+
+type Run = (file: string, args: string[]) => boolean;
+
+const quiet: Run = (file, args) => spawnSync(file, args, { stdio: 'ignore' }).status === 0;
+
+const softLimit = (dir: string): string | null => {
+  const path = join(dir, 'memory.high');
+  return existsSync(path) ? readFileSync(path, 'utf8').trim() : null;
+};
+
+export function liftSessionSoftLimits(run: Run = quiet, slice: string = SYSTEM_SLICE): string[] {
+  if (!existsSync(slice)) return [];
+  const held = readdirSync(slice).filter((name) => SESSION_SCOPE.test(name) && ![null, 'max'].includes(softLimit(join(slice, name))));
+  return held.map((scope) =>
+    run('systemctl', ['set-property', '--runtime', scope, 'MemoryHigh=infinity'])
+      ? `${scope}: its soft memory limit is lifted, so only the hard limit applies`
+      : `${scope}: its soft memory limit could not be lifted; it goes when the session starts again`,
+  );
+}

package/runtime/node_modules/@metro-labs/http/src/connector-oauth.ts

@@ -27,6 +27,21 @@ function challengeOf(verifier: string): string {
   return createHash('sha256').update(verifier).digest('base64url');
 }
 
+const REASON_MAX = 600;
+
+function oneLine(value: unknown): string {
+  if (typeof value !== 'string') return '';
+  const printable = Array.from(value, (char) => (char < ' ' || char === '\u007f' ? ' ' : char)).join('');
+  const text = printable.replace(/\s+/g, ' ').trim();
+  return text.length > REASON_MAX ? `${text.slice(0, REASON_MAX - 1)}…` : text;
+}
+
+function registrationReason(body: unknown): string {
+  if (!isRecord(body)) return '.';
+  const reason = oneLine(body.error_description) || oneLine(body.error);
+  return reason === '' ? '.' : `: ${reason}`;
+}
+
 export async function registerClient(
   server: OAuthServer,
   redirectUri: string,
@@ -58,7 +73,7 @@ export async function registerClient(
   }
   const body: unknown = await res.json().catch(() => null);
   if (!res.ok || !isRecord(body) || typeof body.client_id !== 'string')
-    throw refused('That server refused to register Metro as a client.');
+    throw refused(`That server refused to register Metro as a client${registrationReason(body)}`);
   const secret = body.client_secret;
   return {
     clientId: body.client_id,

package/runtime/node_modules/@metro-labs/inference/src/failures.ts

@@ -34,14 +34,27 @@ export function noteFailure(site: FailureSite, failure: Failure, what: string):
   log.warn({ connection: site.connection, model: site.model, ...failure, message: providerText(failure.message) }, what);
 }
 
+const STOP_DATA = /^\{\s*"type"\s*:\s*"message_stop"/;
+
 export class StreamErrors {
   private readonly parser = new SseParser();
+  private ended = false;
 
   constructor(private readonly site: FailureSite) {}
 
+  get settled(): boolean {
+    return this.ended;
+  }
+
+  cut(): void {
+    noteFailure(this.site, { code: 'stream_cut', message: '' }, 'gateway: the provider ended its stream before the answer was complete');
+  }
+
   feed(text: string): void {
     for (const raw of this.parser.push(text)) {
+      if (raw.event === 'message_stop' || STOP_DATA.test(raw.data)) this.ended = true;
       if (raw.event !== 'error' && !ERROR_DATA.test(raw.data)) continue;
+      this.ended = true;
       const data = parseEvent(raw)?.data ?? {};
       const error = isRecord(data.error) ? data.error : {};
       noteFailure(this.site, { code: stringOf(error.type) || stringOf(error.code), message: stringOf(error.message) }, 'gateway: the provider sent an error in the middle of its stream');

package/runtime/node_modules/@metro-labs/inference/src/forward.ts

@@ -171,16 +171,30 @@ function openResponse(upstream: Response, res: ServerResponse, opts: PipeOptions
 
 type Tap = (chunk: Uint8Array) => void;
 
-function tapOf(opts: PipeOptions, streaming: boolean): Tap | null {
+interface Tapped {
+  tap: Tap | null;
+  errors: StreamErrors | null;
+}
+
+function tapOf(opts: PipeOptions, streaming: boolean): Tapped {
   const scanner = opts.scanner;
   const errors = streaming && opts.site !== undefined ? new StreamErrors(opts.site) : null;
-  if (scanner === undefined && errors === null) return null;
+  if (scanner === undefined && errors === null) return { tap: null, errors };
   const decoder = new TextDecoder();
-  return (chunk) => {
+  const tap: Tap = (chunk) => {
     const text = decoder.decode(chunk, { stream: true });
     scanner?.feed(text);
     errors?.feed(text);
   };
+  return { tap, errors };
+}
+
+const CUT_MESSAGE = 'metro gateway: the provider ended its stream before the answer was complete; try again';
+
+function closeCut(res: ServerResponse, errors: StreamErrors | null): void {
+  if (errors === null || errors.settled || res.writableEnded) return;
+  errors.cut();
+  res.write(errorFrame('api_error', CUT_MESSAGE));
 }
 
 async function pump(body: ReadableStream<Uint8Array>, res: ServerResponse, watch: Watch, tap: Tap | null): Promise<void> {
@@ -202,10 +216,15 @@ export async function pipeResponse(upstream: Response, res: ServerResponse, watc
     return;
   }
   const ping = opts.keepalive === true && streaming ? setInterval(() => res.write(PING_FRAME), PING_MS) : null;
+  const { tap, errors } = tapOf(opts, streaming);
   try {
-    await pump(body, res, watch, tapOf(opts, streaming));
+    await pump(body, res, watch, tap);
+    closeCut(res, errors);
   } catch (err) {
-    if (!watch.idle()) throw err;
+    if (!watch.idle()) {
+      closeCut(res, errors);
+      throw err;
+    }
     if (streaming) res.write(errorFrame('api_error', idleMessage(watch.ms)));
   } finally {
     if (ping !== null) clearInterval(ping);

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.328"
+  "version": "0.1.0-beta.329"
 }

package/runtime/sdk-runner/runner.json

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

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

@@ -1,8 +1,9 @@
 import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
 import { runnerTaskDescription } from '@metro-labs/core/runner-activity';
 import { activityName } from './activity-tasks.js';
 import type { Unanswered } from './inbox.js';
-import { pendingNotice, TASK_LIMIT, type SavedTask, type TaskReason } from './task-state.js';
+import { exhausted, pendingNotice, TASK_LIMIT, type SavedTask, type TaskReason } from './task-state.js';
 
 interface Tool { name: string; parent: string | null }
 const failed = (text: unknown): TaskReason => typeof text === 'string' && /\b429\b|rate.?limit/i.test(text.slice(0, 4_096)) ? 'rate_limit' : 'task_error';
@@ -11,6 +12,7 @@ export class TaskLedger {
   private readonly rows = new Map<string, SavedTask>();
   private readonly tools = new Map<string, Tool>();
   private readonly errors = new Map<string, TaskReason>();
+  private warned = false;
 
   constructor(tasks: SavedTask[], private readonly save: (tasks: SavedTask[], handled?: ReadonlySet<string>) => void) {
     for (const task of tasks) this.rows.set(task.id, task);
@@ -102,7 +104,8 @@ export class TaskLedger {
 
   private room(): boolean {
     if (this.rows.size < TASK_LIMIT) return true;
-    const old = this.snapshot().find((task) => task.notice === null && task.state !== 'running');
+    const rows = this.snapshot();
+    const old = rows.find((task) => task.notice === null && task.state !== 'running') ?? rows.find(exhausted);
     if (old === undefined) return false;
     this.rows.delete(old.id);
     return true;
@@ -111,12 +114,18 @@ export class TaskLedger {
   private get(id: string, now: number): SavedTask {
     const known = this.rows.get(id);
     if (known !== undefined) return known;
-    if (!this.room()) throw new Error('The saved Agent SDK task ledger is full. Handle pending recovery notices before starting more work.');
     const task: SavedTask = { id, toolUseId: null, owner: null, attempt: 0, state: 'interrupted', events: [], updatedAt: now, notice: null };
-    this.rows.set(id, task);
+    if (this.room()) this.rows.set(id, task);
+    else this.untracked();
     return task;
   }
 
+  private untracked(): void {
+    if (this.warned) return;
+    this.warned = true;
+    log.warn({ limit: TASK_LIMIT }, 'sdk-runner: the task ledger is full of running work and pending recovery notices, so new work runs without recovery tracking');
+  }
+
   private start(id: string, rawTool: unknown, event: string | null, now: number, description?: unknown): void {
     const task = this.get(id, now);
     if (task.state !== 'running') task.attempt += 1;

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

@@ -4,9 +4,9 @@ import type { Inbox, Unanswered, Uuid } from './inbox.js';
 import type { SessionStore } from './session-store.js';
 import { completedCommand, startedCommand, uuidsOf } from './session-watch.js';
 import { TaskLedger } from './task-ledger.js';
-import { TASK_LIMIT, type SavedTask } from './task-state.js';
+import { NOTICE_DELIVERIES, TASK_LIMIT, type SavedTask } from './task-state.js';
 
-const DELAYS = [30_000, 120_000, 300_000];
+const DELAYS = [30_000, 120_000, 300_000] as const;
 const marker = (token: string): string => `[metro-task-handled:${token}]`;
 interface Delivery { uuid: Uuid; tokens: string[]; consumed: boolean; completed?: boolean }
 
@@ -159,7 +159,7 @@ export class TaskRecovery {
 
   private eligible(task: SavedTask): boolean {
     const notice = task.notice;
-    if (notice === null || notice.deliveries >= DELAYS.length) return false;
+    if (notice === null || notice.deliveries >= NOTICE_DELIVERIES) return false;
     return ![...this.deliveries.values()].some((delivery) => delivery.completed !== true && delivery.tokens.includes(notice.token));
   }
 

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

@@ -5,6 +5,7 @@ import { activityName } from './activity-tasks.js';
 import type { Uuid } from './inbox.js';
 
 export const TASK_LIMIT = 200;
+export const NOTICE_DELIVERIES = 3;
 const STATES = ['running', 'completed', 'failed', 'stopped', 'interrupted'] as const;
 const REASONS = ['task_error', 'rate_limit', 'worker_restart', 'interrupted', 'provider_error'] as const;
 export type TaskReason = (typeof REASONS)[number];
@@ -57,6 +58,9 @@ function task(raw: unknown): raw is SavedTask {
   return integer(raw.attempt) && integer(raw.updatedAt) && STATES.some((state) => state === raw.state) && notice(raw.notice);
 }
 
+export const exhausted = (task: SavedTask): boolean =>
+  task.state !== 'running' && task.notice !== null && task.notice.deliveries >= NOTICE_DELIVERIES && task.notice.offered === undefined;
+
 export const sdkTask = (task: SavedTask): boolean => !/^(?:input|turn):/.test(task.id);
 
 export function savedTasks(raw: unknown): SavedTask[] {