@stage-labs/metro 0.1.0-beta.173 → 0.1.0-beta.174

package/dist/api.js

@@ -1,9 +1,11 @@
-import { localAgents, localDaemonUp, pickLocalAgent } from './local.js';
+import { localAgent, localDaemonUp } from './local.js';
 import { localUrl } from './runtime.js';
 const NO_DAEMON = `no metro daemon on ${localUrl()} — start one with: metro serve`;
-export async function whoisAuthorized(wanted) {
+export async function whoisAuthorized() {
     if (!(await localDaemonUp()))
         throw new Error(NO_DAEMON);
-    const agent = pickLocalAgent(localAgents(), wanted);
-    return { agent: agent.name, where: localUrl() };
+    const agent = localAgent();
+    if (agent === null)
+        throw new Error('no agent on this machine yet');
+    return { agent: agent.id, where: localUrl() };
 }

package/dist/claude.js

@@ -3,7 +3,7 @@ import { markOnboardingDone, seedChannels } from './onboarding.js';
 import { writeMcpConfig } from './mcp-config.js';
 import { currentRoute, permissionMode, routeModelEnv, systemPrompt } from './route.js';
 import { settingsConflicts, settingsFiles } from './claude-settings.js';
-import { localAgents, pickLocalAgent } from './local.js';
+import { localAgent } from './local.js';
 import { PROVIDER_FLAGS } from './provider-flags.js';
 import { localPort, localUrl } from './runtime.js';
 const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
@@ -76,27 +76,8 @@ async function daemonServing(base = localUrl()) {
         return false;
     }
 }
