@stage-labs/metro 0.1.0-beta.215 → 0.1.0-beta.217

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.215",
+  "version": "0.1.0-beta.217",
   "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.215",
+  "version": "0.1.0-beta.217",
   "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/agents/accounts-api.ts

@@ -228,7 +228,7 @@ async function applied(deps: AccountApiDeps): Promise<boolean> {
     await deps.reloadAgents();
     return true;
   } catch (err) {
-    log.warn({ err: errMsg(err) }, 'account-api: allowlist reload failed, the change lands at the next boot');
+    log.warn({ err: errMsg(err) }, 'account-api: reload failed, the change lands at the next boot');
     return false;
   }
 }
@@ -275,7 +275,7 @@ async function handleEnabled(
     station: target.station,
     accountId: target.accountId,
     enabled,
-    activated: await activate(deps, target.station),
+    activated: await applied(deps),
   });
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/agents/map.ts

@@ -42,6 +42,11 @@ export function setDisabledAccounts(ids: Set<string>): void {
 
 export const accountEnabled = (station: string, accountId: string): boolean => !disabledAccounts.has(mapKey(station, accountId));
 
+export function lineReceives(line: string): boolean {
+  const a = accountFromLine(line);
+  return a === undefined || accountEnabled(a.station, a.accountId);
+}
+
 export function accountFromLine(
   line: string,
 ): { station: string; accountId: string } | undefined {

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

@@ -2,7 +2,7 @@ import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { z } from 'zod';
 import type { InboundRelay } from '../channels/inbound.js';
 import { holdPrompt, type Behavior } from '../approvals/pending.js';
-import { approversForLine } from '../agents/map.js';
+import { approversForLine, lineReceives } from '../agents/map.js';
 import { metroCall } from './ctx.js';
 import { promptBody } from './permission-prompt.js';
 
@@ -46,6 +46,10 @@ function relayLine(deps: PermissionRelayDeps, requestId: string): string | undef
     deps.log('permission_request: known line is outside the agent scope, held for the page only', requestId);
     return undefined;
   }
+  if (!lineReceives(line)) {
+    deps.log('permission_request: the known chat does not receive messages now, so no answer can arrive; held for the page only', requestId);
+    return undefined;
+  }
   if (approversForLine(line).length === 0) {
     deps.log('permission_request: nobody on that chat may approve, held for the page only', requestId);
     return undefined;

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

@@ -22,7 +22,7 @@ import {
   type MetroEvent,
 } from '@metro-labs/core/events';
 import type { TrainEvent } from '@metro-labs/core/trains/protocol';
-import { agentForLine, agentIdForLine } from '../agents/map.js';
+import { agentForLine, agentIdForLine, lineReceives } from '../agents/map.js';
 import type { Endpoint } from '@metro-labs/core/endpoints';
 import { findEndpointByWebhookId, listEndpoints, tokenMatches } from '../stations/webhook-endpoints.js';
 import { attachmentEventUrl, handleAttachRequest, webhookPort } from '../files/attach-serve.js';
@@ -107,6 +107,10 @@ type Emit = (entry: MetroEvent) => void;
 export function makeEmit(dedupSeq?: DedupSeq): Emit {
   const tracker = dedupSeq ?? makeDedupSeq();
   return function emit(entry: MetroEvent): void {
+    if (!lineReceives(entry.line)) {
+      log.debug({ line: entry.line }, 'emit: dropped, this channel does not receive messages');
+      return;
+    }
     const seq = tracker.admit(entry);
     if (seq === null) return;
     const enriched: MetroEvent = withAttachmentUrl({

package/runtime/node_modules/@metro-labs/daemon/src/stations/materialize.ts

@@ -165,10 +165,7 @@ function writeStations(list: LoadedAgent[]): WrittenStations {
       }
       map[`${a.station}/${a.id}`] = agent.id;
       if (a.allowlist) allow[`${a.station}/${a.id}`] = a.allowlist;
-      if (a.enabled === false) {
-        disabled.add(`${a.station}/${a.id}`);
-        continue;
-      }
+      if (a.enabled === false) disabled.add(`${a.station}/${a.id}`);
       const cur = byStation.get(a.station);
       if (cur) cur.push(a);
       else byStation.set(a.station, [a]);

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.215"
+  "version": "0.1.0-beta.217"
 }