@stage-labs/metro 0.1.0-beta.214 → 0.1.0-beta.216

package/dist/background.js

@@ -0,0 +1,123 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+export const AGENT_VIEW_OFF = 'CLAUDE_CODE_DISABLE_AGENT_VIEW';
+const STOP_MS = 30_000;
+const SETTLE_MS = 5_000;
+const POLL_MS = 250;
+const given = (value) => value !== undefined && value.trim() !== '' ? value.trim() : undefined;
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+export const keepInSession = (env) => given(env[AGENT_VIEW_OFF]) === undefined ? { ...env, [AGENT_VIEW_OFF]: '1' } : env;
+const claudeDir = (env = process.env) => given(env.CLAUDE_CONFIG_DIR) ?? join(given(env.HOME) ?? homedir(), '.claude');
+export const projectDir = (dir, cwd) => join(dir, 'projects', cwd.replace(/[^A-Za-z0-9]/g, '-'));
+function startTime(pid) {
+    try {
+        const stat = readFileSync(`/proc/${String(pid)}/stat`, 'utf8');
+        return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function processAlive(pid, procStart) {
+    try {
+        process.kill(pid, 0);
+    }
+    catch (err) {
+        if (err.code !== 'EPERM')
+            return false;
+    }
+    const started = procStart === undefined ? null : startTime(pid);
+    return started === null || started === procStart;
+}
+function backgroundEntry(file, alive) {
+    try {
+        const raw = JSON.parse(readFileSync(file, 'utf8'));
+        if (!isRecord(raw) || typeof raw.pid !== 'number' || typeof raw.sessionId !== 'string')
+            return null;
+        if (raw.kind === 'interactive' || typeof raw.kind !== 'string')
+            return null;
+        return alive(raw.pid, typeof raw.procStart === 'string' ? raw.procStart : undefined) ? raw.sessionId : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function liveBackground(sessions, alive = processAlive) {
+    if (!existsSync(sessions))
+        return new Set();
+    const ids = readdirSync(sessions)
+        .filter((name) => name.endsWith('.json'))
+        .map((name) => backgroundEntry(join(sessions, name), alive));
+    return new Set(ids.filter((id) => id !== null));
+}
+function newestFirst(dir) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.endsWith('.jsonl'))
+        .map((name) => ({ path: join(dir, name), at: statSync(join(dir, name)).mtimeMs }))
+        .sort((a, b) => b.at - a.at)
+        .map((file) => file.path);
+}
+function continuedIn(text) {
+    const last = text.split('\n').findLast((line) => line.includes('"type":"continued-in"'));
+    if (last === undefined)
+        return null;
+    try {
+        const record = JSON.parse(last);
+        return isRecord(record) && typeof record.continuedInSessionId === 'string' ? record.continuedInSessionId : null;
+    }
+    catch {
+        return null;
+    }
+}
+const HAS_TURN = /"type":"(user|assistant)"/;
+export function heldConversation(dir, live) {
+    if (live.size === 0)
+        return null;
+    for (const file of newestFirst(dir)) {
+        const text = readFileSync(file, 'utf8');
+        if (!HAS_TURN.test(text))
+            continue;
+        const moved = continuedIn(text);
+        if (moved !== null && live.has(moved))
+            return moved;
+        if (!live.has(basename(file, '.jsonl')))
+            return null;
+    }
+    return null;
+}
+function stopBackground(id, env = process.env) {
+    const run = spawnSync('claude', ['stop', id], { env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: STOP_MS });
+    if (run.error !== undefined)
+        return { ok: false, detail: run.error.message };
+    const said = `${run.stdout}${run.stderr}`.trim().split('\n').at(-1) ?? '';
+    return { ok: run.status === 0, detail: said === '' ? `exit ${String(run.status)}` : said };
+}
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+async function settled(sessions, held, alive, ms) {
+    if (!liveBackground(sessions, alive).has(held))
+        return true;
+    if (ms <= 0)
+        return false;
+    await sleep(POLL_MS);
+    return settled(sessions, held, alive, ms - POLL_MS);
+}
+export async function takeBackConversation(deps = {}) {
+    const env = deps.env ?? process.env;
+    const alive = deps.alive ?? processAlive;
+    const dir = claudeDir(env);
+    const sessions = join(dir, 'sessions');
+    const held = heldConversation(projectDir(dir, deps.cwd ?? process.cwd()), liveBackground(sessions, alive));
+    if (held === null)
+        return null;
+    const id = held.slice(0, 8);
+    const stopped = (deps.stop ?? stopBackground)(id, env);
+    if (!stopped.ok || !(await settled(sessions, held, alive, deps.settleMs ?? SETTLE_MS)))
+        return `the conversation is held by the Claude Code background session ${id} and it could not be stopped (${stopped.detail}), so Claude Code will refuse to continue it: run claude stop ${id}`;
+    return `the conversation had moved to the Claude Code background session ${id}, where no chat reaches it; stopped that session (its conversation is kept) and continuing it here`;
+}

package/dist/claude.js

@@ -6,6 +6,7 @@ import { settingsConflicts, settingsFiles } from './claude-settings.js';
 import { localAgent } from './local.js';
 import { PROVIDER_FLAGS } from './provider-flags.js';
 import { localPort, localUrl } from './runtime.js';
+import { keepInSession, takeBackConversation } from './background.js';
 const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
 const FRESH_PROMPT_FLAGS = ['--system-prompt-snapshot', 'off'];
 const PERMISSION_MODE_FLAG = { auto: 'auto', bypass: 'bypassPermissions' };
@@ -132,7 +133,22 @@ function gatewayLaunchEnv(key, port) {
         process.stderr.write("metro claude: skipped Claude Code's first-run setup, since it already has a credential here\n");
     return env;
 }
+const continues = (args) => args.includes('-c') || args.includes('--continue');
+async function reclaimConversation(extra) {
+    if (!continues(extra))
+        return;
+    try {
+        const note = await takeBackConversation();
+        if (note !== null)
+            process.stderr.write(`metro claude: ${note}\n`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`metro claude: could not check for a Claude Code background session holding the conversation (${message})\n`);
+    }
+}
 export async function launchClaude(extra) {
+    await reclaimConversation(extra);
     const decision = await verdict();
     const port = localPort();
     const mcp = mcpConfigFor(await servedKey(decision), port);
@@ -143,9 +159,9 @@ export async function launchClaude(extra) {
     try {
         if ('skip' in decision) {
             process.stderr.write(`metro claude: ${decision.skip}\n`);
-            return await runClaude(claudeArgs(extra, mcp?.path, mode, prompt), channelEnv(process.env));
+            return await runClaude(claudeArgs(extra, mcp?.path, mode, prompt), keepInSession(channelEnv(process.env)));
         }
-        return await runClaude(claudeArgs(extra, mcp?.path, mode, prompt), channelEnv(gatewayLaunchEnv(decision.key, port)));
+        return await runClaude(claudeArgs(extra, mcp?.path, mode, prompt), keepInSession(channelEnv(gatewayLaunchEnv(decision.key, port))));
     }
     finally {
         mcp?.cleanup();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.214",
+  "version": "0.1.0-beta.216",
   "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.214",
+  "version": "0.1.0-beta.216",
   "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/daemon/src/boot/boot.ts

@@ -27,7 +27,7 @@ import { runningAsRoot } from '../metro-user/privilege.js';
 import { provisionAgentUser } from '../agent-user/provision.js';
 import { applyVault } from '../vault/index.js';
 import { unwatchSession, watchSession } from '../claude/session.js';
-import { tryClaudeSetup } from '../claude/setup.js';
+import { liveEvents, tryClaudeSetup } from '../claude/setup.js';
 import { applyLocalOwner } from './local-owner.js';
 import { installBearerSessions } from '../routes/bearer.js';
 import { ensureLocalAgent, localOwner } from '../agents/file-admin.js';
@@ -96,7 +96,7 @@ async function syncStations(station: StationName): Promise<void> {
   }
 }
 
-function sessionApis(): SessionApis {
+function sessionApis(setLiveEvents: (on: boolean) => void): SessionApis {
   return localSessionApis({
       syncStations,
       reloadAgents: async () => {
@@ -114,6 +114,7 @@ function sessionApis(): SessionApis {
       capabilities: accountStationCapabilities,
       toolGroups: stationToolGroups,
       prepareAccount,
+      liveEvents: setLiveEvents,
     });
 }
 
@@ -129,10 +130,10 @@ installBearerSessions(agentsDir(), localOwner);
   await materializeFrom(fileSource);
   forgetOrphans(knownAccounts());
   supervisor.start();
-  const metroMcp = await createMetroMcp();
+  const metroMcp = await createMetroMcp({ liveEvents: liveEvents() });
   webhookServer = await startWebhookServer(
     emit,
-    sessionApis(),
+    sessionApis(metroMcp.setLiveEvents),
     metroMcp.httpHandler,
     true,
   );

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

@@ -76,6 +76,11 @@ export class InboundRelay {
     return this.lastLine;
   }
 
+  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);

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

@@ -24,7 +24,9 @@ import {
   claudeSetupStatus,
   ensureClaudeSetup,
   isPermissionMode,
+  liveEvents,
   permissionMode,
+  setLiveEvents,
   setPermissionMode,
   setPrivacy,
   setSystemPrompt,
@@ -70,6 +72,7 @@ export interface ClaudeApiDeps {
   session?: SessionDeps;
   setup?: SetupDeps;
   version?: VersionDeps;
+  liveEvents?: (on: boolean) => void;
 }
 
 function projectOf(query: URLSearchParams): string {
@@ -153,6 +156,7 @@ interface SetupChange {
   privacy?: boolean;
   permissionMode?: PermissionMode;
   systemPrompt?: string;
+  liveEvents?: boolean;
 }
 
 function promptChange(raw: unknown): string | undefined {
@@ -162,9 +166,9 @@ function promptChange(raw: unknown): string | undefined {
   return raw;
 }
 
-function privacyChange(raw: unknown): boolean | undefined {
+function flagChange(raw: unknown, name: string): boolean | undefined {
   if (raw === undefined) return undefined;
-  if (typeof raw !== 'boolean') throw new ApiError('privacy must be true or false', 400);
+  if (typeof raw !== 'boolean') throw new ApiError(`${name} must be true or false`, 400);
   return raw;
 }
 
@@ -176,14 +180,16 @@ function modeChange(raw: unknown): PermissionMode | undefined {
 
 function setupChange(body: unknown): SetupChange {
   if (!isRecord(body)) throw new ApiError('a body is required', 400);
-  const privacy = privacyChange(body.privacy);
+  const privacy = flagChange(body.privacy, 'privacy');
   const permissionMode = modeChange(body.permissionMode);
   const systemPrompt = promptChange(body.systemPrompt);
-  if (privacy === undefined && permissionMode === undefined && systemPrompt === undefined) throw new ApiError('nothing to change', 400);
+  const liveEvents = flagChange(body.liveEvents, 'liveEvents');
+  if (privacy === undefined && permissionMode === undefined && systemPrompt === undefined && liveEvents === undefined) throw new ApiError('nothing to change', 400);
   return {
     ...(privacy === undefined ? {} : { privacy }),
     ...(permissionMode === undefined ? {} : { permissionMode }),
     ...(systemPrompt === undefined ? {} : { systemPrompt }),
+    ...(liveEvents === undefined ? {} : { liveEvents }),
   };
 }
 
@@ -200,9 +206,16 @@ function restartsSession(change: SetupChange, agents: string | undefined): boole
   return restart;
 }
 
+function applyLiveEvents(on: boolean, deps: ClaudeApiDeps): void {
+  const agents = deps.setup?.agents;
+  if (on !== liveEvents(agents)) setLiveEvents(on, agents);
+  deps.liveEvents?.(on);
+}
+
 function applySetupChange(change: SetupChange, deps: ClaudeApiDeps): void {
   const setup = deps.setup ?? {};
   if (change.privacy !== undefined) setPrivacy(change.privacy, setup.agents);
+  if (change.liveEvents !== undefined) applyLiveEvents(change.liveEvents, deps);
   if (restartsSession(change, setup.agents) && sessionRunning(deps.session?.tmux ?? 'tmux')) stopSession(deps.session ?? {});
   ensureClaudeSetup(setup);
 }

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

@@ -64,6 +64,7 @@ export interface SetupStatus {
   privacy: boolean;
   permissionMode: PermissionMode;
   systemPrompt: string;
+  liveEvents: boolean;
   guard: 'plugin';
   worker: boolean;
   skill: boolean;
@@ -103,6 +104,12 @@ export function setPermissionMode(mode: PermissionMode, agents = agentsDir()): v
   writeState(agents, { permissionMode: mode });
 }
 
+export const liveEvents = (agents = agentsDir()): boolean => readState(agents).liveEvents !== false;
+
+export function setLiveEvents(on: boolean, agents = agentsDir()): void {
+  writeState(agents, { liveEvents: on });
+}
+
 const promptPath = (agents: string): string => join(agents, SYSTEM_PROMPT_FILE);
 
 export function systemPrompt(agents = agentsDir()): string {
@@ -213,13 +220,15 @@ export function ensureClaudeSetup(deps: SetupDeps = {}): SetupReport {
 
 export function claudeSetupStatus(deps: SetupDeps = {}): SetupStatus {
   const dir = deps.dir ?? claudeDir();
+  const agents = deps.agents ?? agentsDir();
   const settings = readSettings(join(dir, 'settings.json'));
   const env = settings !== null && isRecord(settings.env) ? settings.env : {};
   const days = settings?.cleanupPeriodDays;
   return {
-    privacy: privacyEnabled(deps.agents ?? agentsDir()),
-    permissionMode: permissionMode(deps.agents ?? agentsDir()),
-    systemPrompt: systemPrompt(deps.agents ?? agentsDir()),
+    privacy: privacyEnabled(agents),
+    permissionMode: permissionMode(agents),
+    systemPrompt: systemPrompt(agents),
+    liveEvents: liveEvents(agents),
     guard: 'plugin',
     worker: existsSync(workerPath(dir)),
     skill: existsSync(skillPath(dir)),

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

@@ -87,17 +87,18 @@ async function serveGet(
       session.bindSink(sink);
     },
   });
-  if (served) session.channel.replayMissed();
+  if (served) session.replayMissed();
 }
 
 let activeSlot: SessionSlot | undefined;
 
-export async function createMetroMcp(): Promise<{
+export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Promise<{
   httpHandler: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
   startInbound: () => void;
+  setLiveEvents: (on: boolean) => void;
 }> {
   await activeSlot?.close();
-  const slot = new SessionSlot();
+  const slot = new SessionSlot(options.liveEvents);
   activeSlot = slot;
 
   const httpHandler = async (
@@ -130,8 +131,16 @@ export async function createMetroMcp(): Promise<{
 
   const startInbound = (): void => {
     slot.startInbound();
-    channelLog('inbound: bus subscription (bounded replay on reconnect)');
+    channelLog(
+      slot.liveEvents
+        ? 'inbound: bus subscription (bounded replay on reconnect)'
+        : 'inbound: live events are off, nothing is pushed to the session',
+    );
   };
 
-  return { httpHandler, startInbound };
+  const setLiveEvents = (on: boolean): void => {
+    slot.setLive(on);
+  };
+
+  return { httpHandler, startInbound, setLiveEvents };
 }

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

@@ -28,10 +28,15 @@ export interface PermissionRelayDeps {
   mcp: Server;
   relay: InboundRelay;
   inScope: (line: string) => boolean;
+  live: () => boolean;
   log: (...a: unknown[]) => void;
 }
 
 function relayLine(deps: PermissionRelayDeps, requestId: string): string | undefined {
+  if (!deps.live()) {
+    deps.log('permission_request: live events are off, so no chat answer can arrive; held for the page only', requestId);
+    return undefined;
+  }
   const line = deps.relay.knownLine;
   if (!line) {
     deps.log('permission_request: no known line, held for the page only', requestId);

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

@@ -8,16 +8,38 @@ export class SessionSlot {
   private session: McpSession | undefined;
   private readonly ledger = newReplayLedger();
   private started = false;
+  private live: boolean;
+
+  constructor(live = true) {
+    this.live = live;
+  }
 
   get current(): McpSession | undefined {
     return this.session;
   }
 
+  get liveEvents(): boolean {
+    return this.live;
+  }
+
   startInbound(): void {
     if (this.started) return;
     this.started = true;
     if (this.ledger.startAt < 0) this.ledger.startAt = currentBusSeq();
-    this.session?.startChannel();
+    if (this.live) this.session?.startChannel();
+  }
+
+  setLive(on: boolean): void {
+    if (this.live === on) return;
+    this.live = on;
+    channelLog('inbound: live events', on ? 'on' : 'off');
+    if (!on) {
+      this.session?.stopChannel();
+      this.session?.relay.dropPending();
+      return;
+    }
+    this.ledger.startAt = currentBusSeq();
+    if (this.started) this.session?.startChannel();
   }
 
   async open(
@@ -32,12 +54,13 @@ export class SessionSlot {
       scope: allowedAgents(identity),
       adopted: adoptId !== undefined,
       ledger: this.ledger,
+      live: () => this.live,
       onClosed: (s) => {
         if (this.session === s) this.session = undefined;
       },
     });
     this.session = session;
-    if (this.started) session.startChannel();
+    if (this.started && this.live) session.startChannel();
     channelLog('session: opened', 'id', id, 'adopted', adoptId !== undefined);
     return session;
   }

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

@@ -52,6 +52,7 @@ export interface SessionInit {
   scope: Set<string>;
   adopted: boolean;
   ledger: ReplayLedger;
+  live: () => boolean;
   onClosed: (session: McpSession) => void;
 }
 
@@ -63,6 +64,7 @@ export class McpSession {
   readonly server: Server;
   readonly relay: InboundRelay;
   readonly channel: ChannelRelay;
+  readonly live: () => boolean;
   private sink: RawGetSink | undefined;
   private unsubscribe: (() => void) | undefined;
   private closed = false;
@@ -73,6 +75,7 @@ export class McpSession {
   private constructor(init: SessionInit) {
     this.id = init.id;
     this.scope = init.scope;
+    this.live = init.live;
     this.issuedSchema = init.adopted ? undefined : toolSchemaSignature();
     this.onClosed = init.onClosed;
     this.eventStore = new BoundedEventStore();
@@ -114,12 +117,13 @@ export class McpSession {
       mcp: this.server,
       relay: this.relay,
       inScope: (line) => this.inScope(line),
+      live: this.live,
       log: channelLog,
     });
     this.channel = new ChannelRelay({
       relay: this.relay,
       log: channelLog,
-      inScope: (line) => this.inScope(line),
+      inScope: (line) => this.live() && this.inScope(line),
       ledger: init.ledger,
     });
   }
@@ -151,6 +155,15 @@ export class McpSession {
     this.unsubscribe ??= this.channel.start();
   }
 
+  stopChannel(): void {
+    this.unsubscribe?.();
+    this.unsubscribe = undefined;
+  }
+
+  replayMissed(): void {
+    if (this.live()) this.channel.replayMissed();
+  }
+
   bindSink(sink: RawGetSink | undefined): void {
     this.sink = sink;
     if (sink !== undefined) this.announceToolSchema();
@@ -195,8 +208,7 @@ export class McpSession {
     this.onClosed(this);
     forgetPromptsOf(this.server);
     this.dropStream();
-    this.unsubscribe?.();
-    this.unsubscribe = undefined;
+    this.stopChannel();
     await this.server.close().catch(() => undefined);
   }
 }

package/runtime/node_modules/@metro-labs/daemon/src/routes/local-mode.ts

@@ -55,6 +55,7 @@ export interface LocalModeDeps {
   capabilities: AgentApiDeps['capabilities'];
   toolGroups?: AgentApiDeps['toolGroups'];
   prepareAccount: AccountApiDeps['prepareAccount'];
+  liveEvents?: (on: boolean) => void;
 }
 
 function attachSessions(deps: LocalModeDeps): AttachSessions {
@@ -192,7 +193,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     bundleApi: bundleApi(deps),
     connectorApi,
     relayApi,
-    claudeApi: {},
+    claudeApi: { liveEvents: deps.liveEvents },
     updateApi: { restart: deps.restart },
     controlApi: { restart: deps.restart, stop: deps.stop },
     ownerApi: { setOwner: (owner) => setLocalOwner(owner) },

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.214"
+  "version": "0.1.0-beta.216"
 }