@stage-labs/metro 0.1.0-beta.325 → 0.1.0-beta.326

package/dist/agent.js

@@ -9,7 +9,7 @@ import { withLock } from './lock.js';
 import { currentModel, permissionMode, systemPrompt } from './route.js';
 import { installDependencies, ranges, readOrNull } from './runtime-install.js';
 import { findBun, localPort, runtimeDir } from './runtime.js';
-export const RUNNER_SOURCES = 'sdk-runner';
+const RUNNER_SOURCES = 'sdk-runner';
 const STAMP = 'runner.json';
 const ENTRY = join('src', 'main.ts');
 const METRO_MODULES = join('node_modules', '@metro-labs');

package/dist/cli.js

@@ -93,7 +93,7 @@ async function run(command) {
     if (handler !== undefined)
         return handler();
     process.stderr.write(USAGE);
-    return Promise.resolve(HELP.has(command) ? 0 : 1);
+    return HELP.has(command) ? 0 : 1;
 }
 const code = await run(process.argv[2]).catch((err) => {
     const message = err instanceof Error ? err.message : String(err);

package/dist/lock.js

@@ -2,6 +2,7 @@ import { closeSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeSy
 import { dirname } from 'node:path';
 import { readOrNull } from './runtime-install.js';
 const pause = new Int32Array(new SharedArrayBuffer(4));
+const EMPTY_GRACE_MS = 5_000;
 export function processAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -13,9 +14,13 @@ export function processAlive(pid) {
 }
 function lockHeld(path, now, staleMs) {
     try {
-        if (now - statSync(path).mtimeMs >= staleMs)
+        const age = now - statSync(path).mtimeMs;
+        if (age >= staleMs)
             return false;
-        const pid = Number(readFileSync(path, 'utf8').trim());
+        const text = readFileSync(path, 'utf8').trim();
+        if (text === '')
+            return age < EMPTY_GRACE_MS;
+        const pid = Number(text);
         return !Number.isInteger(pid) || pid <= 0 || processAlive(pid);
     }
     catch (err) {
@@ -28,7 +33,14 @@ export function takeLock(path, staleMs, now = Date.now(), retry = true) {
     try {
         mkdirSync(dirname(path), { recursive: true });
         const fd = openSync(path, 'wx');
-        writeSync(fd, String(process.pid));
+        try {
+            writeSync(fd, String(process.pid));
+        }
+        catch (err) {
+            closeSync(fd);
+            rmSync(path, { force: true });
+            throw err;
+        }
         closeSync(fd);
         return true;
     }

package/dist/root-release-io.js

@@ -5,8 +5,7 @@ import { createRequire } from 'node:module';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { ISSUER, isRecord, isVersion, PUBLISHER, RELEASE_DIR } from './root-release.js';
-import { PACKAGE_NAME } from './version.js';
-const REGISTRY = 'https://registry.npmjs.org';
+import { PACKAGE_NAME, REGISTRY } from './version.js';
 const ENCODED = PACKAGE_NAME.replace('/', '%2F');
 const ROOT_PATH = '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin';
 const SETUP = join('runtime', 'node_modules', '@metro-labs', 'daemon', 'src', 'metro-user', 'install.ts');

package/dist/root-release.js

@@ -1,9 +1,8 @@
 import { createHash } from 'node:crypto';
-import { compareVersions, PACKAGE_NAME } from './version.js';
+import { compareVersions, PACKAGE_NAME, REGISTRY } from './version.js';
 export const RELEASE_DIR = '/usr/local/lib/metro/release';
 export const PUBLISHER = 'https://github.com/bonustrack/metro/.github/workflows/publish-cli.yml@refs/heads/main';
 export const ISSUER = 'https://token.actions.githubusercontent.com';
-const REGISTRY = 'https://registry.npmjs.org';
 const PROVENANCE = 'https://slsa.dev/provenance/v1';
 const IN_TOTO = 'application/vnd.in-toto+json';
 const VERSION_RE = /^\d{1,9}\.\d{1,9}\.\d{1,9}(?:-[0-9A-Za-z]{1,20}(?:\.[0-9A-Za-z]{1,20}){0,4})?$/;
@@ -27,7 +26,7 @@ function statementOf(bundle) {
         throw new Error('the provenance statement is unreadable; refused');
     return statement;
 }
-export function provenanceNames(statement, version, sha512) {
+function provenanceNames(statement, version, sha512) {
     const subjects = Array.isArray(statement.subject) ? statement.subject : [];
     return (statement.predicateType === PROVENANCE &&
         subjects.some((s) => isRecord(s) && s.name === subjectName(version) && isRecord(s.digest) && s.digest.sha512 === sha512));

package/dist/route.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentsDir } from './local.js';
-const PROVIDERS = new Set(['bedrock', 'openrouter', 'codex', 'gemini', 'routeway']);
+const PROVIDERS = new Set(['bedrock', 'openrouter', 'codex', 'routeway']);
 const ANTHROPIC = 'anthropic';
 const text = (value) => (typeof value === 'string' ? value : '');
 function routedIn(cfg) {

package/dist/service.js

@@ -126,7 +126,8 @@ function systemdPlan(host, serveArgs, runAs) {
         ],
     };
 }
-function launchdPlan(host, exec) {
+function launchdPlan(host, serveArgs) {
+    const exec = [host.node, host.cli, 'serve', ...serveArgs];
     const file = join(host.home, 'Library', 'LaunchAgents', `${LABEL}.plist`);
     const domain = `gui/${String(host.uid)}`;
     const logFile = join(cacheDir(host), 'metro', 'serve', 'service.log');
@@ -146,13 +147,12 @@ function launchdPlan(host, exec) {
     };
 }
 export function servicePlan(host, serveArgs, runAs) {
-    const exec = [host.node, host.cli, 'serve', ...serveArgs];
     if (runAs !== undefined && (host.platform !== 'linux' || host.uid !== 0))
         throw new Error('--user installs a system service for another user: run it as root on Linux');
     if (host.platform === 'linux')
         return systemdPlan(host, serveArgs, runAs);
     if (host.platform === 'darwin')
-        return launchdPlan(host, exec);
+        return launchdPlan(host, serveArgs);
     throw new Error(`metro service supports Linux (systemd) and macOS (launchd), not ${host.platform}`);
 }
 function splitUser(argv) {
@@ -287,7 +287,7 @@ function realDeps() {
                 const said = [result.stderr, result.stdout, result.error?.message].find((t) => typeof t === 'string' && t.trim() !== '') ?? '';
                 throw new Error(`${command.args.join(' ')} failed (exit ${String(code)}): ${said.trim()}`);
             }
-            return { status: code, output: `${result.stdout}${result.stderr}` };
+            return { status: code };
         },
         running: serveLockedBy,
         account: lookupAccount,

package/dist/version.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 export const PACKAGE_NAME = '@stage-labs/metro';
-const REGISTRY = 'https://registry.npmjs.org';
+export const REGISTRY = 'https://registry.npmjs.org';
 const TIMEOUT_MS = 15_000;
 export function parseVersion(raw) {
     const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(raw.trim());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.325",
+  "version": "0.1.0-beta.326",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/node_modules/@metro-labs/core/src/automation-store.ts

@@ -8,7 +8,7 @@ import {
 } from './automation-types.js';
 import { isRecord } from './is-record.js';
 
-export type { AutomationOutcome, AutomationRequest, AutomationResolution, AutomationStatus, AutomationState, AutomationUuid } from './automation-types.js';
+export type { AutomationOutcome, AutomationRequest, AutomationResolution, AutomationStatus } from './automation-types.js';
 
 function payload<T extends { uuid: string }>(row: unknown, parse: (value: unknown) => T): T {
   try {

package/runtime/node_modules/@metro-labs/core/src/automation-types.ts

@@ -5,7 +5,7 @@ export const AUTOMATION_PROMPT_MAX = 64 * 1024;
 const PROMPT_JSON_MAX = 128 * 1024 + 2;
 export const AUTOMATION_REQUEST_MAX = 512;
 export const AUTOMATION_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
-export const AUTOMATION_ROUTINE_RE = /^[a-z][a-z0-9-]{0,63}$/;
+const AUTOMATION_ROUTINE_RE = /^[a-z][a-z0-9-]{0,63}$/;
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const STATES = ['dispatched', 'consumed', 'awaiting-completion', 'completed', 'failed', 'interrupted', 'coalesced', 'cancelled'] as const;
 const DETAILS = ['sdk-completed', 'sdk-failed', 'runner-interrupted', 'newer-slot', 'owner-cancelled', 'worker-blocked', 'worker-completed'] as const;
@@ -29,7 +29,7 @@ const ERRORS = {
 
 export type AutomationUuid = `${string}-${string}-${string}-${string}-${string}`;
 export type AutomationState = (typeof STATES)[number];
-export type AutomationDetail = (typeof DETAILS)[number];
+type AutomationDetail = (typeof DETAILS)[number];
 export type AutomationOutcome = 'completed' | 'blocked';
 export type AutomationErrorCode = keyof typeof ERRORS;
 

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

@@ -2,8 +2,6 @@ export type Line = string & { readonly __line: unique symbol };
 export const asLine = (s: string): Line => s as Line;
 
 const PREFIX = 'metro://';
-const build = (station: string, ...seg: (string | number)[]): Line =>
-  asLine(`${PREFIX}${station}/${seg.map(String).join('/')}`);
 
 function parseAccountScoped(
   line: Line | string,
@@ -42,11 +40,7 @@ function parseTelegramLine(
 }
 
 export const Line = {
-  claude: (orgId: string, sessionId: string): Line =>
-    build('claude', orgId, sessionId),
-  webhook: (endpointId: string): Line => build('webhook', endpointId),
-  user: (station: string, id: string | number): Line =>
-    build(station, 'user', id),
+  webhook: (endpointId: string): Line => asLine(`${PREFIX}webhook/${endpointId}`),
 
   parse(line: Line | string): { station: string; path: string[] } | null {
     if (!line.startsWith(PREFIX)) return null;
@@ -68,7 +62,7 @@ export const Line = {
   parseDiscord: (line: Line | string) =>
     parseAccountScoped(line, 'discord-bot', isSnowflake),
 
-  parseTelegram: (line: Line | string) => parseTelegramLine(line),
+  parseTelegram: parseTelegramLine,
 
   parseThreema: (line: Line | string) =>
     parseAccountScoped(line, 'threema', isThreemaResource),

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

@@ -5,12 +5,6 @@ import { coerceErrorInfo, type TrainErrorInfo } from './train-error.js';
 import type { StructuredEvent } from './events.js';
 import type { CallMsg } from './stations/station-runtime.js';
 
-export {
-  TrainError,
-  serializeTrainError,
-  type TrainErrorInfo,
-} from './train-error.js';
-
 const CALL_TIMEOUT_MS = 60_000;
 
 export interface Pending {

package/runtime/node_modules/@metro-labs/core/src/skill-source.ts

@@ -15,7 +15,7 @@ export interface SkillSource {
   folder: string;
 }
 
-export interface SkillFile {
+interface SkillFile {
   path: string;
   size: number;
   sha256: string;

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

@@ -1,6 +1,6 @@
 import { isRecord } from '../is-record.js';
 
-export const ACCOUNT_STATES = ['connected', 'connecting', 'logged_out', 'disconnected'] as const;
+const ACCOUNT_STATES = ['connected', 'connecting', 'logged_out', 'disconnected'] as const;
 
 export type AccountState = (typeof ACCOUNT_STATES)[number];
 

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

@@ -1,3 +1,7 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
 export const attachDir = (): string =>
   process.env.METRO_XMTP_ATTACH_DIR ??
   `${process.env.HOME}/.cache/metro/messenger-uploads`;
@@ -89,14 +93,9 @@ const cachePathFor = async (
   index: number,
   meta: { mime?: string; name?: string },
 ): Promise<string> => {
-  const { mkdir } = await import('node:fs/promises');
-  const nodePath = await import('node:path');
   const dir = attachDir();
   await mkdir(dir, { recursive: true });
-  return nodePath.join(
-    dir,
-    cacheFileName(messageId, index, meta.name, meta.mime),
-  );
+  return join(dir, cacheFileName(messageId, index, meta.name, meta.mime));
 };
 
 export const saveBufferToCache = async (
@@ -106,8 +105,6 @@ export const saveBufferToCache = async (
   meta: { mime?: string; name?: string },
 ): Promise<SavedAttachment> => {
   assertAttachmentSize(data.length);
-  const { writeFile, rename, rm } = await import('node:fs/promises');
-  const { randomUUID } = await import('node:crypto');
   const path = await cachePathFor(messageId, index, meta);
   const part = `${await cachePathFor(randomUUID(), index, meta)}.part`;
   try {
@@ -125,7 +122,6 @@ export const saveStreamToCache = async (
   index: number,
   meta: { mime?: string; name?: string },
 ): Promise<SavedAttachment> => {
-  const { open, rename, rm } = await import('node:fs/promises');
   const path = await cachePathFor(messageId, index, meta);
   const part = `${path}.part`;
   const handle = await open(part, 'w');

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

@@ -14,7 +14,7 @@ export interface ChannelEntry {
   kind: 'direct' | 'group' | 'channel' | 'thread';
 }
 
-export interface ChannelCapability {
+interface ChannelCapability {
   supported: boolean;
   complete: boolean;
   source: 'remote' | 'local' | 'mixed' | 'unsupported';

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

@@ -1,4 +1,4 @@
-export const MAX_TEXT_CHARS = 20_000;
+const MAX_TEXT_CHARS = 20_000;
 
 const ENTITIES: Record<string, string> = {
   amp: '&',
@@ -52,9 +52,9 @@ export function tidy(text: string): string {
     .trim();
 }
 
-export function capText(text: string, max = MAX_TEXT_CHARS): string {
-  if (text.length <= max) return text;
-  return `${text.slice(0, max)}\n[... ${String(text.length - max)} more characters]`;
+export function capText(text: string): string {
+  if (text.length <= MAX_TEXT_CHARS) return text;
+  return `${text.slice(0, MAX_TEXT_CHARS)}\n[... ${String(text.length - MAX_TEXT_CHARS)} more characters]`;
 }
 
 export function bodyText(body: { contentType?: unknown; content?: unknown } | undefined): string {

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

@@ -1,4 +1,5 @@
 import { mintId } from '../ids.js';
+import { isRecord } from '../is-record.js';
 import { Line } from '../lines.js';
 import { TrainError } from '../train-error.js';
 import { capText } from './mail-text.js';
@@ -47,7 +48,7 @@ export interface ReadQuery {
   limit: number;
 }
 
-export const DEFAULT_LIMIT = 20;
+const DEFAULT_LIMIT = 20;
 export const MAX_LIMIT = 50;
 const SEEN_MAX = 500;
 const SUBJECT_MAX = 255;
@@ -160,7 +161,7 @@ export function subjectOf(station: MailStation, subject: string, text: string):
 
 export const filesOf = (raw: unknown): OutgoingFile[] =>
   (Array.isArray(raw) ? raw : [])
-    .map((a) => (a ?? {}) as Record<string, unknown>)
+    .filter(isRecord)
     .filter((a) => typeof a.path === 'string' && a.path !== '')
     .map((a) => ({
       path: String(a.path),

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

@@ -1,6 +1,6 @@
 type Args = Record<string, unknown>;
 
-export interface Normalized {
+interface Normalized {
   action: string;
   args: Args;
 }

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

@@ -36,7 +36,7 @@ export function pkcePair(verifier = randomBytes(32).toString('base64url')): Pkce
   return { verifier, challenge: createHash('sha256').update(verifier).digest('base64url') };
 }
 
-export const newState = (): string => randomBytes(24).toString('base64url');
+const newState = (): string => randomBytes(24).toString('base64url');
 
 export function parseMailbox(value: unknown): string | null {
   const mailbox = (typeof value === 'string' ? value.trim() : '').toLowerCase();

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

@@ -3,8 +3,8 @@ import { TrainError } from '../train-error.js';
 export const PROFILE_FIELDS = ['name', 'bio', 'avatar'] as const;
 export type ProfileField = (typeof PROFILE_FIELDS)[number];
 
-export const NAME_MAX = 64;
-export const BIO_MAX = 512;
+const NAME_MAX = 64;
+const BIO_MAX = 512;
 
 export interface ProfileAvatar {
   path: string;

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

@@ -82,7 +82,7 @@ export interface MemberOutcome {
   reason?: string;
 }
 
-export interface GroupCapability {
+interface GroupCapability {
   supported: boolean;
   reason?: string;
 }
@@ -98,7 +98,7 @@ export interface GroupResult {
 
 export type ReadFilter = 'account' | 'query' | 'from' | 'until' | 'unread_only' | 'message_id';
 
-export type AttachmentMode = 'canonical' | 'native' | 'none';
+type AttachmentMode = 'canonical' | 'native' | 'none';
 
 export interface Station {
   name: string;

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

@@ -1,3 +1,5 @@
+import { isRecord } from './is-record.js';
+
 export interface TrainErrorInfo {
   code: string;
   message: string;
@@ -41,10 +43,8 @@ export function serializeTrainError(err: unknown): {
   return { error: err instanceof Error ? err.message : String(err) };
 }
 
-export function coerceErrorInfo(v: unknown): TrainErrorInfo | undefined {
-  if (!v || typeof v !== 'object') return undefined;
-  const o = v as Record<string, unknown>;
-  if (typeof o.code !== 'string' || typeof o.message !== 'string')
+export function coerceErrorInfo(o: unknown): TrainErrorInfo | undefined {
+  if (!isRecord(o) || typeof o.code !== 'string' || typeof o.message !== 'string')
     return undefined;
   const info: TrainErrorInfo = { code: o.code, message: o.message };
   if (typeof o.retryable === 'boolean') info.retryable = o.retryable;

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

@@ -69,7 +69,8 @@ function parseFile(root: string, path: string, out: Buffer): FilesAnswer {
   return { root, path, kind: 'file', bytes, modifiedAt: stamp(Number(mtime)), ...preview(out.subarray(end + 1), bytes) };
 }
 
-function readAsAgent(user: AgentUser, path: string): FilesAnswer {
+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);
   const target = join(user.home, ...segmentsOf(path));
   const [file, argv] = asUser(user, 'sh', ['-c', SCRIPT, 'metro', target, String(PREVIEW_BYTES + 1)]);
   const run = spawnSync(file, argv, { stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024, timeout: 20_000 });
@@ -82,8 +83,3 @@ 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): 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/schedules.ts

@@ -1,6 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
 import type { AgentUser } from './user.js';
 import { helperRun, type RunResult } from './unit-files.js';
 
@@ -64,22 +65,21 @@ function listTimers(runner: Runner): Record<string, unknown>[] {
   }
 }
 
-const text = (v: unknown): string => (typeof v === 'string' ? v : '');
 const orRoot = (user: string | undefined): string => (user === undefined || user === '' ? 'root' : user);
 
 function timerJob(runner: Runner, t: Record<string, unknown>): ScheduledJob | null {
-  const unit = text(t.unit);
-  const service = text(t.activates);
+  const unit = stringOf(t.unit);
+  const service = stringOf(t.activates);
   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;
+  if (!stringOf(timer.FragmentPath).startsWith(`${UNIT_DIR}/`)) return null;
   const svc = showProps(runner, service, ['ExecStart', 'User', 'Result']);
-  const command = execArgv(text(svc.ExecStart)).join(' ');
+  const command = execArgv(stringOf(svc.ExecStart)).join(' ');
   return {
     id: `timer:${unit}`,
     kind: 'timer',
     name: unit.replace(/\.timer$/, ''),
-    schedule: calendarOf(`${text(timer.TimersCalendar)} ${text(timer.TimersMonotonic)}`),
+    schedule: calendarOf(`${stringOf(timer.TimersCalendar)} ${stringOf(timer.TimersMonotonic)}`),
     command,
     runsAs: orRoot(svc.User),
     next: stamp(t.next),

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

@@ -1,6 +1,4 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { runningAsMetro } from '../metro-user/privilege.js';
 
@@ -74,28 +72,6 @@ export const agentCommand = (command: readonly string[], extra: Record<string, s
   return [bin, ...argv];
 };
 
-const SDK_PACKAGE = '@anthropic-ai/claude-agent-sdk';
-
-export const CLAUDE_ENV: Readonly<Record<string, string>> = { DISABLE_AUTOUPDATER: '1' };
-
-let musl: boolean | null = null;
-
-function muslFirst(): boolean {
-  if (process.platform !== 'linux') return false;
-  if (musl === null) {
-    const report = process.report.getReport() as { header?: { glibcVersionRuntime?: string } };
-    musl = report.header?.glibcVersionRuntime === undefined;
-  }
-  return musl;
-}
-
-export function claudeBin(user = agentUser()): string {
-  const name = `${SDK_PACKAGE}-${process.platform}-${process.arch}`;
-  const packages = muslFirst() ? [`${name}-musl`, name] : [name, `${name}-musl`];
-  const [first = '', other = ''] = packages.map((pkg) => join(user?.home ?? homedir(), '.metro', 'sdk-runner', 'node_modules', pkg, 'claude'));
-  return existsSync(first) || !existsSync(other) ? first : other;
-}
-
 export const claudeHome = (user = agentUser()): string | null => (user === null ? null : user.home);
 
 export const agentViewDir = (user: AgentUser): string => join(user.home, '.metro', 'agents');

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

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { 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';
@@ -45,7 +45,7 @@ export function viewFiles(dir = agentsDir(), model: () => string | null = () =>
     ['agent.json', agentFile(dir)],
     ['model.json', model()],
   ]);
-  for (const name of COPIED) files.set(name, existsSync(join(dir, name)) ? readText(join(dir, name)) : null);
+  for (const name of COPIED) files.set(name, readText(join(dir, name)));
   for (const name of NEVER_COPIED) files.set(name, null);
   return files;
 }
@@ -58,7 +58,7 @@ export function syncAgentView(user: AgentUser | null = agentUser(), dir = agents
   let changed = 0;
   for (const [name, text] of viewFiles(dir)) {
     const path = join(target, name);
-    if (written.has(path) && written.get(path) === text) continue;
+    if (written.get(path) === text) continue;
     if (text === null) removeHome(path, false, user);
     else writeHomeText(path, text, 0o600, undefined, user);
     written.set(path, text);

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

@@ -6,13 +6,12 @@ import { ApiError } from '@metro-labs/http/api-error';
 import { isRecord } from '@metro-labs/core/is-record';
 import { parseId } from '@metro-labs/core/ids';
 import type { LoadedAccount, LoadedAgent } from '../stations/materialize.js';
-import { STATIONS } from '@metro-labs/core/station-names';
 import { approversOf } from './files.js';
+import { isStationName } from './account-attach.js';
 
 const AGENTS = '/api/agents';
 const RESTORE_PATH = `${AGENTS}/restore`;
 const BUNDLE_MAX = 2 * 1024 * 1024;
-const STATION_NAMES = new Set<string>(STATIONS);
 
 export interface AgentBundle {
   version: 1;
@@ -50,7 +49,7 @@ function parseMode(raw: unknown): ImportMode {
 const bad = (what: string): ApiError => new ApiError(`bundle: ${what}`, 400);
 
 function stationOf(raw: unknown): LoadedAccount {
-  if (!isRecord(raw) || typeof raw.station !== 'string' || !STATION_NAMES.has(raw.station))
+  if (!isRecord(raw) || !isStationName(raw.station))
     throw bad('a station is not a known station');
   if (typeof raw.id !== 'string' || !isRecord(raw.config)) throw bad('a station has no id or config');
   const allowlist = Array.isArray(raw.allowlist)
@@ -58,7 +57,7 @@ function stationOf(raw: unknown): LoadedAccount {
     : null;
   const policy = parsePolicy(raw.policy, `bundle ${raw.station}/${raw.id}`);
   return {
-    station: raw.station as LoadedAccount['station'],
+    station: raw.station,
     id: raw.id,
     allowlist,
     ...approversOf(raw.approvers),

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

@@ -33,8 +33,6 @@ interface Stored {
   file: AgentFile;
 }
 
-const missing = (): AgentAdminError => new AgentAdminError('no such agent', 404);
-
 function parseOwner(raw: string): string | null {
   const text = raw.trim();
   return isOrganizationId(text) ? text : null;
@@ -66,7 +64,7 @@ function save(stored: Stored): void {
 
 function agentOrThrow(id: string, dir: string): Stored {
   const found = storedAgents(dir).find((s) => s.file.id === id);
-  if (found === undefined) throw missing();
+  if (found === undefined) throw new AgentAdminError('no such agent', 404);
   return found;
 }
 
@@ -84,9 +82,8 @@ function freshId(taken: Set<string>): string {
 
 export async function localCreateAgent(rawName?: string, dir = agentsDir()): Promise<CreatedAgent> {
   const name = rawName === undefined ? null : normalizeAgentName(rawName);
-  const existing = storedAgents(dir);
-  if (existing.length > 0) throw new AgentAdminError('this box already has its agent', 409);
-  const id = freshId(new Set());
+  if (storedAgents(dir).length > 0) throw new AgentAdminError('this box already has its agent', 409);
+  const id = newId();
   const key = newApiKey();
   ensureSecureDir(dir);
   save({
@@ -228,9 +225,7 @@ export function localPairAgain(agentId: string, station: StationName, accountId:
 }
 
 export function readLocalAgentFile(agentId: string, dir = agentsDir()): AgentFile {
-  const found = storedAgents(dir).find((s) => s.file.id === agentId);
-  if (found === undefined) throw missing();
-  return found.file;
+  return agentOrThrow(agentId, dir).file;
 }
 
 const UNIQUE_CREDENTIALS: Record<string, string> = {

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

@@ -2,15 +2,14 @@ import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { AGENT_NAME_RE, ID_RE } from '@metro-labs/core/ids';
-import { STATIONS, type StationName } from '@metro-labs/core/station-names';
 import type { LoadedAccount, LoadedAgent, StationSource } from '../stations/materialize.js';
 import { isRecord } from '@metro-labs/core/is-record';
 import { parsePolicy } from '../policy/policy.js';
+import { isStationName } from './account-attach.js';
 
 const AGENT_FILE = 'agent.json';
 
 const KEY_RE = /^[A-Za-z0-9_-]{16,128}$/;
-const STATION_NAMES = new Set<string>(STATIONS);
 
 export class AgentFileError extends Error {}
 
@@ -35,10 +34,6 @@ function fail(path: string, reason: string): never {
   throw new AgentFileError(`${path}: ${reason}`);
 }
 
-function isStationName(value: unknown): value is StationName {
-  return typeof value === 'string' && STATION_NAMES.has(value);
-}
-
 function allowlistOf(raw: unknown, path: string, where: string): string[] | null {
   if (raw === null || raw === undefined) return null;
   if (!Array.isArray(raw)) fail(path, `${where}.allowlist is not a list of strings`);