@stage-labs/metro 0.1.0-beta.306 → 0.1.0-beta.308

package/dist/native-recovery.js

@@ -1,164 +0,0 @@
-import { createHash } from 'node:crypto';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { claudeDir, projectDir, resumeSessionId } from './background.js';
-import { scanNative } from './native-recovery-scan.js';
-import { nativeToken, NATIVE_NOTICE_MAX, NATIVE_TASK_MAX, readNativeState, saveNativeState, withNativeStateLock } from './native-recovery-state.js';
-const hash = (...parts) => createHash('sha256').update(JSON.stringify(parts)).digest('hex');
-const taskId = (owner, source, tool) => hash(owner, source ?? '', tool);
-const RETRY_MS = [0, 60_000, 10 * 60_000];
-const PROMPT_NOTICES = 8;
-const taskReason = (task) => task.state === 'started' ? 'interrupted' : task.state === 'failed' ? 'failed' : task.state === 'restarted' ? 'restarted' : null;
-function agentResult(task, outcome) {
-    if (nativeToken(outcome.agentId))
-        task.agent = outcome.agentId;
-    if (outcome.status === 'completed')
-        task.state = 'completed';
-    else if (outcome.status === 'async_launched')
-        task.state = 'started';
-}
-function messageResult(task, outcome) {
-    if (outcome.success === true && nativeToken(outcome.resumedAgentId)) {
-        task.agent = outcome.resumedAgentId;
-        task.state = 'started';
-    }
-    else if (outcome.success === true && outcome.resumedAgentId === undefined)
-        task.state = 'completed';
-    else if (outcome.success === false)
-        task.state = 'failed';
-}
-function result(task, event) {
-    if (event.at < task.updatedAt || event.receipt === task.receipt)
-        return;
-    if (event.failed)
-        task.state = 'failed';
-    else if (event.outcome !== null) {
-        if (task.kind === 'Agent')
-            agentResult(task, event.outcome);
-        else
-            messageResult(task, event.outcome);
-    }
-    task.receipt = event.receipt;
-    task.updatedAt = event.at;
-}
-function acknowledge(state, event) {
-    const notice = state.notices.find((row) => row.id === event.id);
-    if (notice !== undefined && notice.deliveredAt !== null && event.at >= notice.deliveredAt)
-        notice.acknowledgedAt = event.at;
-}
-function notification(state, event) {
-    const candidates = state.tasks.filter((row) => row.source === event.source && row.at <= event.at
-        && (event.tool === null ? row.agent === event.agent : row.tool === event.tool && (row.agent === null || row.agent === event.agent)));
-    if (candidates.length > 1)
-        return false;
-    const task = candidates[0];
-    if (task !== undefined && event.at >= task.updatedAt) {
-        task.agent = event.agent;
-        task.state = event.state;
-        task.receipt = event.receipt;
-        task.updatedAt = event.at;
-    }
-    return true;
-}
-function applyEvent(state, event) {
-    if (event.type === 'ack') {
-        acknowledge(state, event);
-        return true;
-    }
-    if (event.type === 'notification')
-        return notification(state, event);
-    const id = taskId(state.owner, event.source, event.tool);
-    const task = state.tasks.find((row) => row.id === id);
-    if (event.type === 'result') {
-        if (task !== undefined)
-            result(task, event);
-        return true;
-    }
-    if (task !== undefined)
-        return true;
-    if (state.tasks.length >= NATIVE_TASK_MAX)
-        prune(state);
-    if (state.tasks.length >= NATIVE_TASK_MAX)
-        return false;
-    state.tasks.push({ id, source: event.source, tool: event.tool, kind: event.kind, agent: null, at: event.at, updatedAt: event.at, state: 'started', receipt: event.receipt });
-    return true;
-}
-function addNotice(state, task, reason, gap = 'incomplete') {
-    const id = hash(state.owner, task?.id ?? 'scan', task?.receipt ?? gap, reason);
-    if (state.notices.some((row) => row.id === id))
-        return;
-    if (state.notices.length >= NATIVE_NOTICE_MAX)
-        throw new Error('Native recovery has too many retained notices. Saved state has not been overwritten.');
-    state.notices.push({ id, task: task?.id ?? null, reason, attempts: 0, deliveredAt: null, acknowledgedAt: null });
-}
-function prune(state) {
-    const pending = new Set(state.notices.filter((row) => row.acknowledgedAt === null).map((row) => row.task));
-    const acknowledged = new Set(state.notices.filter((row) => row.acknowledgedAt !== null).map((row) => row.id));
-    const removable = state.tasks.filter((row) => !pending.has(row.id) && (taskReason(row) === null || acknowledged.has(hash(state.owner, row.id, row.receipt, taskReason(row) ?? ''))))
-        .sort((a, b) => a.updatedAt - b.updatedAt);
-    const removed = new Set(removable.slice(0, Math.max(0, state.tasks.length - NATIVE_TASK_MAX / 2)).map((row) => row.id));
-    state.tasks = state.tasks.filter((row) => !removed.has(row.id));
-    state.notices = state.notices.filter((row) => row.task === null || !removed.has(row.task));
-}
-function noticeLine(state, notice) {
-    const task = state.tasks.find((row) => row.id === notice.task);
-    const subject = task === undefined ? 'Native task history' : `${task.kind} receipt ${task.tool}${task.agent === null ? '' : `, worker ${task.agent}`}`;
-    const facts = {
-        interrupted: 'has no terminal receipt. Work may have run before interruption; its outcome is unknown.',
-        failed: 'reported failure. Earlier side effects may already have happened.',
-        restarted: 'was stopped by worker restart, not explicit user cancellation.',
-        incomplete: 'could not be fully checked within the bounded local scan. Other unfinished work may exist.',
-    };
-    return `${subject} ${facts[notice.reason]}\nAfter taking responsibility for this notice, emit a standalone assistant text block exactly: METRO_RECOVERY_ACK ${notice.id}`;
-}
-function promptFor(state, notices) {
-    return [
-        'Metro native recovery notice. This is recovery bookkeeping, not a new user task or permission to repeat actions.',
-        `Owner conversation: ${state.owner}. Native worker routing may have lost ownership metadata; this notice does not repair it.`,
-        'Review the affected work and current evidence, using a read-only worker if needed. Do not blindly rerun a task, resend a message, or repeat another side effect. Acknowledge awareness only; acknowledgment is not proof of successful completion. Do not post these bookkeeping markers to chat.',
-        ...notices.map((notice) => noticeLine(state, notice)),
-    ].join('\n\n');
-}
-function prepare(state, root) {
-    const scan = scanNative(root, state.owner, state.files, state.tasks);
-    prune(state);
-    for (const event of scan.events)
-        if (!applyEvent(state, event))
-            scan.gaps.push('unresolved-receipts');
-    state.files = scan.files;
-    for (const task of state.tasks) {
-        const reason = taskReason(task);
-        if (reason !== null)
-            addNotice(state, task, reason);
-    }
-    for (const gap of scan.gaps)
-        addNotice(state, null, 'incomplete', gap);
-}
-function isDue(notice, now) {
-    return notice.acknowledgedAt === null && notice.attempts < RETRY_MS.length
-        && (notice.deliveredAt === null || now - notice.deliveredAt >= (RETRY_MS[notice.attempts] ?? Infinity));
-}
-function locations(owner, deps) {
-    const env = deps.env ?? process.env;
-    const given = env.HOME?.trim();
-    const home = resolve(given === '' ? homedir() : given ?? homedir());
-    return { path: join(home, '.metro', 'native-recovery', `${owner}.json`), root: projectDir(claudeDir(env), deps.cwd ?? process.cwd()) };
-}
-export function nativeRecoveryArgs(extra, deps = {}) {
-    const owner = resumeSessionId(extra);
-    if (extra.length !== 2 || owner === undefined || (extra[0] !== '--resume' && extra[0] !== '-r'))
-        return extra;
-    const { path, root } = locations(owner, deps);
-    return withNativeStateLock(path, () => {
-        const state = readNativeState(path, owner);
-        prepare(state, root);
-        const now = deps.now ?? Date.now();
-        const due = state.notices.filter((row) => isDue(row, now)).slice(0, PROMPT_NOTICES);
-        for (const notice of due) {
-            notice.attempts += 1;
-            notice.deliveredAt = now;
-        }
-        saveNativeState(path, state);
-        return due.length === 0 ? extra : [...extra, promptFor(state, due)];
-    });
-}