-export function agentKey(agents, wanted) {
-    if (agents.length === 0)
-        return { skip: 'no agent lives on this machine yet, so Claude Code talks to Anthropic directly' };
-    try {
-        return { key: pickLocalAgent(agents, wanted).key };
-    }
-    catch {
-        return {
-            skip: wanted === undefined || wanted === ''
-                ? 'this box has no agent yet (or several old ones), so Claude Code talks to Anthropic directly for now'
-                : `no agent named '${wanted}' lives here, so Claude Code talks to Anthropic directly`,
-        };
-    }
-}
-function localAgentList() {
-    try {
-        return localAgents();
-    }
-    catch {
-        return [];
-    }
+export function agentKey(agent) {
+    return agent === null ? { skip: 'no agent lives on this machine yet, so Claude Code talks to Anthropic directly' } : { key: agent.key };
 }
 async function verdict() {
     const pinned = pinnedBy(process.env);
@@ -105,7 +86,7 @@ async function verdict() {
     const conflicts = settingsConflicts(settingsFiles());
     if (conflicts.length > 0)
         return { skip: `a settings file pins the provider (${conflicts.join(', ')}), so Claude Code keeps it` };
-    const picked = agentKey(localAgentList(), undefined);
+    const picked = agentKey(localAgent());
     if ('skip' in picked)
         return picked;
     if (await daemonServing())
@@ -131,7 +112,7 @@ export function runClaude(args, env) {
 async function servedKey(decision) {
     if ('key' in decision)
         return decision.key;
-    const picked = agentKey(localAgentList(), undefined);
+    const picked = agentKey(localAgent());
     if ('skip' in picked)
         return null;
     return (await daemonServing()) ? picked.key : null;

package/dist/cli.js

@@ -22,7 +22,7 @@ const USAGE = `metro — run your agent on this machine
                   starts at boot and after a crash, so the page can stop, start and
                   restart it with no shell; metro service uninstall and status as well
   metro stop      stop metro on this machine, metro serve included
-  metro tail <agent-id>
+  metro tail [agent-id]
                   follow this machine's inbound events, one JSON line each
   metro whoami    print the agent this machine runs
   metro claude [args...]
@@ -53,8 +53,8 @@ async function stopDaemon() {
 const HELP = new Set([undefined, 'help', '--help', '-h']);
 const COMMANDS = {
     whoami: async () => {
-        const { agent, where } = await whoisAuthorized(process.argv[3]);
-        process.stdout.write(`agent '${agent}' on ${where}\n`);
+        const { agent, where } = await whoisAuthorized();
+        process.stdout.write(`agent ${agent} on ${where}\n`);
         return 0;
     },
     serve: () => serve(process.argv.slice(3)),

package/dist/local.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { localUrl } from './runtime.js';
@@ -7,64 +7,30 @@ export function agentsDir() {
     const explicit = process.env.METRO_AGENTS_DIR?.trim();
     return explicit !== undefined && explicit !== '' ? explicit : join(homedir(), '.metro', 'agents');
 }
-function agentFiles(dir) {
-    const fixed = join(dir, 'agent.json');
-    if (existsSync(fixed))
-        return [fixed];
-    if (!existsSync(dir))
-        return [];
-    return readdirSync(dir, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => join(dir, entry.name, 'agent.json'))
-        .filter((path) => existsSync(path));
-}
-export function localAgents(dir = agentsDir()) {
-    const out = [];
-    for (const path of agentFiles(dir)) {
-        try {
-            const file = JSON.parse(readFileSync(path, 'utf8'));
-            if (typeof file.id === 'string' && typeof file.key === 'string')
-                out.push({ id: file.id, name: typeof file.name === 'string' ? file.name : 'agent', key: file.key });
-        }
-        catch {
-            continue;
-        }
+function agentFile(dir) {
+    try {
+        return JSON.parse(readFileSync(join(dir, 'agent.json'), 'utf8'));
+    }
+    catch {
+        return null;
     }
-    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function localAgent(dir = agentsDir()) {
+    const file = agentFile(dir);
+    return typeof file?.id === 'string' && typeof file.key === 'string' ? { id: file.id, key: file.key } : null;
 }
 export function localStations(dir = agentsDir()) {
+    const stations = agentFile(dir)?.stations;
+    if (!Array.isArray(stations))
+        return [];
     const out = new Set();
-    for (const path of agentFiles(dir)) {
-        try {
-            const file = JSON.parse(readFileSync(path, 'utf8'));
-            if (!Array.isArray(file.stations))
-                continue;
-            for (const s of file.stations) {
-                const station = s.station;
-                if (typeof station === 'string')
-                    out.add(station);
-            }
-        }
-        catch {
-            continue;
-        }
+    for (const s of stations) {
+        const station = s.station;
+        if (typeof station === 'string')
+            out.add(station);
     }
     return [...out].sort();
 }
-export function pickLocalAgent(agents, wanted) {
-    if (wanted !== undefined && wanted !== '') {
-        const found = agents.find((a) => a.name === wanted || a.id === wanted);
-        if (found === undefined)
-            throw new Error(`no local agent named '${wanted}'`);
-        return found;
-    }
-    const only = agents[0];
-    if (only !== undefined && agents.length === 1)
-        return only;
-    throw new Error(agents.length === 0
-        ? 'no agent on this machine yet'
-        : `several agents on this machine — name one: ${agents.map((a) => a.name).join(', ')}`);
-}
 export async function localDaemonUp(base = localUrl()) {
     try {
         const res = await fetch(`${base}/api/mode`, { signal: AbortSignal.timeout(PROBE_MS) });

package/dist/serve.js

@@ -8,7 +8,7 @@ import { findBun, localPort, spawnPlan } from './runtime.js';
 import { prepareRuntime } from './runtime-install.js';
 import { ensureNodeName } from './node-name.js';
 import { holdUntilStart } from './hold.js';
-const SCRUBBED = new Set(['METRO_RUN_TOKEN', 'METRO_AGENT', 'DATABASE_URL']);
+const SCRUBBED = new Set(['DATABASE_URL']);
 const PORT_FLAG = /^--port=(.*)$/;
 const OWNER_FLAG = /^--owner=(.*)$/;
 const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
@@ -24,14 +24,14 @@ function portOf(raw) {
 const ORGANIZATION = /^org_[A-Za-z0-9]{10,64}$/;
 function ownerOf(raw) {
     if (raw !== undefined && ORGANIZATION.test(raw))
-        return raw;
-    if (raw === undefined || !ADDRESS.test(raw))
-        throw new Error(`'${raw ?? ''}' is neither an organization id (org_…) nor an Ethereum address — ${USAGE}`);
-    return raw.toLowerCase();
+        return { owner: raw };
+    if (raw !== undefined && ADDRESS.test(raw))
+        return { owner: null, ignoredOwner: raw };
+    throw new Error(`'${raw ?? ''}' is not an organization id (org_…) — ${USAGE}`);
 }
 export function parseServeArgs(argv) {
     let port = localPort();
-    let owner = null;
+    let owner = { owner: null };
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i] ?? '';
         if (TUNNEL_FLAG.test(arg))
@@ -58,10 +58,14 @@ export function parseServeArgs(argv) {
         }
         throw new Error(`unknown argument '${arg}' — ${USAGE}`);
     }
-    return { port, owner };
+    return { port, ...owner };
 }
-export function requireOwner(owner, dir = agentsDir()) {
-    if (owner !== null || existsSync(join(dir, '.owner')))
+export function requireOwner(args, dir = agentsDir()) {
+    if (args.ignoredOwner !== undefined) {
+        process.stderr.write(`--owner ${args.ignoredOwner} is a wallet address, which metro ignores: the organization id in ${join(dir, '.owner')} decides who signs in\n`);
+        return;
+    }
+    if (args.owner !== null || existsSync(join(dir, '.owner')))
         return;
     throw new Error('no owner is set for this machine, so nobody could sign in.\n' +
         'Pass the organization that owns it once; it is remembered in ' +
@@ -71,9 +75,7 @@ export function requireOwner(owner, dir = agentsDir()) {
 export function readOwner(dir = agentsDir()) {
     try {
         const raw = readFileSync(join(dir, '.owner'), 'utf8').trim();
-        if (ORGANIZATION.test(raw))
-            return raw;
-        return ADDRESS.test(raw.toLowerCase()) ? raw.toLowerCase() : null;
+        return ORGANIZATION.test(raw) ? raw : null;
     }
     catch {
         return null;
@@ -142,12 +144,13 @@ export function servePlan(opts) {
     };
 }
 export function serve(argv) {
-    const { port, owner } = parseServeArgs(argv);
+    const args = parseServeArgs(argv);
+    const { port, owner } = args;
     const running = serveLockedBy();
     if (running !== null)
         throw new Error(`a metro serve daemon is already running on this machine (pid ${String(running)}). ` +
             'Stop it first: metro stop');
-    requireOwner(owner);
+    requireOwner(args);
     const tailscaleBin = findTailscale();
     const node = ensureNodeName(tailscaleBin);
     process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}, published as ${node} on your tailnet\n`);

package/dist/service.js

@@ -126,13 +126,13 @@ export function servicePlan(host, serveArgs) {
     throw new Error(`metro service supports Linux (systemd) and macOS (launchd), not ${host.platform}`);
 }
 function install(serveArgs, deps) {
-    const { owner } = parseServeArgs(serveArgs);
+    const args = parseServeArgs(serveArgs);
     const plan = servicePlan(deps.host, serveArgs);
     if (deps.exists(plan.file)) {
         deps.out(`metro is already installed as a ${plan.kind} service (${plan.file}) and restarts on its own; metro service status says whether it is running. To change its arguments: metro service uninstall, then install again`);
         return 0;
     }
-    deps.preflight(owner);
+    deps.preflight(args);
     const pid = deps.running();
     if (pid !== null)
         throw new Error(`a metro serve is running on this machine (pid ${String(pid)}). Stop it first (metro stop), then install: the service takes over from there`);
@@ -209,8 +209,8 @@ function realDeps() {
             return { status: code, output: `${result.stdout}${result.stderr}` };
         },
         running: serveLockedBy,
-        preflight: (owner) => {
-            requireOwner(owner);
+        preflight: (args) => {
+            requireOwner(args);
             findBun();
             findTailscale();
         },

package/dist/tail.js

@@ -1,4 +1,4 @@
-import { localAgents } from './local.js';
+import { localAgent } from './local.js';
 import { assertAgentId, localUrl } from './runtime.js';
 const BACKOFF_MS = [1_000, 2_000, 5_000];
 const STALL_MS = 90_000;
@@ -22,9 +22,9 @@ function keySource(agentId) {
         return { resolve: () => Promise.resolve(fromEnv), fixed: true };
     return {
         resolve: () => {
-            const agent = localAgents().find((a) => a.id === agentId);
-            if (agent === undefined)
-                throw new Error(`no agent ${agentId} on this machine — create or restore it in the web UI of metro serve, or set METRO_AGENT_KEY`);
+            const agent = localAgent();
+            if (agent === null || (agentId !== undefined && agent.id !== agentId))
+                throw new Error(`no agent ${agentId === undefined ? '' : `${agentId} `}on this machine — start metro serve, or set METRO_AGENT_KEY`);
             return Promise.resolve(agent.key);
         },
         fixed: false,
@@ -89,7 +89,7 @@ function note(state, message) {
     process.stderr.write(`metro: ${message}\n`);
 }
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function settle(end, source, key, agentId, state) {
+async function settle(end, source, key, state) {
     if (end === 'unauthorized') {
         if (source.fixed)
             throw new Error('the key in METRO_AGENT_KEY was refused by the local daemon');
@@ -97,13 +97,13 @@ async function settle(end, source, key, agentId, state) {
         return source.resolve();
     }
     if (end === 'unreachable')
-        note(state, `no metro daemon on ${localUrl()} — run 'metro serve' (agent ${agentId})`);
+        note(state, `no metro daemon on ${localUrl()} — run 'metro serve'`);
     else
         note(state, 'stream ended — reconnecting');
     return key;
 }
 export async function tailEvents(argv) {
-    const agentId = assertAgentId(argv[0]);
+    const agentId = argv[0] === undefined ? undefined : assertAgentId(argv[0]);
     const source = keySource(agentId);
     let key = await source.resolve();
     const state = { last: '' };
@@ -112,7 +112,7 @@ export async function tailEvents(argv) {
         const end = await streamOnce(key);
         if (end === 'ended')
             attempt = 0;
-        key = await settle(end, source, key, agentId, state);
+        key = await settle(end, source, key, state);
         await delay(backoffAt(attempt));
         attempt += 1;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.173",
+  "version": "0.1.0-beta.174",
   "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.173",
+  "version": "0.1.0-beta.174",
   "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/marketplace/plugin/bin/metro-plugin.mjs

@@ -1,30 +1,20 @@
 #!/usr/bin/env node
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
 const agentsDir = () => process.env.METRO_AGENTS_DIR || join(homedir(), '.metro', 'agents');
 
-function readAgent(path) {
+function readAgent() {
+  const path = join(agentsDir(), 'agent.json');
+  let parsed;
   try {
-    const parsed = JSON.parse(readFileSync(path, 'utf8'));
-    return typeof parsed?.key === 'string' ? parsed : null;
+    parsed = JSON.parse(readFileSync(path, 'utf8'));
   } catch {
-    return null;
+    throw new Error(`no agent on this machine yet (${path})`);
   }
-}
-
-function pickAgent() {
-  const dir = agentsDir();
-  const fixed = readAgent(join(dir, 'agent.json'));
-  if (fixed !== null) return fixed;
-  if (!existsSync(dir)) throw new Error(`no agent on this machine yet (${dir})`);
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const found = readAgent(join(dir, entry.name, 'agent.json'));
-    if (found !== null) return found;
-  }
-  throw new Error(`no agent on this machine yet (${dir})`);
+  if (typeof parsed?.key !== 'string') throw new Error(`no agent key in ${path}`);
+  return parsed;
 }
 
 if (process.argv[2] !== 'headers') {
@@ -33,7 +23,7 @@ if (process.argv[2] !== 'headers') {
 }
 
 try {
-  process.stdout.write(`${JSON.stringify({ Authorization: `Bearer ${pickAgent().key}` })}\n`);
+  process.stdout.write(`${JSON.stringify({ Authorization: `Bearer ${readAgent().key}` })}\n`);
 } catch (err) {
   process.stderr.write(`metro: ${err.message}\n`);
   process.stdout.write('{}\n');

package/runtime/node_modules/@metro-labs/core/package.json

@@ -7,7 +7,6 @@
   "exports": {
     "./log": "./src/log.ts",
     "./events": "./src/events.ts",
-    "./identity": "./src/identity.ts",
     "./is-record": "./src/is-record.ts",
     "./secure-fs": "./src/secure-fs.ts",
     "./version": "./src/version.ts",
@@ -15,7 +14,6 @@
     "./trains/protocol": "./src/protocol.ts",
     "./ids": "./src/ids.ts",
     "./tickets": "./src/tickets.ts",
-    "./address": "./src/address.ts",
     "./station-names": "./src/station-names.ts",
     "./str": "./src/str.ts",
     "./lines": "./src/lines.ts",

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

@@ -24,7 +24,6 @@ import { newId } from '@metro-labs/core/ids';
 import { registerKey } from './keys.js';
 import { MOVABLE_STATIONS, type LoadedAgent } from '../stations/materialize.js';
 import type { StationName } from '@metro-labs/core/station-names';
-import { normalizeAddress } from '@metro-labs/core/address';
 
 const OWNER_FILE = '.owner';
 
@@ -37,7 +36,7 @@ const missing = (): AgentAdminError => new AgentAdminError('no such agent', 404)
 
 export function parseOwner(raw: string): string | null {
   const text = raw.trim();
-  return isOrganizationId(text) ? text : normalizeAddress(text);
+  return isOrganizationId(text) ? text : null;
 }
 
 export function localOwner(dir = agentsDir()): string | null {
@@ -50,7 +49,7 @@ export function localOwner(dir = agentsDir()): string | null {
 
 export function setLocalOwner(raw: string, dir = agentsDir()): string {
   const owner = parseOwner(raw);
-  if (owner === null) throw new ApiError(`'${raw}' is neither an organization id nor an Ethereum address`, 400);
+  if (owner === null) throw new ApiError(`'${raw}' is not an organization id`, 400);
   ensureSecureDir(dir);
   writeSecure(join(dir, OWNER_FILE), `${owner}\n`);
   return owner;

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

@@ -42,6 +42,7 @@ import { prepareAccount } from '../stations/attach.js';
 import { materializeFrom, reloadFrom } from '../stations/materialize.js';
 import type { StationName } from '@metro-labs/core/station-names';
 import { startUploadReaper } from '../files/upload-store.js';
+import { startAttachReaper } from '../files/attach-reaper.js';
 
 installCrashGuard();
 acquireLock(join(STATE_DIR, '.tail-lock'));
@@ -126,6 +127,7 @@ installBearerSessions(agentsDir(), localOwner);
   metroMcp.startInbound();
   syncPluginServers(readLocalConnectors());
   startUploadReaper();
+  startAttachReaper();
   announceLocalEndpoint();
   tunnel?.start();
   log.info(

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

@@ -2,29 +2,20 @@ import { localOwner, setLocalOwner } from '../agents/file-admin.js';
 import { isOrganizationId } from '@metro-labs/http/workos-token';
 import { log } from '@metro-labs/core/log';
 
-const NO_ONE = 'nobody can sign in; restart with metro serve --owner <organization id>';
-
-const WALLET = `the owner is a wallet address, and wallets cannot sign in any more; ${NO_ONE}`;
-
-function keepsOrganization(wanted: string, stored: string | null): stored is string {
-  return wanted !== '' && stored !== null && isOrganizationId(stored) && !isOrganizationId(wanted);
-}
-
-function announce(owner: string | null): string | null {
-  if (owner === null) log.warn(`local daemon: no owner set, so ${NO_ONE}`);
-  else if (!isOrganizationId(owner)) log.warn(`local daemon: ${WALLET}`);
-  return owner;
-}
-
 export function applyLocalOwner(): string | null {
   const wanted = process.env.METRO_OWNER?.trim() ?? '';
   const stored = localOwner();
-  if (keepsOrganization(wanted, stored)) {
-    log.info({ owner: stored, ignored: wanted }, 'local daemon: this machine belongs to an organization, so the wallet in --owner is ignored');
+  if (stored !== null) {
+    if (wanted !== '' && wanted !== stored)
+      log.info({ owner: stored, ignored: wanted }, 'local daemon: this machine already belongs to an organization, so --owner is ignored');
     return stored;
   }
-  if (wanted === '') return announce(stored);
-  const owner = setLocalOwner(wanted);
-  log.info({ owner }, 'local daemon: owner set from METRO_OWNER');
-  return announce(owner);
+  if (isOrganizationId(wanted)) {
+    const owner = setLocalOwner(wanted);
+    log.info({ owner }, 'local daemon: owner set from METRO_OWNER');
+    return owner;
+  }
+  if (wanted !== '') log.info({ ignored: wanted }, 'local daemon: --owner is not an organization id, so it is ignored');
+  log.warn('local daemon: no organization owns this machine, so nobody can sign in; restart with metro serve --owner <organization id>');
+  return null;
 }

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

@@ -0,0 +1,174 @@
+import { readdirSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  attachDir,
+  resolveCachedAttachment,
+} from '@metro-labs/core/stations/attachments';
+import { errMsg, log } from '@metro-labs/core/log';
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const MB = 1024 * 1024;
+const DEFAULT_TTL_DAYS = 7;
+const DEFAULT_MAX_MB = 2048;
+const PART_TTL_MS = 60 * 60 * 1000;
+const SWEEP_MS = 10 * 60 * 1000;
+const SIDECARS = ['.owner', '.grant'] as const;
+
+export interface AttachSweepOptions {
+  dir?: string;
+  now?: number;
+  ttlMs?: number;
+  maxBytes?: number;
+}
+
+export interface AttachSweepResult {
+  expired: number;
+  capped: number;
+  orphans: number;
+  parts: number;
+  freedBytes: number;
+}
+
+interface Entry {
+  name: string;
+  mtime: number;
+  size: number;
+}
+
+const positive = (raw: string | undefined, fallback: number): number => {
+  const value = Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+};
+
+export const attachTtlMs = (): number =>
+  positive(process.env.METRO_ATTACH_TTL_DAYS, DEFAULT_TTL_DAYS) * DAY_MS;
+
+export const attachMaxBytes = (): number =>
+  positive(process.env.METRO_ATTACH_MAX_MB, DEFAULT_MAX_MB) * MB;
+
+const cacheShaped = (name: string): boolean =>
+  resolveCachedAttachment(name) !== null;
+
+function stripSuffix(name: string, suffixes: readonly string[]): string | undefined {
+  const suffix = suffixes.find((s) => name.endsWith(s));
+  if (suffix === undefined) return undefined;
+  const base = name.slice(0, -suffix.length);
+  return cacheShaped(base) ? base : undefined;
+}
+
+function listEntries(dir: string): Entry[] {
+  let names: string[];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const entries: Entry[] = [];
+  for (const name of names) {
+    try {
+      const stat = statSync(join(dir, name));
+      if (stat.isFile()) entries.push({ name, mtime: stat.mtimeMs, size: stat.size });
+    } catch {
+      continue;
+    }
+  }
+  return entries;
+}
+
+function removeEntry(dir: string, name: string): void {
+  rmSync(join(dir, name), { force: true });
+}
+
+function removeWithSidecars(dir: string, name: string): void {
+  removeEntry(dir, name);
+  for (const suffix of SIDECARS) removeEntry(dir, `${name}${suffix}`);
+}
+
+interface Sweep {
+  dir: string;
+  now: number;
+  entries: Entry[];
+  result: AttachSweepResult;
+}
+
+function sweepParts(sweep: Sweep): Set<string> {
+  const fresh = new Set<string>();
+  for (const entry of sweep.entries) {
+    const base = stripSuffix(entry.name, ['.part']);
+    if (base === undefined) continue;
+    if (sweep.now - entry.mtime <= PART_TTL_MS) {
+      fresh.add(base);
+      continue;
+    }
+    removeEntry(sweep.dir, entry.name);
+    sweep.result.parts += 1;
+    sweep.result.freedBytes += entry.size;
+  }
+  return fresh;
+}
+
+function sweepExpired(sweep: Sweep, ttlMs: number): Entry[] {
+  const kept: Entry[] = [];
+  for (const entry of sweep.entries) {
+    if (!cacheShaped(entry.name)) continue;
+    if (sweep.now - entry.mtime <= ttlMs) {
+      kept.push(entry);
+      continue;
+    }
+    removeWithSidecars(sweep.dir, entry.name);
+    sweep.result.expired += 1;
+    sweep.result.freedBytes += entry.size;
+  }
+  return kept;
+}
+
+function sweepOrphans(sweep: Sweep, busy: Set<string>): void {
+  const present = new Set(sweep.entries.map((e) => e.name));
+  for (const entry of sweep.entries) {
+    const base = stripSuffix(entry.name, SIDECARS);
+    if (base === undefined || present.has(base) || busy.has(base)) continue;
+    removeEntry(sweep.dir, entry.name);
+    sweep.result.orphans += 1;
+  }
+}
+
+function capSize(sweep: Sweep, kept: Entry[], maxBytes: number): void {
+  let total = kept.reduce((sum, e) => sum + e.size, 0);
+  for (const entry of [...kept].sort((a, b) => a.mtime - b.mtime)) {
+    if (total <= maxBytes) return;
+    removeWithSidecars(sweep.dir, entry.name);
+    total -= entry.size;
+    sweep.result.capped += 1;
+    sweep.result.freedBytes += entry.size;
+  }
+}
+
+export function sweepAttachments(options: AttachSweepOptions = {}): AttachSweepResult {
+  const dir = options.dir ?? attachDir();
+  const sweep: Sweep = {
+    dir,
+    now: options.now ?? Date.now(),
+    entries: listEntries(dir),
+    result: { expired: 0, capped: 0, orphans: 0, parts: 0, freedBytes: 0 },
+  };
+  const busy = sweepParts(sweep);
+  const kept = sweepExpired(sweep, options.ttlMs ?? attachTtlMs());
+  sweepOrphans(sweep, busy);
+  capSize(sweep, kept, options.maxBytes ?? attachMaxBytes());
+  return sweep.result;
+}
+
+export function startAttachReaper(): void {
+  const run = (): void => {
+    try {
+      const swept = sweepAttachments();
+      if (swept.expired + swept.capped + swept.orphans + swept.parts > 0) {
+        log.info(swept, 'attachments: reaped the cache');
+      }
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'attachments: sweep failed');
+    }
+  };
+  run();
+  setInterval(run, SWEEP_MS).unref?.();
+}

package/runtime/node_modules/@metro-labs/http/src/mode-api.ts

@@ -3,7 +3,7 @@ import { cors, sendJson } from './api-http.js';
 
 const PATH = '/api/mode';
 
-export type DaemonMode = 'hosted' | 'linked' | 'local';
+export type DaemonMode = 'hosted' | 'local';
 
 export interface ModeInfo {
   mode: DaemonMode;

package/runtime/node_modules/@metro-labs/http/src/workos-token.ts

@@ -1,10 +1,9 @@
 import type { IncomingMessage } from 'node:http';
 import { createPublicKey, verify, type JsonWebKey, type KeyObject } from 'node:crypto';
 
-export const WORKOS_API = 'https://api.workos.com';
+const WORKOS_API = 'https://api.workos.com';
 const ORG_RE = /^org_[A-Za-z0-9]{10,64}$/;
 export const isOrganizationId = (value: string): boolean => ORG_RE.test(value);
-export const WORKOS_ISSUER = 'https://api.workos.com';
 export const DEFAULT_CLIENT_ID = 'client_01M2TJJJ6RM9CT081QB4XZK3G2';
 const SKEW_S = 60;
 const REFETCH_COOLDOWN_MS = 60_000;
@@ -129,7 +128,7 @@ function parseToken(token: string): Parts | null {
   return { signed: `${head}.${body}`, body, signature: b64url(sig), kid };
 }
 
-export async function verifyToken(token: string, keys: SigningKeys, issuer = WORKOS_ISSUER, now = Date.now()): Promise<Session | null> {
+export async function verifyToken(token: string, keys: SigningKeys, issuer = WORKOS_API, now = Date.now()): Promise<Session | null> {
   const parts = parseToken(token);
   if (parts === null) return null;
   const key = await keys.keyFor(parts.kid, now).catch(() => null);
@@ -144,7 +143,7 @@ export function bearerToken(req: IncomingMessage): string | null {
   return scheme?.toLowerCase() === 'bearer' && token?.includes('.') === true ? token : null;
 }
 
-export async function bearerSession(req: IncomingMessage, keys: SigningKeys, issuer = WORKOS_ISSUER): Promise<Session | null> {
+export async function bearerSession(req: IncomingMessage, keys: SigningKeys, issuer = WORKOS_API): Promise<Session | null> {
   const token = bearerToken(req);
   return token === null ? null : verifyToken(token, keys, issuer);
 }

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.173"
+  "version": "0.1.0-beta.174"
 }

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

@@ -1,6 +0,0 @@
-const ADDRESS_RE = /^0x[0-9a-f]{40}$/;
-
-export function normalizeAddress(raw: string): string | null {
-  const address = raw.trim().toLowerCase();
-  return ADDRESS_RE.test(address) ? address : null;
-}