@stage-labs/metro 0.1.0-beta.201 → 0.1.0-beta.202

package/runtime/node_modules/@metro-labs/core/src/stations/messaging-normalize.ts

@@ -1,88 +1,16 @@
 type Args = Record<string, unknown>;
+
 export interface Normalized {
   action: string;
   args: Args;
 }
 
-interface Attachment {
-  kind?: string;
-  path?: string;
-  url?: string;
-  data?: string;
-  mime?: string;
-  name?: string;
-}
-
-interface DiscordFile {
-  file: string;
-  kind: string;
-  name: string;
-}
-
-const discordFile = (a: Attachment): DiscordFile | null => {
-  const file = a.path ?? a.url;
-  if (typeof file !== 'string') return null;
-  return { file, kind: a.kind ?? 'file', name: a.name ?? '' };
-};
+export type Normalize = (action: string, args: Args) => Normalized;
 
-function discordAttachments(att: Attachment[]): Args {
-  const usable = att
-    .map(discordFile)
-    .filter((f): f is DiscordFile => f !== null);
-  if (!usable.length) return {};
-  return {
-    files: usable.map((f) => f.file),
-    attachmentKinds: usable.map((f) => f.kind),
-    attachmentNames: usable.map((f) => f.name),
+export const messagingAliases =
+  (removal: Args = { emoji: '' }): Normalize =>
+  (action, args) => {
+    if (action === 'reply') return { action: 'send', args };
+    if (action === 'unreact') return { action: 'react', args: { ...args, ...removal } };
+    return { action, args };
   };
-}
-
-export function normalizeDiscord(action: string, env: Args): Normalized {
-  const att = (env.attachments as Attachment[] | undefined) ?? [];
-  if (action === 'send') {
-    return { action: 'send', args: { ...env, ...discordAttachments(att) } };
-  }
-  if (action === 'reply') {
-    const replyTo = env.replyTo ?? env.messageId;
-    return {
-      action: 'send',
-      args: { ...env, replyTo, ...discordAttachments(att) },
-    };
-  }
-  if (action === 'unreact')
-    return { action: 'react', args: { ...env, emoji: '' } };
-  if (action === 'read') {
-    return {
-      action: 'fetch',
-      args: { line: env.line, limit: env.limit, before: env.before },
-    };
-  }
-  return { action, args: env };
-}
-
-export function normalizeTelegram(action: string, env: Args): Normalized {
-  if (action === 'reply') {
-    return {
-      action: 'send',
-      args: {
-        line: env.line,
-        text: env.text,
-        replyTo: env.replyTo,
-        attachments: env.attachments,
-      },
-    };
-  }
-  if (action === 'unreact')
-    return { action: 'react', args: { ...env, emoji: '' } };
-  return { action, args: env };
-}
-
-export function normalizeXmtp(action: string, env: Args): Normalized {
-  if (action === 'unreact') {
-    return { action: 'react', args: { ...env, action: 'removed' } };
-  }
-  if (action === 'read') {
-    return { action: 'query', args: { line: env.line, limit: env.limit } };
-  }
-  return { action, args: env };
-}

package/runtime/node_modules/@metro-labs/core/src/stations/station-runtime.ts

@@ -1,5 +1,5 @@
 import { serializeTrainError, type TrainErrorInfo } from '../train-error.js';
-import type { Normalized } from './messaging-normalize.js';
+import type { Normalize } from './messaging-normalize.js';
 
 export const emit = (e: unknown): void =>
   void process.stdout.write(JSON.stringify(e) + '\n');
@@ -27,7 +27,7 @@ export type StationHandler = (id: string, args: Args) => void | Promise<void>;
 
 export interface StationConfig {
   handlers: Record<string, StationHandler>;
-  normalize: (action: string, args: Args) => Normalized;
+  normalize?: Normalize;
 }
 
 const lineTag = (args: Args): string =>
@@ -40,15 +40,13 @@ export function makeStation({ handlers, normalize }: StationConfig) {
     let action = msg.action;
     let args: Args = msg.args;
     try {
-      ({ action, args } = normalize(msg.action, msg.args));
-      emit({ op: 'log', text: `call ${action} recv (line=${lineTag(args)})` });
+      if (normalize && !handlers[action]) ({ action, args } = normalize(action, args));
       const handler = handlers[action];
       if (!handler) {
         respond(id, { error: `unknown action '${action}' (have: ${known})` });
         return;
       }
       await handler(id, args);
-      emit({ op: 'log', text: `call ${action} done (line=${lineTag(args)})` });
     } catch (err) {
       const info = serializeTrainError(err);
       emit({

package/runtime/node_modules/@metro-labs/core/src/stations/train-events.ts

@@ -4,15 +4,11 @@ import { emit } from './station-runtime.js';
 type Fields = Record<string, unknown>;
 type Out = (e: unknown) => void;
 
-export const selfUri = (station: string, account?: string): string =>
-  process.env.METRO_SELF_URI ??
-  (account === undefined ? `metro://${station}/self` : `metro://${station}/${account}/self`);
+export const selfUri = (): string => process.env.METRO_SELF_URI ?? 'metro://user';
 
 export function emitInbound(account: string, e: Fields, out: Out = emit): void {
   out({
-    kind: 'inbound',
     ...e,
-    account,
     payload: { ...(e.payload as Fields | undefined), account },
   });
 }
@@ -30,18 +26,17 @@ export interface SavedFile {
   path: string;
   mime?: string;
   name?: string;
+  bytes?: number;
 }
 
 function attachmentEvent(at: AttachmentAt, text: string, payload: Fields): Fields {
   return {
-    kind: 'inbound',
     id: mintId(),
     ts: new Date().toISOString(),
     station: at.station,
     line: at.line,
-    from: at.from ?? selfUri(at.station, at.account),
+    from: at.from ?? selfUri(),
     text,
-    account: at.account,
     payload: { account: at.account, attachmentFor: at.forId, index: at.index, ...payload },
   };
 }
@@ -49,9 +44,9 @@ function attachmentEvent(at: AttachmentAt, text: string, payload: Fields): Field
 export const attachmentSavedEvent = (at: AttachmentAt & { saved: SavedFile; extra?: Fields }): Fields =>
   attachmentEvent(at, `📎 saved: ${at.saved.path}`, {
     contentType: 'attachmentSaved',
+    ...(at.saved.bytes === undefined ? {} : { size: at.saved.bytes }),
     ...at.extra,
     attachmentPath: at.saved.path,
-    localPath: at.saved.path,
     mime: at.saved.mime,
     name: at.saved.name,
   });

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

@@ -1,12 +1,11 @@
 import { spawnSync } from 'node:child_process';
-import { closeSync, openSync, readdirSync, readSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { ApiError } from '@metro-labs/http/api-error';
 import { asUser, type AgentUser } from './user.js';
 
-export type EntryKind = 'folder' | 'file' | 'other';
+type EntryKind = 'folder' | 'file' | 'other';
 
-export interface FileEntry {
+interface FileEntry {
   name: string;
   kind: EntryKind;
   bytes: number;
@@ -76,44 +75,15 @@ function readAsAgent(user: AgentUser, path: string): FilesAnswer {
   const run = spawnSync(file, argv, { stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024, timeout: 20_000 });
   if (run.error !== undefined) throw new ApiError(`could not read that path: ${run.error.message}`, 500);
   if (run.status !== 0) throw new ApiError(run.stderr.toString('utf8').trim() || 'the agent cannot read that path', 404);
-  const out = run.stdout;
-  const body = out.subarray(2);
-  return out.subarray(0, 1).toString() === 'D' ? folderAnswer(user.home, path, parseListing(body)) : parseFile(user.home, path, body);
-}
-
-function readHead(target: string): Buffer {
-  const fd = openSync(target, 'r');
-  try {
-    const buffer = Buffer.alloc(PREVIEW_BYTES + 1);
-    return buffer.subarray(0, readSync(fd, buffer, 0, buffer.length, 0));
-  } finally {
-    closeSync(fd);
-  }
+  return answerOf(user.home, path, run.stdout);
 }
 
-function readLocal(root: string, path: string): FilesAnswer {
-  const target = join(root, ...segmentsOf(path));
-  let stat;
-  try {
-    stat = statSync(target);
-  } catch {
-    throw new ApiError('no such file or folder', 404);
-  }
-  if (stat.isFile()) return { root, path, kind: 'file', bytes: stat.size, modifiedAt: stat.mtime.toISOString(), ...preview(readHead(target), stat.size) };
-  const entries = readdirSync(target, { withFileTypes: true }).map((entry): FileEntry => {
-    const inner = join(target, entry.name);
-    try {
-      const s = statSync(inner);
-      return { name: entry.name, kind: s.isDirectory() ? 'folder' : s.isFile() ? 'file' : 'other', bytes: s.size, modifiedAt: s.mtime.toISOString() };
-    } catch {
-      return { name: entry.name, kind: 'other', bytes: 0, modifiedAt: '' };
-    }
-  });
-  return folderAnswer(root, path, entries);
+export function answerOf(root: string, path: string, out: Buffer): FilesAnswer {
+  const body = out.subarray(2);
+  return out.subarray(0, 1).toString() === 'D' ? folderAnswer(root, path, parseListing(body)) : parseFile(root, path, body);
 }
 
-export function readAgentPath(user: AgentUser | null, path: string, localRoot?: string): FilesAnswer {
-  if (user !== null) return readAsAgent(user, path);
-  if (localRoot === undefined) throw new ApiError('Claude Code does not run as its own user on this machine, so there is no agent folder to show', 409);
-  return readLocal(localRoot, path);
+export function readAgentPath(user: AgentUser | null, path: string): FilesAnswer {
+  if (user === null) throw new ApiError('Claude Code does not run as its own user on this machine, so there is no agent folder to show', 409);
+  return readAsAgent(user, path);
 }

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

@@ -9,7 +9,7 @@ const DROP_IN = '11-metro-vault.conf';
 const BEGIN = '# metro vault: begin';
 const END = '# metro vault: end';
 
-export const jobEnvFile = (user: AgentUser): string => join(user.home, '.metro', 'vault.env');
+const jobEnvFile = (user: AgentUser): string => join(user.home, '.metro', 'vault.env');
 
 export function withCronEnv(lines: string[], env: Record<string, string>): string[] {
   const start = lines.indexOf(BEGIN);

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

@@ -1,14 +1,14 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from './agent-fs.js';
+import { existsSync } from './agent-fs.js';
 import { join } from 'node:path';
 import { chmodSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { errMsg, log } from '@metro-labs/core/log';
-import { isRecord } from '@metro-labs/core/is-record';
 import { copyIntoHome } from './home-fs.js';
 import { AGENT_NAME, agentMarketplaceDir, agentUser, agentUserExpected, asUser, claudeBin, forgetAgentUser, type AgentUser } from './user.js';
 import { watchAgentView } from './view.js';
-import { mustHelper, runningAsMetro } from '../metro-user/privilege.js';
+import { mustHelper } from '../metro-user/privilege.js';
+import { stagedPluginVersion } from '../claude/plugin-install.js';
 
 const INSTALL_MS = 10 * 60_000;
 const INSTALLER = 'curl -fsSL https://claude.ai/install.sh | bash';
@@ -27,21 +27,11 @@ function openMetroHome(): void {
 }
 
 function ensureUser(): AgentUser | null {
-  if (runningAsMetro()) {
-    mustHelper(['ensure-agent']);
-    openMetroHome();
-    forgetAgentUser();
-    const user = agentUser();
-    if (user !== null) run(...asUser(user, 'chmod', ['711', user.home]));
-    return user;
-  }
-  if (agentUser() === null) {
-    run('useradd', ['--create-home', '--shell', '/bin/bash', AGENT_NAME]);
-    log.info({ user: AGENT_NAME }, 'agent-user: created the user Claude Code runs as');
-    forgetAgentUser();
-  }
+  mustHelper(['ensure-agent']);
+  openMetroHome();
+  forgetAgentUser();
   const user = agentUser();
-  if (user !== null) run('chmod', ['700', user.home]);
+  if (user !== null) run(...asUser(user, 'chmod', ['711', user.home]));
   return user;
 }
 
@@ -64,23 +54,14 @@ function installClaude(user: AgentUser): Promise<void> {
   });
 }
 
-const pluginVersion = (dir: string): string | null => {
-  try {
-    const parsed: unknown = JSON.parse(readFileSync(join(dir, 'plugin', '.claude-plugin', 'plugin.json'), 'utf8'));
-    return isRecord(parsed) && typeof parsed.version === 'string' ? parsed.version : null;
-  } catch {
-    return null;
-  }
-};
-
 function copyMarketplace(user: AgentUser, env: NodeJS.ProcessEnv): void {
   const store = env.METRO_RUNTIME_STORE?.trim() ?? '';
   const from = join(store, 'marketplace');
   if (store === '' || !existsSync(join(from, '.claude-plugin', 'marketplace.json'))) return;
   const to = agentMarketplaceDir(user);
-  if (pluginVersion(from) !== null && pluginVersion(from) === pluginVersion(to)) return;
+  if (stagedPluginVersion(from) !== null && stagedPluginVersion(from) === stagedPluginVersion(to)) return;
   const files = copyIntoHome(from, to, user);
-  log.info({ files, version: pluginVersion(from) }, 'agent-user: copied the metro plugin where the agent user can load it');
+  log.info({ files, version: stagedPluginVersion(from) }, 'agent-user: copied the metro plugin where the agent user can load it');
 }
 
 export async function provisionAgentUser(env: NodeJS.ProcessEnv = process.env): Promise<Provisioned> {

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

@@ -87,7 +87,6 @@ export function scheduleDetail(id: string, user: AgentUser | null, runner: Runne
 
 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);

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

@@ -1,7 +1,7 @@
 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 { listSchedules } from './schedules.js';
 import { runNow, scheduleDetail } from './schedule-detail.js';
 import { agentUser } from './user.js';
 
@@ -18,8 +18,8 @@ async function answer(req: IncomingMessage): Promise<unknown> {
   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) };
+  if (bodyField(body, 'action') !== 'run') throw new ApiError('action must be run', 400);
+  return { job: runNow(id, user) };
 }
 
 export function handleSchedulesRequest(req: IncomingMessage, res: ServerResponse): boolean {

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

@@ -1,20 +1,13 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-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 { errMsg, log } from '@metro-labs/core/log';
-import { asUser, type AgentUser } from './user.js';
-import { metroRun, writeDropIn } from './unit-files.js';
+import type { AgentUser } from './user.js';
+import { helperRun } from './unit-files.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)$/;
 
-export type JobKind = 'timer' | 'cron-root' | 'cron-agent';
+type JobKind = 'timer' | 'cron-agent';
 
 export interface ScheduledJob {
   id: string;
@@ -26,9 +19,6 @@ export interface ScheduledJob {
   next: string | null;
   last: string | null;
   lastResult: string | null;
-  usesRoot: boolean;
-  converted: boolean;
-  problem?: string | null;
 }
 
 export interface Runner {
@@ -37,17 +27,13 @@ export interface Runner {
 
 export const realRunner: Runner = {
   run: (file, args, input) => {
-    const viaHelper = metroRun(file, args, input);
+    const viaHelper = helperRun(file, args, input);
     if (viaHelper !== null) return viaHelper;
     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 ?? '' };
   },
 };
 
-const ROOT_RE = /(^|[\s="'=:])\/root(?=\/|$|[\s"';:])/;
-export const usesRootHome = (text: string): boolean => ROOT_RE.test(text);
-export const rehome = (text: string, home: string): string => text.replace(/(^|[\s="'=:])\/root(?=\/|$|[\s"';:])/g, `$1${home}`);
-
 const stamp = (micros: unknown): string | null =>
   typeof micros === 'number' && micros > 0 ? new Date(micros / 1000).toISOString() : null;
 
@@ -61,7 +47,7 @@ export function showProps(runner: Runner, unit: string, props: string[]): Record
   return found;
 }
 
-export function execArgv(execStart: string): string[] {
+function execArgv(execStart: string): string[] {
   const m = /argv\[\]=(.*?) ;/.exec(execStart);
   return m?.[1] === undefined ? [] : m[1].split(' ').filter((a) => a !== '');
 }
@@ -87,7 +73,7 @@ function timerJob(runner: Runner, t: Record<string, unknown>): ScheduledJob | nu
   if (unit === '' || service === '' || OWN_UNITS.test(service)) return null;
   const timer = showProps(runner, unit, ['FragmentPath', 'TimersCalendar', 'TimersMonotonic']);
   if (!text(timer.FragmentPath).startsWith(`${UNIT_DIR}/`)) return null;
-  const svc = showProps(runner, service, ['ExecStart', 'User', 'Result', 'DropInPaths', 'Environment', 'WorkingDirectory']);
+  const svc = showProps(runner, service, ['ExecStart', 'User', 'Result']);
   const command = execArgv(text(svc.ExecStart)).join(' ');
   return {
     id: `timer:${unit}`,
@@ -99,8 +85,6 @@ function timerJob(runner: Runner, t: Record<string, unknown>): ScheduledJob | nu
     next: stamp(t.next),
     last: stamp(t.last),
     lastResult: svc.Result ?? null,
-    usesRoot: usesRootHome(`${command} ${text(svc.Environment)} ${text(svc.WorkingDirectory)}`),
-    converted: text(svc.DropInPaths).includes(DROP_IN),
   };
 }
 
@@ -148,105 +132,13 @@ function cronJobs(runner: Runner, user: string, kind: JobKind): ScheduledJob[] {
       next: null,
       last: null,
       lastResult: null,
-      usesRoot: usesRootHome(parsed.command),
-      converted: false,
     }];
   });
 }
 
 function allJobs(user: AgentUser | null, runner: Runner): ScheduledJob[] {
-  return [...timerJobs(runner), ...cronJobs(runner, 'root', 'cron-root'), ...(user === null ? [] : cronJobs(runner, user.name, 'cron-agent'))];
-}
-
-const quote = (arg: string): string => `"${arg.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
-
-export function dropInText(user: AgentUser, argv: string[], environment: string): string {
-  const env = environment.split(' ').filter((pair) => pair.includes('=') && !pair.startsWith('HOME=') && !pair.startsWith('PATH='));
-  return [
-    '[Service]',
-    `User=${user.name}`,
-    `Group=${String(user.gid)}`,
-    `WorkingDirectory=${user.home}`,
-    `Environment=HOME=${user.home}`,
-    `Environment=PATH=${user.home}/.local/bin:/usr/local/bin:/usr/bin:/bin`,
-    ...env.map((pair) => `Environment=${quote(rehome(pair, user.home))}`),
-    'ExecStart=',
-    `ExecStart=${argv.map((a) => quote(rehome(a, user.home))).join(' ')}`,
-    '',
-  ].join('\n');
-}
-
-function agentSees(user: AgentUser, path: string): boolean {
-  if (existsSync(path)) return true;
-  const [file, args] = asUser(user, 'test', ['-e', path]);
-  return spawnSync(file, args, { stdio: 'ignore' }).status === 0;
-}
-
-function convertTimer(job: ScheduledJob, user: AgentUser, runner: Runner): void {
-  const unit = job.id.slice('timer:'.length);
-  const service = showProps(runner, unit, ['Unit']).Unit ?? unit.replace(/\.timer$/, '.service');
-  const svc = showProps(runner, service, ['ExecStart', 'Environment']);
-  const argv = execArgv(svc.ExecStart ?? '');
-  if (argv.length === 0) throw new ApiError('that timer runs no command metro can read', 400);
-  const missing = argv.map((a) => rehome(a, user.home)).find((a) => a.startsWith(`${user.home}/`) && !agentSees(user, a));
-  if (missing !== undefined) throw new ApiError(`${missing} does not exist; move it to the agent first`, 409);
-  writeDropIn(service, DROP_IN, dropInText(user, argv, svc.Environment ?? ''));
-  runner.run('systemctl', ['daemon-reload']);
-  log.info({ unit, service, user: user.name }, 'schedules: a timer now runs as the agent user');
-}
-
-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);
-  if (line === undefined) throw new ApiError('that cron line is gone', 404);
-  mkdirSync(backups, { recursive: true });
-  writeFileSync(join(backups, `crontab-root.${new Date().toISOString().replace(/[:.]/g, '-')}.bak`), lines.join('\n'), { mode: 0o600 });
-  const agentLines = crontabOf(runner, user.name).filter((l) => l !== '');
-  const moved = runner.run('crontab', ['-u', user.name, '-'], `${[...agentLines, rehome(line, user.home)].join('\n')}\n`);
-  if (moved.status !== 0) throw new ApiError("the agent's crontab refused the line", 500);
-  const kept = lines.filter((l) => l !== line && l !== '');
-  runner.run('crontab', ['-u', 'root', '-'], `${kept.join('\n')}\n`);
-  log.info({ user: user.name }, "schedules: a root cron line moved to the agent's crontab");
-}
-
-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);
-}
-
-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;
+  return [...timerJobs(runner), ...(user === null ? [] : cronJobs(runner, user.name, 'cron-agent'))];
 }
 
 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 (needsAgent(job)) toAgent(job, user, backups, runner);
-  problems.delete(id);
-  return listSchedules(user, runner);
-}
+  allJobs(user, runner).filter((job) => job.runsAs !== 'root');

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

@@ -1,61 +1,37 @@
 import { spawnSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { mustHelper, rootHelper, runningAsMetro } from '../metro-user/privilege.js';
+import { mustHelper, rootHelper } from '../metro-user/privilege.js';
 import { agentUser, asUser } from './user.js';
 
 const UNIT_DIR = '/etc/systemd/system';
 
 export function writeDropIn(service: string, name: string, text: string): void {
-  if (runningAsMetro()) {
-    mustHelper(['dropin-write', service, name], text);
-    return;
-  }
-  mkdirSync(join(UNIT_DIR, `${service}.d`), { recursive: true });
-  writeFileSync(join(UNIT_DIR, `${service}.d`, name), text, { mode: 0o644 });
+  mustHelper(['dropin-write', service, name], text);
 }
 
 export function removeDropIn(service: string, name: string): boolean {
-  const file = join(UNIT_DIR, `${service}.d`, name);
-  if (!existsSync(file)) return false;
-  if (runningAsMetro()) mustHelper(['dropin-remove', service, name]);
-  else rmSync(file, { force: true });
+  if (!existsSync(join(UNIT_DIR, `${service}.d`, name))) return false;
+  mustHelper(['dropin-remove', service, name]);
   return true;
 }
 
-const lineHash = (line: string): string => createHash('sha256').update(line.trim()).digest('hex').slice(0, 16);
-
-function asAgentRun(args: string[], input?: string): { status: number | null; stdout: string } {
-  const [file, argv] = asUser(agentUser(), 'crontab', args);
+function agentCrontab(args: string[], input?: string): { status: number | null; stdout: string } {
+  const at = args.indexOf('-u');
+  const rest = at < 0 ? args : args.filter((_, i) => i !== at && i !== at + 1);
+  const [file, argv] = asUser(agentUser(), 'crontab', rest);
   const run = spawnSync(file, argv, { encoding: 'utf8', input, stdio: ['pipe', 'pipe', 'ignore'], timeout: 20_000 });
   return { status: run.error === undefined ? run.status : null, stdout: run.stdout ?? '' };
 }
 
-function rootCrontabWrite(input: string): { status: number | null; stdout: string } {
-  const wanted = new Set(input.split('\n').filter((l) => l.trim() !== '').map(lineHash));
-  const current = rootHelper(['root-crontab']).stdout.split('\n').filter((l) => l.trim() !== '');
-  for (const line of current) if (!wanted.has(lineHash(line))) mustHelper(['root-crontab-drop', lineHash(line)]);
-  return { status: 0, stdout: '' };
-}
-
-function crontab(args: string[], input?: string): { status: number | null; stdout: string } {
-  const at = args.indexOf('-u');
-  const who = at >= 0 ? args[at + 1] : undefined;
-  const rest = args.filter((_, i) => i !== at && i !== at + 1);
-  if (who === 'root') return rest[0] === '-l' ? { status: 0, stdout: rootHelper(['root-crontab']).stdout } : rootCrontabWrite(input ?? '');
-  return asAgentRun(rest, input);
-}
-
 function systemctl(args: string[]): { status: number | null; stdout: string } | null {
   if (args[0] === 'daemon-reload') return { status: rootHelper(['daemon-reload']).status, stdout: '' };
   if (args[0] === 'start') return { status: rootHelper(['start-job', args[args.length - 1] ?? '']).status, stdout: '' };
   return null;
 }
 
-export function metroRun(file: string, args: string[], input?: string): { status: number | null; stdout: string } | null {
-  if (!runningAsMetro()) return null;
-  if (file === 'crontab') return crontab(args, input);
+export function helperRun(file: string, args: string[], input?: string): { status: number | null; stdout: string } | null {
+  if (file === 'crontab') return agentCrontab(args, input);
   if (file === 'systemctl') return systemctl(args);
   return null;
 }