package/dist/onboarding.js

@@ -1,44 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-const FILE = '.claude.json';
-const FLAG = 'hasCompletedOnboarding';
-const given = (value) => value !== undefined && value.trim() !== '' ? value.trim() : undefined;
-export function claudeConfigPath(env = process.env) {
-    return join(given(env.CLAUDE_CONFIG_DIR) ?? given(env.HOME) ?? homedir(), FILE);
-}
-function readConfig(path) {
-    if (!existsSync(path))
-        return {};
-    try {
-        const parsed = JSON.parse(readFileSync(path, 'utf8'));
-        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function markOnboardingDone(path = claudeConfigPath()) {
-    const config = readConfig(path);
-    if (config === null)
-        return 'unreadable';
-    if (config[FLAG] === true)
-        return 'already';
-    writeFileSync(path, `${JSON.stringify({ ...config, [FLAG]: true }, null, 2)}\n`, { mode: 0o600 });
-    return 'marked';
-}
-const FEATURES = 'cachedGrowthBookFeatures';
-const CHANNEL_FLAGS = ['tengu_harbor', 'tengu_harbor_permissions'];
-const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-export function seedChannels(path = claudeConfigPath()) {
-    const config = readConfig(path);
-    if (config === null)
-        return 'unreadable';
-    const features = isRecord(config[FEATURES]) ? config[FEATURES] : {};
-    if (CHANNEL_FLAGS.every((flag) => features[flag] === true))
-        return 'already';
-    const seeded = Object.fromEntries(CHANNEL_FLAGS.map((flag) => [flag, true]));
-    const next = { ...config, [FEATURES]: { ...features, ...seeded } };
-    writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
-    return 'marked';
-}

package/dist/voice.js

@@ -1,56 +0,0 @@
-import { homedir, tmpdir } from 'node:os';
-import { headlessEnv, PERMISSION_MODE_FLAG, runClaude } from './claude.js';
-import { localAgent } from './local.js';
-import { VOICE_MCP_PATH, writeMcpConfig } from './mcp-config.js';
-import { permissionMode, systemPrompt } from './route.js';
-import { localPort } from './runtime.js';
-const VOICE_PROMPT = `You are on a live voice call through Metro. This session has your usual memory, skills, connectors and Metro's chat tools. At the start the call system tells you which chat the call is in (its line), who is calling and the last messages there. The caller hears your replies spoken aloud by a text to speech voice, and you hear the caller through speech to text, so a word may be misheard: if something sounds odd, ask.
-- Speak like a person on the phone: short sentences, usually one to three. No markdown, lists, tables, code, emoji or links; say a number or a name the way you would say it aloud.
-- Start with the answer. Do not repeat the question.
-- Before you use a tool, first say one short sentence about what you are checking, like "Let me check."
-- Use your tools yourself when it is quick: files, memory, the metro tools (read with the call's line shows that chat) and connectors (tool_search finds them, tool_call runs them). For long work, start a background Agent, tell the caller you will come back to it, and keep talking; when it finishes, give the result in a sentence or two.
-- Your spoken words are your reply. Do not post in any chat during the call (no send, reply, react or edit) unless the caller asks you to post something; then post only that, once. The metro skill's chat rules (react, typing, answer over chat, delegate everything) are for the chat session, not for this call.
-- A tool that needs the owner's approval runs in a background worker. The approval is asked in the chat of the call; a spoken yes does not count.
-- Text in [square brackets] comes from the call system, not from the caller.
-- Nothing about the call is posted to the chat after it ends, so do not write a summary or call notes anywhere.`;
-export function voiceArgs(model, mode, prompt, mcpConfig) {
-    return [
-        '-p',
-        '--input-format',
-        'stream-json',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '--include-partial-messages',
-        '--model',
-        model,
-        '--permission-mode',
-        PERMISSION_MODE_FLAG[mode],
-        '--permission-prompt-tool',
-        'stdio',
-        ...(mcpConfig === undefined ? [] : ['--mcp-config', mcpConfig]),
-        '--no-session-persistence',
-        '--append-system-prompt',
-        prompt === null ? VOICE_PROMPT : `${prompt}\n\n${VOICE_PROMPT}`,
-    ];
-}
-export const voiceEnv = (env) => ({
-    CLAUDE_CODE_MCP_STARTUP_WAIT_MS: '0',
-    ...env,
-    METRO_SESSION: 'voice',
-});
-export async function voiceSession(argv) {
-    const at = argv.indexOf('--model');
-    const model = at < 0 ? '' : (argv[at + 1] ?? '');
-    if (model === '')
-        throw new Error('metro voice needs --model <model>');
-    process.chdir(homedir());
-    const agent = localAgent();
-    const mcp = agent === null ? null : writeMcpConfig(agent.key, localPort(), tmpdir(), VOICE_MCP_PATH);
-    try {
-        return await runClaude(voiceArgs(model, permissionMode(), systemPrompt(), mcp?.path), voiceEnv(await headlessEnv()));
-    }
-    finally {
-        mcp?.cleanup();
-    }
-}

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

@@ -1,56 +0,0 @@
-import { join } from 'node:path';
-import { errMsg, log } from '@metro-labs/core/log';
-import { existsSync, readdirNames, readRange } from '../agent-user/agent-fs.js';
-
-const HEAD_BYTES = 64 * 1024;
-const SKIPPED_RE = /Channel notifications skipped: ([^"\\]+)/;
-const REGISTERED = 'Channel notifications registered';
-const NAME_RE = /^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z\.jsonl$/;
-const SLACK_MS = 5_000;
-
-export interface ChannelState {
-  registered: boolean;
-  reason: string | null;
-}
-
-let state: ChannelState | null = null;
-
-export const channelState = (): ChannelState | null => state;
-
-export function forgetChannelState(): void {
-  state = null;
-}
-
-export const mcpLogDir = (home: string): string =>
-  join(home, '.cache', 'claude-cli-nodejs', home.replace(/[^a-zA-Z0-9]/g, '-'), 'mcp-logs-metro');
-
-const openedAt = (name: string): number => {
-  const m = NAME_RE.exec(name);
-  return m === null ? Number.NaN : Date.parse(`${m[1] ?? ''}T${m[2] ?? ''}:${m[3] ?? ''}:${m[4] ?? ''}.${m[5] ?? ''}Z`);
-};
-
-export function readChannelState(home: string, since: number): ChannelState | null {
-  const dir = mcpLogDir(home);
-  if (!existsSync(dir)) return null;
-  const newest = readdirNames(dir).filter((name) => openedAt(name) >= since - SLACK_MS).sort().at(-1);
-  if (newest === undefined) return null;
-  const head = readRange(join(dir, newest), 0, HEAD_BYTES).toString('utf8');
-  const skipped = SKIPPED_RE.exec(head);
-  if (skipped !== null) return { registered: false, reason: skipped[1]?.trim() ?? null };
-  return head.includes(REGISTERED) ? { registered: true, reason: null } : null;
-}
-
-export function noteChannelState(home: string, since: number): boolean {
-  let found: ChannelState | null;
-  try {
-    found = readChannelState(home, since);
-  } catch (err) {
-    log.debug({ err: errMsg(err) }, 'claude-session: could not read the metro MCP log of Claude Code');
-    return false;
-  }
-  if (found === null) return false;
-  state = found;
-  if (found.registered) log.info('claude-session: Claude Code registered the metro channel');
-  else log.error({ reason: found.reason }, 'claude-session: Claude Code skipped the metro channel, so chat messages do not reach the session');
-  return true;
-}

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

@@ -1,16 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { errMsg } from '@metro-labs/core/log';
-import { asAgent } from '../agent-user/user.js';
-
-export const CLAUDE_CODE_VERSION = '2.1.289';
-
-const INSTALL_TIMEOUT_MS = 5 * 60_000;
-const TAIL = 400;
-
-export function installClaudeCode(bin: string): void {
-  const run = spawnSync(...asAgent(bin, ['install', CLAUDE_CODE_VERSION]), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: INSTALL_TIMEOUT_MS });
-  const failed = `claude install ${CLAUDE_CODE_VERSION} failed`;
-  if (run.error !== undefined) throw new Error(`${failed}: ${errMsg(run.error)}`);
-  if (run.status === 0) return;
-  throw new Error(`${failed}: ${`${run.stderr}${run.stdout}`.trim().slice(-TAIL)}`);
-}

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

@@ -1,121 +0,0 @@
-import { execFile } from 'node:child_process';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg, log } from '@metro-labs/core/log';
-import { existsSync } from '../agent-user/agent-fs.js';
-import { removeHome } from '../agent-user/home-fs.js';
-import { agentUser, asAgent, claudeBin } from '../agent-user/user.js';
-import { agentsDir } from '../agents/files.js';
-import { readSetupState, writeSetupState } from './setup-state.js';
-
-const PLUGIN = 'metro@metro';
-const MARKETPLACE = 'metro';
-const DONE = 'pluginRemoved';
-const STEP_MS = 60_000;
-const SAID_MAX = 300;
-
-export interface Answer {
-  status: number;
-  stdout: string;
-  stderr: string;
-}
-
-export type Run = (args: string[]) => Promise<Answer>;
-
-export interface CleanupDeps {
-  run?: Run | null;
-  agents?: string;
-  leftover?: string | null;
-}
-
-export type CleanupOutcome = 'done' | 'clean' | 'removed' | 'skipped' | 'failed';
-
-export const claudeAt =
-  (bin: string): Run =>
-  (args) =>
-    new Promise((resolve) => {
-      execFile(...asAgent(bin, args), { encoding: 'utf8', timeout: STEP_MS, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
-        const code = (err as { code?: unknown } | null)?.code;
-        resolve({ status: err === null ? 0 : typeof code === 'number' ? code : 1, stdout, stderr });
-      });
-    });
-
-async function findClaude(): Promise<Run | null> {
-  const candidates = agentUser() === null ? ['claude', join(homedir(), '.local', 'bin', 'claude')] : [claudeBin()];
-  for (const bin of candidates) {
-    const run = claudeAt(bin);
-    if ((await run(['--version'])).status === 0) return run;
-  }
-  return null;
-}
-
-function listOf(stdout: string): Record<string, unknown>[] {
-  try {
-    const parsed: unknown = JSON.parse(stdout);
-    return Array.isArray(parsed) ? parsed.filter(isRecord) : [];
-  } catch {
-    return [];
-  }
-}
-
-async function listed(run: Run, args: string[], key: string, wanted: string): Promise<boolean | null> {
-  const answer = await run(args);
-  if (answer.status !== 0) {
-    log.warn({ args, said: `${answer.stderr}${answer.stdout}`.trim().slice(0, SAID_MAX) }, 'claude-plugin: claude could not list');
-    return null;
-  }
-  return listOf(answer.stdout).some((entry) => entry[key] === wanted);
-}
-
-async function step(run: Run, args: string[]): Promise<boolean> {
-  const answer = await run(args);
-  if (answer.status === 0) {
-    log.info({ args }, 'claude-plugin: removed what the old metro plugin left');
-    return true;
-  }
-  log.warn({ args, said: `${answer.stderr}${answer.stdout}`.trim().slice(0, SAID_MAX) }, 'claude-plugin: claude refused');
-  return false;
-}
-
-async function removeIfListed(run: Run, list: string[], key: string, wanted: string, remove: string[]): Promise<'gone' | 'removed' | 'failed'> {
-  const present = await listed(run, list, key, wanted);
-  if (present === null) return 'failed';
-  if (!present) return 'gone';
-  return (await step(run, remove)) ? 'removed' : 'failed';
-}
-
-function leftoverDir(): string | null {
-  const user = agentUser();
-  return user === null ? null : join(user.home, '.metro', 'marketplace');
-}
-
-function removeLeftover(dir: string | null): boolean {
-  if (dir === null || !existsSync(dir)) return true;
-  try {
-    removeHome(dir, true);
-    log.info({ dir }, 'claude-plugin: removed the old plugin marketplace copy');
-    return true;
-  } catch (err) {
-    log.warn({ dir, err: errMsg(err) }, 'claude-plugin: could not remove the old plugin marketplace copy');
-    return false;
-  }
-}
-
-async function cleanUp(run: Run, leftover: string | null): Promise<'removed' | 'clean' | 'failed'> {
-  const plugin = await removeIfListed(run, ['plugin', 'list', '--json'], 'id', PLUGIN, ['plugin', 'uninstall', PLUGIN]);
-  const market = await removeIfListed(run, ['plugin', 'marketplace', 'list', '--json'], 'name', MARKETPLACE, ['plugin', 'marketplace', 'remove', MARKETPLACE]);
-  const folder = removeLeftover(leftover);
-  if (plugin === 'failed' || market === 'failed' || !folder) return 'failed';
-  return plugin === 'removed' || market === 'removed' ? 'removed' : 'clean';
-}
-
-export async function removeMetroPlugin(deps: CleanupDeps = {}): Promise<CleanupOutcome> {
-  const agents = deps.agents ?? agentsDir();
-  if (readSetupState(agents)[DONE] === true) return 'done';
-  const run = deps.run === undefined ? await findClaude() : deps.run;
-  if (run === null) return 'skipped';
-  const outcome = await cleanUp(run, deps.leftover === undefined ? leftoverDir() : deps.leftover);
-  if (outcome !== 'failed') writeSetupState(agents, { [DONE]: true });
-  return outcome;
-}

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

@@ -1,45 +0,0 @@
-import { agentsDir } from '../agents/files.js';
-import type { CodexMethod } from '../gateway/codex-auth.js';
-import { connectionOf, readModelConfig, routedConnection, type Connection, type ModelConfig } from '../gateway/model-config.js';
-import { readSetupState, writeSetupState } from './setup-state.js';
-
-const RUNNERS = ['cli', 'sdk'] as const;
-export type HarnessRunner = (typeof RUNNERS)[number];
-
-export const SDK_NEEDS_KEY =
-  'The Agent SDK runner needs an API key or a ChatGPT sign-in on every model the Model page lists, the first one and each fallback: use Anthropic with an API key, Amazon Bedrock, OpenRouter, or a signed-in Codex connection (with ChatGPT or with a code). Anthropic does not allow products built on the Agent SDK to use a Claude login, so on a login it runs only where the Metro operator allows it.';
-
-export const isHarnessRunner = (value: unknown): value is HarnessRunner => RUNNERS.some((r) => r === value);
-
-export function harnessRunner(agents = agentsDir()): HarnessRunner {
-  const runner = readSetupState(agents).runner;
-  return isHarnessRunner(runner) ? runner : 'cli';
-}
-
-export function setHarnessRunner(runner: HarnessRunner, agents = agentsDir()): void {
-  writeSetupState(agents, { runner });
-}
-
-export const sdkOnLogin = (agents = agentsDir()): boolean => readSetupState(agents).sdkOnLogin === true;
-
-export function setSdkOnLogin(on: boolean, agents = agentsDir()): void {
-  writeSetupState(agents, { sdkOnLogin: on });
-}
-
-const SDK_ON_CODEX: Record<CodexMethod, boolean> = { chatgpt: true, code: true };
-
-const permitted = (conn: Connection | null): boolean => conn !== null && (conn.apiKey !== '' || (conn.codex !== null && SDK_ON_CODEX[conn.codex.method]));
-
-const servingConnections = (cfg: ModelConfig): (Connection | null)[] => [routedConnection(cfg), ...(cfg.fallbacks ?? []).map((f) => connectionOf(cfg, f.connection))];
-
-const permittedRoute = (cfg: ModelConfig): boolean => servingConnections(cfg).every(permitted);
-
-export const sdkAllowed = (agents = agentsDir(), cfg: ModelConfig = readModelConfig(agents), loginAllowed?: boolean): boolean => permittedRoute(cfg) || (loginAllowed ?? sdkOnLogin(agents));
-
-export const sdkConnectionAllowed = (connection: Connection, agents = agentsDir()): boolean => permitted(connection) || sdkOnLogin(agents);
-
-export function runnerModel(cfg: ModelConfig): string | null {
-  const conn = routedConnection(cfg);
-  if (conn === null || conn.model === '') return null;
-  return conn.provider === 'anthropic' ? conn.model : `${conn.provider}:${conn.model}`;
-}

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

@@ -1,57 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { join } from 'node:path';
-import { isRecord } from '@metro-labs/core/is-record';
-import { readJson, writeJson } from '@metro-labs/core/secure-fs';
-import { agentsDir } from '../agents/files.js';
-import { existsSync, readFileSync, realpathSync } from '../agent-user/agent-fs.js';
-import { claudeDir } from './files.js';
-
-const SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-const sessionId = (value: unknown): string | null => typeof value === 'string' && SESSION_ID_RE.test(value) ? value : null;
-
-function sdkSavedSession(home: string): Record<string, unknown> | null {
-  try {
-    const raw: unknown = JSON.parse(readFileSync(join(home, '.metro', 'agent-session.json'), 'utf8'));
-    return isRecord(raw) ? raw : null;
-  } catch (err) {
-    return isRecord(err) && err.code === 'ENOENT' ? {} : null;
-  }
-}
-
-const inputState = (value: unknown): boolean => value === undefined || value === 'queued' || value === 'started';
-
-function sdkInput(value: unknown): boolean {
-  if (!isRecord(value)) return false;
-  return typeof value.text === 'string' && typeof value.at === 'number' && Number.isFinite(value.at) && (value.uuid === undefined || sessionId(value.uuid) !== null) && inputState(value.state);
-}
-
-const sdkInputs = (value: unknown): value is unknown[] | undefined => value === undefined || (Array.isArray(value) && value.every(sdkInput));
-
-export function sdkPending(home: string): number | null {
-  const state = sdkSavedSession(home);
-  if (state === null) return null;
-  if (state.sessionId !== undefined && state.sessionId !== null && sessionId(state.sessionId) === null) return null;
-  if (!sdkInputs(state.unanswered) || !sdkInputs(state.interrupted)) return null;
-  return state.unanswered?.length ?? 0;
-}
-
-function projectFolder(home: string, dir: string): string {
-  let cwd = home;
-  try {
-    cwd = realpathSync(home);
-  } catch {
-    cwd = home;
-  }
-  return join(dir, 'projects', cwd.replace(/[^A-Za-z0-9]/g, '-'));
-}
-
-export function continueArgs(home: string, dir = claudeDir(), agents = agentsDir()): string[] {
-  const path = join(agents, 'claude-session.json');
-  const raw = readJson<unknown>(path, null);
-  const state = isRecord(raw) ? raw : {};
-  const project = projectFolder(home, dir);
-  const pinned = sessionId(state.cliSessionId);
-  const id = pinned ?? randomUUID();
-  if (pinned === null) writeJson(path, { ...state, cliSessionId: id });
-  return [existsSync(join(project, `${id}.jsonl`)) ? '--resume' : '--session-id', id];
-}

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

@@ -1,76 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { ApiError } from '@metro-labs/http/api-error';
-import { errMsg, log } from '@metro-labs/core/log';
-import { sessionRunning, stopSession, type SessionDeps } from './session.js';
-import { agentUser, asAgent, claudeBin } from '../agent-user/user.js';
-import { CLAUDE_CODE_VERSION, installClaudeCode } from './pinned.js';
-
-const VERSION_RE = /(\d+)\.(\d+)\.(\d+)/;
-
-export interface VersionDeps {
-  claude?: string;
-  session?: SessionDeps;
-}
-
-export interface ClaudeVersion {
-  installed: string | null;
-  latest: string;
-  newer: boolean;
-}
-
-function candidates(deps: VersionDeps): string[] {
-  if (deps.claude !== undefined) return [deps.claude];
-  return agentUser() === null ? ['claude', join(homedir(), '.local', 'bin', 'claude')] : [claudeBin()];
-}
-
-const parse = (text: string): string | null => {
-  const m = VERSION_RE.exec(text);
-  return m === null ? null : `${m[1] ?? ''}.${m[2] ?? ''}.${m[3] ?? ''}`;
-};
-
-function probe(bin: string): string | null {
-  const run = spawnSync(...asAgent(bin, ['--version']), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-  return run.error === undefined && run.status === 0 && typeof run.stdout === 'string' ? parse(run.stdout) : null;
-}
-
-function located(deps: VersionDeps): { bin: string; installed: string } | null {
-  for (const bin of candidates(deps)) {
-    const installed = probe(bin);
-    if (installed !== null) return { bin, installed };
-  }
-  return null;
-}
-
-export function claudeVersion(deps: VersionDeps = {}): ClaudeVersion {
-  const installed = located(deps)?.installed ?? null;
-  return { installed, latest: CLAUDE_CODE_VERSION, newer: installed !== null && installed !== CLAUDE_CODE_VERSION };
-}
-
-function restartIfChanged(changed: boolean, session: SessionDeps): boolean {
-  if (!changed || !sessionRunning(session.tmux ?? 'tmux')) return false;
-  stopSession(session);
-  return true;
-}
-
-export function updateClaude(deps: VersionDeps = {}): ClaudeVersion & { restarted: boolean } {
-  const found = located(deps);
-  if (found === null) throw new ApiError('Claude Code is not installed on this machine', 404);
-  try {
-    installClaudeCode(found.bin);
-  } catch (err) {
-    throw new ApiError(errMsg(err), 502);
-  }
-  const after = claudeVersion(deps);
-  const restarted = restartIfChanged(after.installed !== null && after.installed !== found.installed, deps.session ?? {});
-  log.info({ from: found.installed, to: after.installed, restarted }, 'claude-version: Claude Code updated');
-  return { ...after, restarted };
-}
-
-export function pinClaudeCode(deps: VersionDeps = {}): void {
-  const found = located(deps);
-  if (found === null || found.installed === CLAUDE_CODE_VERSION) return;
-  installClaudeCode(found.bin);
-  log.info({ from: found.installed, to: located(deps)?.installed ?? null }, 'claude-version: installed the Claude Code version metro was checked with');
-}