@stage-labs/metro 0.1.0-beta.190 → 0.1.0-beta.192

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.190",
+  "version": "0.1.0-beta.192",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.190",
+  "version": "0.1.0-beta.192",
   "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/agent-user/provision.ts

@@ -1,20 +1,16 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, lstatSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
-import { agentsDir } from '../agents/files.js';
 import { copyIntoHome } from './home-fs.js';
-import { agentMarketplaceDir, agentUser, asUser, claudeBin, forgetAgentUser, lookupUser, wantedAgentUser, type AgentUser } from './user.js';
+import { AGENT_NAME, agentMarketplaceDir, agentUser, agentUserExpected, asUser, claudeBin, forgetAgentUser, type AgentUser } from './user.js';
 import { watchAgentView } from './view.js';
-import { repairGitLinks } from './git-links.js';
 
 const INSTALL_MS = 10 * 60_000;
 const INSTALLER = 'curl -fsSL https://claude.ai/install.sh | bash';
-const MIGRATED = '.agent-user-migrated';
 
-export type Provisioned = 'off' | 'unsupported' | 'failed' | 'ready';
+export type Provisioned = 'off' | 'failed' | 'ready';
 
 function run(file: string, args: string[]): void {
   const done = spawnSync(file, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
@@ -22,10 +18,10 @@ function run(file: string, args: string[]): void {
   if (done.status !== 0) throw new Error(`${file} ${args.join(' ')}: ${done.stderr.trim() || `exit ${String(done.status)}`}`);
 }
 
-function ensureUser(name: string): AgentUser | null {
+function ensureUser(): AgentUser | null {
   if (agentUser() === null) {
-    run('useradd', ['--create-home', '--shell', '/bin/bash', name]);
-    log.info({ user: name }, 'agent-user: created the user Claude Code runs as');
+    run('useradd', ['--create-home', '--shell', '/bin/bash', AGENT_NAME]);
+    log.info({ user: AGENT_NAME }, 'agent-user: created the user Claude Code runs as');
     forgetAgentUser();
   }
   const user = agentUser();
@@ -33,54 +29,6 @@ function ensureUser(name: string): AgentUser | null {
   return user;
 }
 
-const absent = (path: string): boolean => {
-  try {
-    lstatSync(path);
-    return false;
-  } catch {
-    return true;
-  }
-};
-
-const encodedCwd = (dir: string): string => dir.replace(/[^A-Za-z0-9]/g, '-');
-
-function moveProject(user: AgentUser, from: string): void {
-  const projects = join(user.home, '.claude', 'projects');
-  const old = join(projects, encodedCwd(from));
-  const next = join(projects, encodedCwd(user.home));
-  if (existsSync(old) && absent(next)) run('mv', ['-T', old, next]);
-}
-
-const stamp = (now: Date): string => now.toISOString().replace(/[-:]/g, '').replace(/\..*$/, '').replace('T', '-');
-
-const kindIs = (path: string, want: 'dir' | 'file'): boolean => {
-  try {
-    const st = lstatSync(path);
-    return want === 'dir' ? st.isDirectory() : st.isFile();
-  } catch {
-    return false;
-  }
-};
-
-function migrateClaude(user: AgentUser, dir: string): void {
-  const marker = join(dir, MIGRATED);
-  if (existsSync(marker)) return;
-  const home = homedir();
-  const copied: string[] = [];
-  for (const name of ['.claude', '.claude.json']) {
-    const from = join(home, name);
-    const to = join(user.home, name);
-    if (!existsSync(from)) continue;
-    if (!absent(to)) run('mv', ['-T', to, `${to}.before-root-${stamp(new Date())}`]);
-    run('cp', ['-aT', from, to]);
-    run('chown', ['-hR', `${user.name}:${String(user.gid)}`, to]);
-    copied.push(name);
-  }
-  if (copied.includes('.claude')) moveProject(user, home);
-  writeFileSync(marker, `${user.name}\n`, { mode: 0o600 });
-  log.info({ user: user.name, copied }, 'agent-user: moved the Claude Code folder and login to the agent user once; root keeps its copy');
-}
-
 function installClaude(user: AgentUser): Promise<void> {
   if (existsSync(claudeBin(user))) return Promise.resolve();
   const [file, args] = asUser(user, 'bash', ['-c', INSTALLER]);
@@ -119,79 +67,17 @@ function copyMarketplace(user: AgentUser, env: NodeJS.ProcessEnv): void {
   log.info({ files, version: pluginVersion(from) }, 'agent-user: copied the metro plugin where the agent user can load it');
 }
 
-function stopRootSession(): void {
-  const running = spawnSync('tmux', ['has-session', '-t', 'metro'], { stdio: 'ignore' });
-  if (running.error !== undefined || running.status !== 0) return;
-  spawnSync('tmux', ['kill-session', '-t', 'metro'], { stdio: 'ignore' });
-  log.info('agent-user: stopped the Claude session root was running; it comes back as the agent user');
-}
-
-function stopAgentSessions(user: AgentUser): void {
-  spawnSync(...asUser(user, 'tmux', ['kill-server']), { stdio: 'ignore' });
-}
-
-function takeBack(user: AgentUser, now: Date): string[] {
-  const home = homedir();
-  const taken: string[] = [];
-  for (const [name, kind] of [['.claude', 'dir'], ['.claude.json', 'file']] as const) {
-    const from = join(user.home, name);
-    if (!kindIs(from, kind)) continue;
-    const to = join(home, name);
-    if (!absent(to)) run('mv', ['-T', to, `${to}.before-agent-${stamp(now)}`]);
-    run('cp', ['-aT', from, to]);
-    run('chown', ['-hR', 'root:root', to]);
-    taken.push(name);
-  }
-  if (taken.includes('.claude')) {
-    const projects = join(home, '.claude', 'projects');
-    const old = join(projects, encodedCwd(user.home));
-    const next = join(projects, encodedCwd(home));
-    if (existsSync(old) && absent(next)) run('mv', ['-T', old, next]);
-  }
-  return taken;
-}
-
-export function returnToRoot(dir = agentsDir(), now = new Date()): string[] | null {
-  const marker = join(dir, MIGRATED);
-  if (process.platform !== 'linux' || process.getuid?.() !== 0 || !existsSync(marker)) return null;
-  const name = readFileSync(marker, 'utf8').trim() || 'agent';
-  const user = lookupUser(name);
-  if (user === null) return null;
-  stopAgentSessions(user);
-  const taken = takeBack(user, now);
-  rmSync(marker);
-  log.info({ user: user.name, taken }, 'agent-user: switched off; the agent\'s Claude folder and login are root\'s again, root\'s older copy is kept beside it');
-  return taken;
-}
-
-export async function provisionAgentUser(dir = agentsDir(), env: NodeJS.ProcessEnv = process.env): Promise<Provisioned> {
-  const name = wantedAgentUser(dir);
-  if (name === null) {
-    try {
-      returnToRoot(dir);
-    } catch (err) {
-      log.error({ err: errMsg(err) }, 'agent-user: could not bring the Claude folder back to root; the agent user keeps it, nothing was deleted');
-    }
-    return 'off';
-  }
-  if (process.platform !== 'linux' || process.getuid?.() !== 0) {
-    log.warn({ user: name }, 'agent-user: running Claude Code as its own user needs Linux and a daemon running as root; the Claude session stays stopped');
-    return 'unsupported';
-  }
+export async function provisionAgentUser(env: NodeJS.ProcessEnv = process.env): Promise<Provisioned> {
+  if (!agentUserExpected()) return 'off';
   try {
-    const user = ensureUser(name);
-    if (user === null) throw new Error(`the user ${name} could not be found after creating it`);
-    stopRootSession();
-    migrateClaude(user, dir);
+    const user = ensureUser();
+    if (user === null) throw new Error(`the user ${AGENT_NAME} could not be found after creating it`);
     await installClaude(user);
     copyMarketplace(user, env);
     watchAgentView();
-    repairGitLinks(user).catch((err: unknown) => {
-      log.warn({ err: errMsg(err) }, 'agent-user: could not repair git links');
-    });
     return 'ready';
   } catch (err) {
-    log.error({ user: name, err: errMsg(err) }, 'agent-user: could not prepare the agent user; the Claude session stays stopped');
+    log.error({ user: AGENT_NAME, err: errMsg(err) }, 'agent-user: could not prepare the agent user; the Claude session stays stopped');
     return 'failed';
   }
 }

package/runtime/node_modules/@metro-labs/daemon/src/agent-user/schedule-detail.ts

@@ -0,0 +1,82 @@
+import { spawn } from 'node:child_process';
+import { closeSync, existsSync, openSync, readSync, statSync } from 'node:fs';
+import { ApiError } from '@metro-labs/http/api-error';
+import { log } from '@metro-labs/core/log';
+import { listSchedules, realRunner, showProps, type Runner, type ScheduledJob } from './schedules.js';
+import { asUser, type AgentUser } from './user.js';
+
+const LOG_LINES = 80;
+const TAIL_BYTES = 64 * 1024;
+
+export interface JobDetail extends ScheduledJob {
+  definition: string;
+  logs: string;
+  logSource: string | null;
+}
+
+function findJob(id: string, user: AgentUser | null, runner: Runner): ScheduledJob {
+  const job = listSchedules(user, runner).find((j) => j.id === id);
+  if (job === undefined) throw new ApiError('no such scheduled job', 404);
+  return job;
+}
+
+const serviceOf = (unit: string, runner: Runner): string => showProps(runner, unit, ['Unit']).Unit ?? unit.replace(/\.timer$/, '.service');
+
+export function logFileOf(command: string): string | null {
+  const m = /(?:^|\s)(?:>>|>)\s*(\/\S+)/.exec(command);
+  return m?.[1] ?? null;
+}
+
+function tail(path: string): string {
+  const size = statSync(path).size;
+  const start = Math.max(0, size - TAIL_BYTES);
+  const fd = openSync(path, 'r');
+  try {
+    const buffer = Buffer.alloc(size - start);
+    readSync(fd, buffer, 0, buffer.length, start);
+    return buffer.toString('utf8').split('\n').slice(-LOG_LINES).join('\n');
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function timerDetail(job: ScheduledJob, runner: Runner): JobDetail {
+  const unit = job.id.slice('timer:'.length);
+  const service = serviceOf(unit, runner);
+  return {
+    ...job,
+    definition: runner.run('systemctl', ['cat', unit, service, '--no-pager']).stdout,
+    logs: runner.run('journalctl', ['-u', service, '-n', String(LOG_LINES), '--no-pager', '-o', 'short-iso']).stdout,
+    logSource: `journalctl -u ${service}`,
+  };
+}
+
+function cronDetail(job: ScheduledJob): JobDetail {
+  const file = logFileOf(job.command);
+  const readable = file !== null && existsSync(file) && statSync(file).isFile();
+  return {
+    ...job,
+    definition: `${job.schedule} ${job.command}`,
+    logs: readable ? tail(file) : '',
+    logSource: file,
+  };
+}
+
+export function scheduleDetail(id: string, user: AgentUser | null, runner: Runner = realRunner): JobDetail {
+  const job = findJob(id, user, runner);
+  return job.kind === 'timer' ? timerDetail(job, runner) : cronDetail(job);
+}
+
+export function runNow(id: string, user: AgentUser | null, runner: Runner = realRunner): JobDetail {
+  const job = findJob(id, user, runner);
+  if (job.runsAs === 'root') throw new ApiError('this job still runs as root; switch it to the agent first', 409);
+  if (job.kind === 'timer') runner.run('systemctl', ['start', '--no-block', serviceOf(job.id.slice('timer:'.length), runner)]);
+  else {
+    if (user === null) throw new ApiError('Claude Code does not run as its own user on this machine', 409);
+    const [file, args] = asUser(user, 'sh', ['-c', job.command]);
+    const child = spawn(file, args, { detached: true, stdio: 'ignore', cwd: user.home });
+    child.unref();
+  }
+  log.info({ job: job.name }, 'schedules: run now, from the page');
+  return scheduleDetail(id, user, runner);
+}

package/runtime/node_modules/@metro-labs/daemon/src/agent-user/schedules-api.ts

@@ -0,0 +1,27 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { bodyField, readJsonBody, sessionRoute } from '@metro-labs/http/api-http';
+import { listSchedules, retrySchedule } from './schedules.js';
+import { runNow, scheduleDetail } from './schedule-detail.js';
+import { agentUser } from './user.js';
+
+const PATH = '/api/schedules';
+
+const queryId = (req: IncomingMessage): string | null => new URLSearchParams((req.url ?? '').split('?')[1] ?? '').get('id');
+
+async function answer(req: IncomingMessage): Promise<unknown> {
+  const user = agentUser();
+  if (req.method === 'GET') {
+    const id = queryId(req);
+    return id === null ? { agentUser: user?.name ?? null, jobs: listSchedules(user) } : { job: scheduleDetail(id, user) };
+  }
+  const body = await readJsonBody(req);
+  const id = bodyField(body, 'id');
+  if (typeof id !== 'string' || id === '') throw new ApiError('id is required', 400);
+  if (bodyField(body, 'action') === 'run') return { job: runNow(id, user) };
+  return { agentUser: user?.name ?? null, jobs: retrySchedule(id, user) };
+}
+
+export function handleSchedulesRequest(req: IncomingMessage, res: ServerResponse): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET', 'POST'] }, admin: true, label: 'schedules-api' }, () => answer(req));
+}

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

@@ -1,14 +1,15 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { ApiError } from '@metro-labs/http/api-error';
 import { isRecord } from '@metro-labs/core/is-record';
-import { log } from '@metro-labs/core/log';
+import { errMsg, log } from '@metro-labs/core/log';
 import type { AgentUser } from './user.js';
 
 const UNIT_DIR = '/etc/systemd/system';
+const defaultBackups = (): string => join(homedir(), '.metro', 'agents');
 const DROP_IN = '10-metro-agent.conf';
 const OWN_UNITS = /^metro(-claude-\d+)?\.(service|scope)$/;
 
@@ -26,13 +27,14 @@ export interface ScheduledJob {
   lastResult: string | null;
   usesRoot: boolean;
   converted: boolean;
+  problem?: string | null;
 }
 
 export interface Runner {
   run: (file: string, args: string[], input?: string) => { status: number | null; stdout: string };
 }
 
-const realRunner: Runner = {
+export const realRunner: Runner = {
   run: (file, args, input) => {
     const done = spawnSync(file, args, { encoding: 'utf8', input, stdio: ['pipe', 'pipe', 'ignore'], timeout: 20_000 });
     return { status: done.error === undefined ? done.status : null, stdout: done.stdout ?? '' };
@@ -46,7 +48,7 @@ export const rehome = (text: string, home: string): string => text.replace(/(^|[
 const stamp = (micros: unknown): string | null =>
   typeof micros === 'number' && micros > 0 ? new Date(micros / 1000).toISOString() : null;
 
-function showProps(runner: Runner, unit: string, props: string[]): Record<string, string> {
+export function showProps(runner: Runner, unit: string, props: string[]): Record<string, string> {
   const out = runner.run('systemctl', ['show', unit, '--no-pager', ...props.map((p) => `-p${p}`)]).stdout;
   const found: Record<string, string> = {};
   for (const line of out.split('\n')) {
@@ -149,7 +151,7 @@ function cronJobs(runner: Runner, user: string, kind: JobKind): ScheduledJob[] {
   });
 }
 
-export function listSchedules(user: AgentUser | null, runner: Runner = realRunner): ScheduledJob[] {
+function allJobs(user: AgentUser | null, runner: Runner): ScheduledJob[] {
   return [...timerJobs(runner), ...cronJobs(runner, 'root', 'cron-root'), ...(user === null ? [] : cronJobs(runner, user.name, 'cron-agent'))];
 }
 
@@ -186,14 +188,6 @@ function convertTimer(job: ScheduledJob, user: AgentUser, runner: Runner): void
   log.info({ unit, service, user: user.name }, 'schedules: a timer now runs as the agent user');
 }
 
-function restoreTimer(job: ScheduledJob, runner: Runner): void {
-  const unit = job.id.slice('timer:'.length);
-  const service = showProps(runner, unit, ['Unit']).Unit ?? unit.replace(/\.timer$/, '.service');
-  rmSync(join(UNIT_DIR, `${service}.d`, DROP_IN), { force: true });
-  runner.run('systemctl', ['daemon-reload']);
-  log.info({ unit, service }, 'schedules: a timer runs as root again');
-}
-
 function convertCron(job: ScheduledJob, user: AgentUser, backups: string, runner: Runner): void {
   const lines = crontabOf(runner, 'root');
   const line = lines.find((l) => lineId('cron-root', l) === job.id);
@@ -208,23 +202,44 @@ function convertCron(job: ScheduledJob, user: AgentUser, backups: string, runner
   log.info({ user: user.name }, "schedules: a root cron line moved to the agent's crontab");
 }
 
-function toRoot(job: ScheduledJob, runner: Runner): void {
-  if (job.kind !== 'timer' || !job.converted) throw new ApiError('only a timer metro switched can go back to root', 400);
-  restoreTimer(job, runner);
-}
-
-function toAgent(job: ScheduledJob, user: AgentUser | null, backups: string, runner: Runner): void {
-  if (user === null) throw new ApiError('switch Claude Code to its own user first', 409);
+function toAgent(job: ScheduledJob, user: AgentUser, backups: string, runner: Runner): void {
   if (job.kind === 'timer') convertTimer(job, user, runner);
   else if (job.kind === 'cron-root') convertCron(job, user, backups, runner);
   else throw new ApiError('that job already runs as the agent', 400);
 }
 
-export function changeSchedule(id: string, action: unknown, user: AgentUser | null, backups = join(homedir(), '.metro', 'agents'), runner: Runner = realRunner): ScheduledJob[] {
-  if (action !== 'agent' && action !== 'root') throw new ApiError('action must be agent or root', 400);
-  const job = listSchedules(user, runner).find((j) => j.id === id);
+const problems = new Map<string, string>();
+
+const needsAgent = (job: ScheduledJob): boolean => job.kind !== 'cron-agent' && job.runsAs === 'root' && job.usesRoot;
+
+function tryAgent(job: ScheduledJob, user: AgentUser, backups: string, runner: Runner): boolean {
+  try {
+    toAgent(job, user, backups, runner);
+    problems.delete(job.id);
+    return true;
+  } catch (err) {
+    problems.set(job.id, errMsg(err));
+    log.warn({ job: job.name, err: errMsg(err) }, 'schedules: a job still pointing into /root could not be switched to the agent user');
+    return false;
+  }
+}
+
+export function convertRootJobs(user: AgentUser | null, backups = defaultBackups(), runner: Runner = realRunner): number {
+  if (user === null) return 0;
+  const pending = allJobs(user, runner).filter(needsAgent);
+  return pending.filter((job) => tryAgent(job, user, backups, runner)).length;
+}
+
+export const listSchedules = (user: AgentUser | null, runner: Runner = realRunner): ScheduledJob[] =>
+  allJobs(user, runner)
+    .filter((job) => job.runsAs !== 'root' || job.usesRoot)
+    .map((job) => ({ ...job, problem: problems.get(job.id) ?? null }));
+
+export function retrySchedule(id: string, user: AgentUser | null, backups = defaultBackups(), runner: Runner = realRunner): ScheduledJob[] {
+  if (user === null) throw new ApiError('Claude Code does not run as its own user on this machine', 409);
+  const job = allJobs(user, runner).find((j) => j.id === id);
   if (job === undefined) throw new ApiError('no such scheduled job', 404);
-  if (action === 'root') toRoot(job, runner);
-  else toAgent(job, user, backups, runner);
+  if (needsAgent(job)) toAgent(job, user, backups, runner);
+  problems.delete(id);
   return listSchedules(user, runner);
 }

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

@@ -1,11 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { join } from 'node:path';
-import { isRecord } from '@metro-labs/core/is-record';
-import { readJson } from '@metro-labs/core/secure-fs';
-import { agentsDir } from '../agents/files.js';
 
-export const CONFIG_FILE = 'agent-user.json';
-const NAME_RE = /^[a-z_][a-z0-9_-]{0,31}$/;
+export const AGENT_NAME = 'agent';
 const AGENT_PATH = ['.local/bin', '/usr/local/sbin', '/usr/local/bin', '/usr/sbin', '/usr/bin', '/sbin', '/bin'];
 
 export interface AgentUser {
@@ -32,22 +28,14 @@ export function lookupUser(name: string): AgentUser | null {
 
 const realHost: UserHost = { platform: process.platform, uid: process.getuid?.(), lookup: lookupUser };
 
-export function wantedAgentUser(dir = agentsDir()): string | null {
-  const raw = readJson<unknown>(join(dir, CONFIG_FILE), null);
-  if (!isRecord(raw) || raw.enabled === false) return null;
-  const name = typeof raw.user === 'string' ? raw.user : 'agent';
-  return NAME_RE.test(name) && name !== 'root' ? name : null;
-}
+export const agentUserExpected = (host: UserHost = realHost): boolean => host.platform === 'linux' && host.uid === 0;
 
-let cached: { key: string; user: AgentUser | null } | null = null;
+let cached: AgentUser | null = null;
 
-export function agentUser(dir = agentsDir(), host: UserHost = realHost): AgentUser | null {
-  const name = wantedAgentUser(dir);
-  if (name === null || host.platform !== 'linux' || host.uid !== 0) return null;
-  const key = `${dir}\n${name}`;
-  if (cached?.key === key && cached.user !== null) return cached.user;
-  cached = { key, user: host.lookup(name) };
-  return cached.user;
+export function agentUser(host: UserHost = realHost): AgentUser | null {
+  if (!agentUserExpected(host)) return null;
+  cached ??= host.lookup(AGENT_NAME);
+  return cached;
 }
 
 export function forgetAgentUser(): void {

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

@@ -24,6 +24,8 @@ import { syncPluginServers } from '../connectors/plugin-sync.js';
 import { loadConnectorPolicies, readLocalConnectors } from '../connectors/store.js';
 import { ensureMetroPlugin } from '../claude/plugin-install.js';
 import { provisionAgentUser } from '../agent-user/provision.js';
+import { convertRootJobs } from '../agent-user/schedules.js';
+import { agentUser as currentAgentUser } from '../agent-user/user.js';
 import { ensureServiceOomPolicy } from '../claude/memory.js';
 import { unwatchSession, watchSession } from '../claude/session.js';
 import { tryClaudeSetup } from '../claude/setup.js';
@@ -158,7 +160,11 @@ async function startClaude(): Promise<void> {
   ensureServiceOomPolicy();
   const agentUser = await provisionAgentUser();
   if (agentUser !== 'off') log.info({ agentUser }, 'agent-user: Claude Code runs as its own user');
-  if (agentUser === 'failed' || agentUser === 'unsupported') return;
+  if (agentUser === 'failed') return;
+  if (agentUser === 'ready') {
+    const switched = convertRootJobs(currentAgentUser());
+    if (switched > 0) log.info({ switched }, "schedules: jobs that pointed into root's home now run as the agent user");
+  }
   ensureMetroPlugin()
     .then((outcome) => {
       log.info({ outcome }, 'plugin: metro plugin for Claude Code');

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

@@ -12,7 +12,7 @@ import { claudeDir, listClaudeProjects } from './files.js';
 import { claudeAccount, claudeInstalled } from './login.js';
 import { trustFolder } from './onboarding.js';
 import { inSessionScope } from './memory.js';
-import { agentUser, agentViewDir, asAgent, claudeHome, wantedAgentUser } from '../agent-user/user.js';
+import { agentUser, agentUserExpected, agentViewDir, asAgent, claudeHome } from '../agent-user/user.js';
 
 function sessionEnv(): Record<string, string> {
   const user = agentUser();
@@ -132,14 +132,14 @@ function credentialReady(deps: SessionDeps): string | null {
   return 'Claude Code is not signed in and the Model page routes nowhere yet';
 }
 
-const agentUserMissing = (deps: SessionDeps, agents: string): boolean =>
-  deps.metro === undefined && wantedAgentUser(agents) !== null && agentUser(agents) === null;
+const agentUserMissing = (deps: SessionDeps): boolean =>
+  deps.metro === undefined && agentUserExpected() && agentUser() === null;
 
 export function sessionBlocked(deps: SessionDeps = {}): string | null {
   const agents = deps.agents ?? agentsDir();
   if (listAgentFiles(agents).length === 0) return 'no agent on this machine yet';
-  if (agentUserMissing(deps, agents))
-    return 'Claude Code is set to run as its own user, and that user is not ready (Linux and a daemon running as root are needed; see the log)';
+  if (agentUserMissing(deps))
+    return 'Claude Code runs as the user agent here, and that user is not ready yet; see the log';
   if (deps.metro === undefined && !claudeInstalled()) return 'Claude Code is not installed on this machine';
   if (!tmuxOk(deps.tmux ?? 'tmux', ['-V'])) return 'tmux is not installed on this machine';
   return credentialReady(deps);

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

@@ -195,7 +195,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     claudeApi: {},
     updateApi: { restart: deps.restart },
     controlApi: { restart: deps.restart, stop: deps.stop },
-    agentUserApi: { restart: deps.restart },
+    schedulesApi: true,
     ownerApi: { setOwner: (owner) => setLocalOwner(owner) },
     machineApi: {},
     modelApi: {},

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

@@ -17,14 +17,14 @@ import { handleMachineRequest, type MachineApiDeps } from '../server/machine.js'
 import { handleModelRequest, type ModelApiDeps } from '../gateway/model-api.js';
 import type { GatewayDeps } from '../gateway/gateway.js';
 import { handleTerminalRequest, type TerminalApiDeps } from '../terminal/api.js';
-import { handleAgentUserRequest, type AgentUserApiDeps } from '../agent-user/api.js';
+import { handleSchedulesRequest } from '../agent-user/schedules-api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
   bundleApi?: BundleApiDeps;
   updateApi?: UpdateApiDeps;
   controlApi?: ControlApiDeps;
-  agentUserApi?: AgentUserApiDeps;
+  schedulesApi?: true;
   ownerApi?: OwnerApiDeps;
   machineApi?: MachineApiDeps;
   modelApi?: ModelApiDeps;
@@ -51,7 +51,7 @@ export function handleSessionApis(
     ...when(apis.bundleApi, (d) => handleBundleRequest(req, res, d)),
     ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
     ...when(apis.controlApi, (d) => handleControlRequest(req, res, d)),
-    ...when(apis.agentUserApi, (d) => handleAgentUserRequest(req, res, d)),
+    ...when(apis.schedulesApi, () => handleSchedulesRequest(req, res)),
     ...when(apis.ownerApi, (d) => handleOwnerRequest(req, res, d)),
     ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
     ...when(apis.modelApi, (d) => handleModelRequest(req, res, d)),

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.190"
+  "version": "0.1.0-beta.192"
 }

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

@@ -1,98 +0,0 @@
-import { existsSync, rmSync } from 'node:fs';
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { join } from 'node:path';
-import { ApiError } from '@metro-labs/http/api-error';
-import { bodyField, readJsonBody, requireAdmin, sessionRoute } from '@metro-labs/http/api-http';
-import { log } from '@metro-labs/core/log';
-import { writeSecure } from '@metro-labs/core/secure-fs';
-import { agentsDir } from '../agents/files.js';
-import { agentUser, CONFIG_FILE, forgetAgentUser, wantedAgentUser } from './user.js';
-import { listWorkspace, modeOf, startMove } from './workspace.js';
-import { changeSchedule, listSchedules } from './schedules.js';
-
-const PATH = '/api/agent-user';
-const WORKSPACE = '/api/agent-user/workspace';
-const SCHEDULES = '/api/schedules';
-const EXIT_DELAY_MS = 500;
-const NAMES_BODY_MAX = 128 * 1024;
-
-export interface AgentUserApiDeps {
-  restart: () => void;
-  agents?: () => string;
-  host?: () => { platform: string; uid: number | undefined; cli: boolean };
-}
-
-export interface AgentUserStatus {
-  enabled: boolean;
-  user: string | null;
-  active: boolean;
-  supported: boolean;
-  reason: string | null;
-}
-
-const realHost = (): { platform: string; uid: number | undefined; cli: boolean } => ({
-  platform: process.platform,
-  uid: process.getuid?.(),
-  cli: (process.env.METRO_CLI_BIN?.trim() ?? '') !== '',
-});
-
-function unsupported(host: { platform: string; uid: number | undefined; cli: boolean }): string | null {
-  if (host.platform !== 'linux') return 'Claude Code can run as its own user on Linux only.';
-  if (host.uid !== 0) return 'Metro runs as a normal user here, so it cannot switch Claude Code to another user.';
-  if (!host.cli) return 'This daemon was not started by metro serve, so nothing would bring it back after the switch.';
-  return null;
-}
-
-export function agentUserStatus(deps: Pick<AgentUserApiDeps, 'agents' | 'host'> = {}): AgentUserStatus {
-  const dir = (deps.agents ?? agentsDir)();
-  const reason = unsupported((deps.host ?? realHost)());
-  const user = wantedAgentUser(dir);
-  return { enabled: user !== null, user, active: user !== null && agentUser(dir) !== null, supported: reason === null, reason };
-}
-
-function setWanted(dir: string, enabled: boolean): void {
-  const path = join(dir, CONFIG_FILE);
-  if (enabled) writeSecure(path, `${JSON.stringify({ user: 'agent' })}\n`);
-  else if (existsSync(path)) rmSync(path);
-  forgetAgentUser();
-}
-
-async function workspaceAnswer(req: IncomingMessage, dir: string): Promise<unknown> {
-  const user = agentUser(dir);
-  if (user === null) throw new ApiError('switch Claude Code to its own user first', 409);
-  if (req.method === 'GET') return { user: user.name, home: user.home, entries: listWorkspace(user) };
-  const body = await readJsonBody(req, NAMES_BODY_MAX);
-  const started = startMove(bodyField(body, 'names'), user, modeOf(bodyField(body, 'mode')));
-  return { started, entries: listWorkspace(user) };
-}
-
-async function schedulesAnswer(req: IncomingMessage, dir: string): Promise<unknown> {
-  const user = agentUser(dir);
-  if (req.method === 'GET') return { agentUser: user?.name ?? null, jobs: listSchedules(user) };
-  const body = await readJsonBody(req);
-  const id = bodyField(body, 'id');
-  if (typeof id !== 'string' || id === '') throw new ApiError('id is required', 400);
-  return { agentUser: user?.name ?? null, jobs: changeSchedule(id, bodyField(body, 'action'), user) };
-}
-
-async function switchAnswer(req: IncomingMessage, deps: AgentUserApiDeps, subject: string): Promise<unknown> {
-  const enabled = bodyField(await readJsonBody(req), 'enabled');
-  if (typeof enabled !== 'boolean') throw new ApiError('enabled must be true or false', 400);
-  const reason = unsupported((deps.host ?? realHost)());
-  if (enabled && reason !== null) throw new ApiError(reason, 400);
-  setWanted((deps.agents ?? agentsDir)(), enabled);
-  log.info({ enabled, subject }, 'agent-user-api: switched from the page; restarting');
-  setTimeout(deps.restart, EXIT_DELAY_MS).unref();
-  return { ...agentUserStatus(deps), restarting: true };
-}
-
-export function handleAgentUserRequest(req: IncomingMessage, res: ServerResponse, deps: AgentUserApiDeps): boolean {
-  const methods = { [PATH]: ['GET', 'POST'], [WORKSPACE]: ['GET', 'POST'], [SCHEDULES]: ['GET', 'POST'] };
-  return sessionRoute(req, res, { methods, admin: ['POST'], label: 'agent-user-api' }, async (session, path) => {
-    const dir = (deps.agents ?? agentsDir)();
-    if (path !== PATH) requireAdmin(session);
-    if (path === WORKSPACE) return workspaceAnswer(req, dir);
-    if (path === SCHEDULES) return schedulesAnswer(req, dir);
-    return req.method === 'GET' ? agentUserStatus(deps) : switchAnswer(req, deps, session.subject);
-  });
-}

package/runtime/node_modules/@metro-labs/daemon/src/agent-user/git-links.ts

@@ -1,34 +0,0 @@
-import { spawn } from 'node:child_process';
-import { homedir } from 'node:os';
-import { errMsg, log } from '@metro-labs/core/log';
-import { asUser, type AgentUser } from './user.js';
-
-const REPAIR = [
-  'from="$1"; to="$2"',
-  'find "$to" -maxdepth 8 -name node_modules -prune -o -name .git -type f -print 2>/dev/null | while read -r f; do',
-  '  grep -q "^gitdir: $from/" "$f" && sed -i "s#^gitdir: $from/#gitdir: $to/#" "$f" && echo "$f"',
-  'done',
-  'find "$to" -maxdepth 10 -name node_modules -prune -o -path "*/.git/worktrees/*/gitdir" -type f -print 2>/dev/null | while read -r g; do',
-  '  grep -q "^$from/" "$g" && sed -i "s#^$from/#$to/#" "$g" && echo "$g"',
-  'done',
-].join('\n');
-
-export function repairGitLinks(user: AgentUser, from = homedir()): Promise<number> {
-  const [file, args] = asUser(user, 'sh', ['-c', REPAIR, 'metro', from, user.home]);
-  return new Promise((resolve) => {
-    const child = spawn(file, args, { stdio: ['ignore', 'pipe', 'ignore'] });
-    let out = '';
-    child.stdout.on('data', (chunk: Buffer) => {
-      out += chunk.toString('utf8');
-    });
-    child.on('error', (err) => {
-      log.warn({ err: errMsg(err) }, 'agent-user: could not repair git links');
-      resolve(0);
-    });
-    child.on('close', () => {
-      const fixed = out.split('\n').filter((line) => line !== '').length;
-      if (fixed > 0) log.info({ fixed }, "agent-user: repaired git links that still pointed into root's home");
-      resolve(fixed);
-    });
-  });
-}

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

@@ -1,182 +0,0 @@
-import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, lstatSync, mkdtempSync, readdirSync, rmSync, statSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { ApiError } from '@metro-labs/http/api-error';
-import { errMsg, log } from '@metro-labs/core/log';
-import { repairGitLinks } from './git-links.js';
-import { asUser, type AgentUser } from './user.js';
-
-const SKIPPED = new Set(['snap', 'lost+found']);
-const SAFE_HIDDEN = [
-  '.cache/huggingface/hub',
-  '.cache/whisper',
-  '.cache/torch',
-  '.cache/ms-playwright',
-  '.venv',
-  '.venvs',
-  '.virtualenvs',
-  '.pyenv',
-  '.bun',
-  '.nvm',
-  '.cargo',
-  '.rustup',
-  '.deno',
-];
-const SIZE_MS = 2_000;
-const SIZES_BUDGET_MS = 6_000;
-const NAMES_MAX = 1_000;
-
-export type EntryState = 'here' | 'waiting' | 'copying' | 'moved' | 'failed';
-export type MoveMode = 'copy' | 'move';
-
-export interface WorkspaceEntry {
-  name: string;
-  kind: 'folder' | 'file' | 'link';
-  hidden: boolean;
-  bytes: number | null;
-  state: EntryState;
-  error: string | null;
-}
-
-interface Job {
-  state: 'waiting' | 'copying' | 'failed';
-  error: string | null;
-}
-
-const jobs = new Map<string, Job>();
-let queue: Promise<void> = Promise.resolve();
-
-function kindOf(path: string): WorkspaceEntry['kind'] | null {
-  try {
-    const stat = lstatSync(path);
-    if (stat.isSymbolicLink()) return 'link';
-    if (stat.isDirectory()) return 'folder';
-    return stat.isFile() ? 'file' : null;
-  } catch {
-    return null;
-  }
-}
-
-const present = (path: string): boolean => kindOf(path) !== null;
-
-function sizeOf(path: string): number | null {
-  const run = spawnSync('du', ['-sk', path], { encoding: 'utf8', timeout: SIZE_MS, stdio: ['ignore', 'pipe', 'ignore'] });
-  const kb = Number(run.stdout.split('\t')[0]);
-  return run.status === 0 && Number.isFinite(kb) ? kb * 1024 : null;
-}
-
-export function candidates(from = homedir()): string[] {
-  const visible = readdirSync(from).filter((name) => !name.startsWith('.') && !SKIPPED.has(name));
-  const hidden = SAFE_HIDDEN.filter((name) => kindOf(join(from, name)) === 'folder');
-  return [...visible.sort((a, b) => a.localeCompare(b)), ...hidden];
-}
-
-function stateOf(name: string, user: AgentUser): Pick<WorkspaceEntry, 'state' | 'error'> {
-  const job = jobs.get(name);
-  if (job !== undefined) return { state: job.state, error: job.error };
-  return { state: present(join(user.home, name)) ? 'moved' : 'here', error: null };
-}
-
-export function listWorkspace(user: AgentUser, from = homedir(), now = Date.now): WorkspaceEntry[] {
-  const until = now() + SIZES_BUDGET_MS;
-  return candidates(from).flatMap((name): WorkspaceEntry[] => {
-    const path = join(from, name);
-    const kind = kindOf(path);
-    if (kind === null) return [];
-    const bytes = kind === 'file' ? lstatSync(path).size : kind === 'folder' && now() < until ? sizeOf(path) : null;
-    return [{ name, kind, hidden: name.startsWith('.'), bytes, ...stateOf(name, user) }];
-  });
-}
-
-function run(file: string, args: string[]): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(file, args, { stdio: ['ignore', 'ignore', 'pipe'] });
-    let said = '';
-    child.stderr.on('data', (chunk: Buffer) => {
-      said = `${said}${chunk.toString('utf8')}`.slice(-1000);
-    });
-    child.on('error', reject);
-    child.on('close', (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`${file}: ${said.trim() || `exit ${String(code)}`}`));
-    });
-  });
-}
-
-function makeParents(user: AgentUser, target: string): void {
-  const parent = dirname(target);
-  if (parent === user.home || existsSync(parent)) return;
-  const [file, args] = asUser(user, 'mkdir', ['-p', '--', parent]);
-  spawnSync(file, args, { stdio: 'ignore' });
-}
-
-const sameDisk = (a: string, b: string): boolean => statSync(a).dev === statSync(b).dev;
-
-async function putBack(staged: string, source: string): Promise<void> {
-  if (present(staged) && !present(source)) await run('mv', ['-T', '--', staged, source]);
-}
-
-async function place(name: string, user: AgentUser, from: string, mode: MoveMode): Promise<void> {
-  const source = join(from, name);
-  const target = join(user.home, name);
-  const staging = mkdtempSync(join(user.home, '..', '.metro-move-'));
-  const staged = join(staging, 'entry');
-  try {
-    if (mode === 'move') await run('mv', ['-T', '--', source, staged]);
-    else await run('cp', ['-a', '--', source, staged]);
-    await run('chown', ['-hR', `${String(user.uid)}:${String(user.gid)}`, staged]);
-    makeParents(user, target);
-    if (present(target)) throw new Error(`${target} already exists; move or remove it first`);
-    await run('mv', ['-T', '--', staged, target]);
-  } catch (err) {
-    if (mode === 'move') await putBack(staged, source);
-    throw err;
-  } finally {
-    rmSync(staging, { recursive: true, force: true });
-  }
-}
-
-async function moveOne(name: string, user: AgentUser, from: string, mode: MoveMode): Promise<void> {
-  await place(name, user, from, mode);
-  jobs.delete(name);
-  await repairGitLinks(user, from);
-  log.info({ name, mode, user: user.name }, "agent-user: an entry from root's home now belongs to the agent user");
-}
-
-function wantedNames(names: unknown): string[] {
-  if (!Array.isArray(names) || names.length === 0 || names.length > NAMES_MAX || !names.every((n) => typeof n === 'string'))
-    throw new ApiError('names must be a list of entries from the list', 400);
-  return [...new Set(names)];
-}
-
-export function modeOf(raw: unknown): MoveMode {
-  if (raw === undefined || raw === 'copy') return 'copy';
-  if (raw === 'move') return 'move';
-  throw new ApiError('mode must be copy or move', 400);
-}
-
-function assertMovable(name: string, listed: ReadonlySet<string>, user: AgentUser): void {
-  if (!listed.has(name)) throw new ApiError(`${name} is not an entry metro offers to move`, 400);
-  const job = jobs.get(name)?.state;
-  if (job === 'copying' || job === 'waiting') throw new ApiError(`${name} is already being moved`, 409);
-  if (present(join(user.home, name))) throw new ApiError(`${name} already exists in ${user.home}`, 409);
-}
-
-export function startMove(names: unknown, user: AgentUser, mode: MoveMode = 'copy', from = homedir()): string[] {
-  const wanted = wantedNames(names);
-  const listed = new Set(candidates(from));
-  for (const name of wanted) assertMovable(name, listed, user);
-  if (mode === 'move' && !sameDisk(from, dirname(user.home))) throw new ApiError(`${from} is on another disk than ${user.home}; copy instead`, 400);
-  for (const name of wanted) {
-    jobs.set(name, { state: 'waiting', error: null });
-    queue = queue.then(async () => {
-      jobs.set(name, { state: 'copying', error: null });
-      await moveOne(name, user, from, mode).catch((err: unknown) => {
-        jobs.set(name, { state: 'failed', error: errMsg(err) });
-        log.warn({ name, err: errMsg(err) }, 'agent-user: could not move an entry to the agent user');
-      });
-    });
-  }
-  return wanted;
-}