@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -0,0 +1,145 @@
+import { createPrivateKey, createPublicKey, generateKeyPairSync, randomBytes, type KeyObject } from 'node:crypto';
+import { closeSync, existsSync, fsyncSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { parseId } from '@metro-labs/core/ids';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+import { ensureSecureDir } from '@metro-labs/core/secure-fs';
+import { agentKeyId, rawPublicKey } from '@metro-labs/http/agent-signature';
+import { ApiError } from '@metro-labs/http/api-error';
+import { isOrganizationId } from '@metro-labs/http/workos-token';
+import { agentsDir } from '../agents/files.js';
+
+const FILE = 'agent-key.json';
+
+export interface Enrollment {
+  server: string;
+  organization: string;
+  at: string;
+}
+
+export interface AgentKey {
+  keyId: string;
+  signingKey: string;
+  signing: KeyObject;
+  enrollment: Enrollment | null;
+}
+
+const pathOf = (dir: string): string => join(dir, FILE);
+
+function privateSigningKey(raw: unknown): KeyObject | null {
+  if (typeof raw !== 'string' || raw === '') return null;
+  try {
+    const key = createPrivateKey({ key: Buffer.from(raw, 'base64'), format: 'der', type: 'pkcs8' });
+    return key.asymmetricKeyType === 'ed25519' ? key : null;
+  } catch {
+    return null;
+  }
+}
+
+function enrollmentOf(raw: unknown): Enrollment | null {
+  if (!isRecord(raw) || typeof raw.organization !== 'string' || typeof raw.at !== 'string') return null;
+  const server = parseId(raw.server);
+  return server !== null && isOrganizationId(raw.organization) ? { server, organization: raw.organization, at: raw.at } : null;
+}
+
+function agentKeyOf(signing: KeyObject, enrollment: Enrollment | null): AgentKey {
+  const signingKey = rawPublicKey(createPublicKey(signing));
+  return { keyId: agentKeyId(signingKey), signingKey, signing, enrollment };
+}
+
+const unreadable = (): null => {
+  log.warn('agent-key.json: Metro cannot read this agent key, so the agent must be enrolled again');
+  return null;
+};
+
+function storedOf(path: string): Record<string, unknown> | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return unreadable();
+  }
+  return isRecord(parsed) ? parsed : unreadable();
+}
+
+function keyOf(stored: Record<string, unknown> | null): AgentKey | null {
+  if (stored === null) return null;
+  const signing = privateSigningKey(stored.signing);
+  if (stored.version !== 1 || signing === null) return unreadable();
+  return agentKeyOf(signing, enrollmentOf(stored.enrollment));
+}
+
+export function readAgentKey(dir = agentsDir()): AgentKey | null {
+  const path = existsSync(pathOf(dir)) ? pathOf(dir) : join(dir, 'box-key.json');
+  return existsSync(path) ? keyOf(storedOf(path)) : null;
+}
+
+const pendingPath = (dir: string): string => join(dir, 'agent-key.pending.json');
+
+function pendingFields(stored: Record<string, unknown> | null): { owner: string; ticketHash: string; expectedServer: string | null } {
+  if (typeof stored?.ticketHash !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(stored.ticketHash) || typeof stored.owner !== 'string' || !isOrganizationId(stored.owner)) {
+    throw new ApiError('Metro cannot read the pending enrollment key. Restore its file or permissions before enrolling again.', 503);
+  }
+  const expectedServer = stored.expectedServer === undefined ? null : parseId(stored.expectedServer);
+  if (stored.expectedServer !== undefined && expectedServer === null) throw new ApiError('Metro cannot read the pending enrollment identity. Restore its file before enrolling again.', 503);
+  return { owner: stored.owner, ticketHash: stored.ticketHash, expectedServer };
+}
+
+export function readPendingAgentKey(owner: string, dir: string): (AgentKey & { ticketHash: string; expectedServer: string | null }) | null {
+  if (!existsSync(pendingPath(dir))) return null;
+  const stored = storedOf(pendingPath(dir));
+  const fields = pendingFields(stored);
+  const key = keyOf(stored);
+  if (key === null) throw new ApiError('Metro cannot read the pending enrollment key. Restore its file or permissions before enrolling again.', 503);
+  return fields.owner === owner ? { ...key, ticketHash: fields.ticketHash, expectedServer: fields.expectedServer } : null;
+}
+
+function flush(path: string): void {
+  const file = openSync(path, 'r');
+  try {
+    fsyncSync(file);
+  } finally {
+    closeSync(file);
+  }
+}
+
+function writeKey(path: string, stored: Record<string, unknown>): void {
+  const dir = dirname(path);
+  ensureSecureDir(dir);
+  const temp = `${path}.${randomBytes(12).toString('hex')}.tmp`;
+  const file = openSync(temp, 'wx', 0o600);
+  try {
+    try {
+      writeFileSync(file, `${JSON.stringify(stored, null, 2)}\n`);
+      fsyncSync(file);
+    } finally {
+      closeSync(file);
+    }
+    renameSync(temp, path);
+    flush(dir);
+  } finally {
+    rmSync(temp, { force: true });
+  }
+}
+
+export function clearPendingAgentKey(dir: string): void {
+  rmSync(pendingPath(dir), { force: true });
+  flush(dir);
+}
+
+export function newAgentKey(): AgentKey {
+  return agentKeyOf(generateKeyPairSync('ed25519').privateKey, null);
+}
+
+const exported = (key: KeyObject): string => key.export({ format: 'der', type: 'pkcs8' }).toString('base64');
+
+const privateKeys = (key: AgentKey): Record<string, unknown> => ({ version: 1, signing: exported(key.signing) });
+
+export function savePendingAgentKey(key: AgentKey, owner: string, ticketHash: string, dir: string, expectedServer?: string): void {
+  writeKey(pendingPath(dir), { ...privateKeys(key), owner, ticketHash, ...(expectedServer === undefined ? {} : { expectedServer }) });
+}
+
+export function saveAgentKey(key: AgentKey, enrollment: Enrollment, dir = agentsDir()): void {
+  writeKey(pathOf(dir), { ...privateKeys(key), enrollment });
+}

package/runtime/node_modules/@metro-labs/daemon/src/connectors/enroll-api.ts

@@ -0,0 +1,99 @@
+import { createHash } from 'node:crypto';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { resolve } from 'node:path';
+import { parseId } from '@metro-labs/core/ids';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+import { ApiError } from '@metro-labs/http/api-error';
+import { readJsonBody, sessionRoute, type ApiSession } from '@metro-labs/http/api-http';
+import { agentsDir } from '../agents/files.js';
+import { clearPendingAgentKey, newAgentKey, readPendingAgentKey, saveAgentKey, savePendingAgentKey, type AgentKey } from './agent-key.js';
+import { agentCall, METRO_API, MetroApiRefusal, type MetroApi } from './metro-api.js';
+
+const PATH = '/api/enrollment';
+const TICKET_RE = /^[A-Za-z0-9_-]{43}$/;
+const enrolling = new Set<string>();
+
+export interface EnrollApiDeps {
+  owner: () => string | null;
+  dir?: () => string;
+  api?: MetroApi;
+}
+
+export interface Enrolled {
+  server: string;
+  organization: string;
+  keyId: string;
+}
+
+const differently = (): ApiError => new ApiError('api.metro.box enrolled this agent differently than Metro asked. Try enrolling again.', 503);
+
+function enrolledOf(value: Record<string, unknown>, key: AgentKey, owner: string): Enrolled {
+  const server = parseId(value.server);
+  if (server === null || value.organization !== owner || value.keyId !== key.keyId) throw differently();
+  return { server, organization: owner, keyId: key.keyId };
+}
+
+function sameOwner(deps: EnrollApiDeps, owner: string): void {
+  if (deps.owner() !== owner) throw new ApiError('This agent changed organizations during enrollment. Enroll it again from its current organization.', 409);
+}
+
+async function recover(api: MetroApi, key: AgentKey, owner: string): Promise<Enrolled | null> {
+  try {
+    return enrolledOf(await agentCall(api, key, '/api/agents/session'), key, owner);
+  } catch (err) {
+    if (err instanceof MetroApiRefusal && err.upstreamStatus === 401 && err.code === 'agent_key_missing') return null;
+    throw err;
+  }
+}
+
+function saveRecovered(pending: ReturnType<typeof readPendingAgentKey>, enrolled: Enrolled | null, ticketHash: string, api: MetroApi, dir: string): Enrolled | null {
+  if (pending === null || enrolled === null) return null;
+  if (pending.expectedServer !== null && pending.expectedServer !== enrolled.server) throw differently();
+  saveAgentKey(pending, { server: enrolled.server, organization: enrolled.organization, at: new Date(api.now()).toISOString() }, dir);
+  if (pending.ticketHash !== ticketHash) return null;
+  clearPendingAgentKey(dir);
+  return enrolled;
+}
+
+async function exchange(ticket: string, owner: string, dir: string, deps: EnrollApiDeps): Promise<Enrolled> {
+  const api = deps.api ?? METRO_API;
+  const pending = readPendingAgentKey(owner, dir);
+  const ticketHash = createHash('sha256').update(ticket).digest('base64url');
+  const recovered = pending === null ? null : await recover(api, pending, owner);
+  sameOwner(deps, owner);
+  const finished = saveRecovered(pending, recovered, ticketHash, api, dir);
+  if (finished !== null) return finished;
+  const key = pending?.ticketHash === ticketHash ? pending : newAgentKey();
+  if (key !== pending) savePendingAgentKey(key, owner, ticketHash, dir);
+  const enrolled = enrolledOf(await agentCall(api, key, '/api/agents/enroll', { ticket, organization: owner, signingKey: key.signingKey }), key, owner);
+  sameOwner(deps, owner);
+  savePendingAgentKey(key, owner, ticketHash, dir, enrolled.server);
+  const confirmed = enrolledOf(await agentCall(api, key, '/api/agents/session'), key, owner);
+  sameOwner(deps, owner);
+  if (confirmed.server !== enrolled.server) throw differently();
+  saveAgentKey(key, { server: enrolled.server, organization: owner, at: new Date(api.now()).toISOString() }, dir);
+  clearPendingAgentKey(dir);
+  log.info({ server: enrolled.server, organization: owner, keyId: key.keyId }, 'enrollment: this agent is enrolled with its organization on api.metro.box');
+  return enrolled;
+}
+
+async function enroll(req: IncomingMessage, session: ApiSession, deps: EnrollApiDeps): Promise<Enrolled> {
+  const body = await readJsonBody(req);
+  const ticket = isRecord(body) && typeof body.ticket === 'string' ? body.ticket : '';
+  if (!TICKET_RE.test(ticket)) throw new ApiError('enrolling needs the ticket api.metro.box gave for this agent', 400);
+  const owner = deps.owner();
+  if (owner === null || owner !== session.subject) throw new ApiError('this machine has no organization yet', 409);
+  const dir = resolve(deps.dir?.() ?? agentsDir());
+  if (enrolling.has(dir)) throw new ApiError('This agent is already enrolling. Wait for it to finish before trying again.', 409);
+  enrolling.add(dir);
+  try {
+    return await exchange(ticket, owner, dir, deps);
+  } finally {
+    enrolling.delete(dir);
+  }
+}
+
+export function handleEnrollRequest(req: IncomingMessage, res: ServerResponse, deps: EnrollApiDeps): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['POST'] }, admin: true, label: 'enrollment' }, (session) => enroll(req, session, deps));
+}

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

@@ -0,0 +1,59 @@
+import { lstatSync, readdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { agentsDir } from '../agents/files.js';
+
+const WRITTEN = new Set([
+  'connectors.json',
+  'connector-migrations.json',
+  'connector-migrations.initialized',
+  'connector-server-keys.json',
+  'connector-server-keys.initialized',
+  'org-connector-sync.json',
+]);
+
+const OPERATIONS = 'connector-migration-operations-[A-Za-z0-9][A-Za-z0-9_-]{10}\\.json';
+
+const PATTERNS = [
+  new RegExp(`^${OPERATIONS}(?:\\.initialized)?$`),
+  new RegExp(`^(?:connectors\\.json|connector-server-keys\\.json|connector-server-keys\\.initialized|org-connector-sync\\.json|${OPERATIONS})\\.tmp-[0-9]+$`),
+  /^connector-migrations\.json\.[0-9a-f]{24}\.tmp$/,
+];
+
+const isConnectorLeftover =(name: string): boolean => WRITTEN.has(name) || PATTERNS.some((pattern) => pattern.test(name));
+
+const codeOf = (err: unknown): unknown => (err instanceof Error && 'code' in err ? err.code : undefined);
+
+function namesIn(dir: string): string[] {
+  try {
+    return readdirSync(dir).filter(isConnectorLeftover);
+  } catch (err) {
+    if (codeOf(err) !== 'ENOENT') log.warn({ err: errMsg(err), dir }, 'connectors: could not list the old connector files');
+    return [];
+  }
+}
+
+function removeOne(path: string): boolean {
+  try {
+    if (!lstatSync(path).isFile()) {
+      log.warn({ path }, 'connectors: left an old connector file alone, it is not a regular file');
+      return false;
+    }
+    unlinkSync(path);
+    return true;
+  } catch (err) {
+    if (codeOf(err) !== 'ENOENT') log.warn({ err: errMsg(err), path }, 'connectors: could not remove an old connector file');
+    return false;
+  }
+}
+
+export function removeConnectorLeftovers(dir = agentsDir()): number {
+  try {
+    const removed = namesIn(dir).filter((name) => removeOne(join(dir, name))).length;
+    log.info({ removed }, 'connectors: removed the files of the old connector path');
+    return removed;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'connectors: could not remove the files of the old connector path');
+    return 0;
+  }
+}

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

@@ -0,0 +1,93 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { ApiError } from '@metro-labs/http/api-error';
+import { signAgentRequest } from '@metro-labs/http/agent-signature';
+import type { AgentKey } from './agent-key.js';
+
+const TIMEOUT_MS = 15_000;
+const ANSWER_MAX = 64 * 1024;
+
+export type AgentFetch = (url: string, init: RequestInit) => Promise<Response>;
+
+export interface MetroApi {
+  base: string;
+  fetch: AgentFetch;
+  now: () => number;
+}
+
+export const METRO_API: MetroApi = {
+  base: 'https://api.metro.box',
+  fetch: (url, init) => fetch(url, init),
+  now: () => Date.now(),
+};
+
+const tooLarge = (): ApiError => new ApiError('api.metro.box sent an answer too large for Metro.', 503);
+const unreachable = (): ApiError => new ApiError('Metro could not reach api.metro.box. Try again.', 503);
+
+async function answerOf(response: Response, max: number): Promise<unknown> {
+  if (Number(response.headers.get('content-length') ?? '0') > max) throw tooLarge();
+  const reader = response.body?.getReader();
+  if (reader === undefined) return null;
+  const parts: Uint8Array[] = [];
+  let size = 0;
+  for (let part = await reader.read(); !part.done; part = await reader.read()) {
+    size += part.value.length;
+    if (size > max) {
+      await reader.cancel();
+      throw tooLarge();
+    }
+    parts.push(part.value);
+  }
+  try {
+    return JSON.parse(Buffer.concat(parts).toString('utf8')) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+export class MetroApiRefusal extends ApiError {
+  constructor(message: string, readonly upstreamStatus: number, readonly code: string | null) {
+    super(message, upstreamStatus >= 500 ? 503 : 400);
+  }
+}
+
+function refusal(status: number, value: unknown): ApiError {
+  const said = isRecord(value) && typeof value.error === 'string' && value.error.length <= 300 ? value.error : `api.metro.box answered ${String(status)}`;
+  const code = isRecord(value) && typeof value.code === 'string' ? value.code : null;
+  return new MetroApiRefusal(said, status, code);
+}
+
+interface AgentCallOptions {
+  answerMax?: number;
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+
+function signedCall(api: MetroApi, key: AgentKey, path: string, body: Record<string, unknown> | undefined): { url: URL; method: string; text: string; authorization: string } {
+  const url = new URL(path, api.base);
+  const method = body === undefined ? 'GET' : 'POST';
+  const text = body === undefined ? '' : JSON.stringify(body);
+  const authorization = signAgentRequest({ method, host: url.host, path: `${url.pathname}${url.search}`, body: Buffer.from(text, 'utf8') }, key.signing, key.keyId, api.now());
+  return { url, method, text, authorization };
+}
+
+export async function agentCall(api: MetroApi, key: AgentKey, path: string, body?: Record<string, unknown>, options: AgentCallOptions = {}): Promise<Record<string, unknown>> {
+  const { url, method, text, authorization } = signedCall(api, key, path, body);
+  let response: Response;
+  try {
+    response = await api.fetch(url.toString(), {
+      method,
+      headers: { authorization, ...(body === undefined ? {} : { 'content-type': 'application/json' }) },
+      ...(body === undefined ? {} : { body: text }),
+      redirect: 'error',
+      signal: AbortSignal.any([AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS), ...(options.signal === undefined ? [] : [options.signal])]),
+    });
+  } catch {
+    throw unreachable();
+  }
+  const value = await answerOf(response, options.answerMax ?? ANSWER_MAX).catch((err: unknown) => {
+    throw err instanceof ApiError ? err : unreachable();
+  });
+  if (!response.ok) throw refusal(response.status, value);
+  if (!isRecord(value)) throw new ApiError('api.metro.box sent an answer Metro cannot read.', 503);
+  return value;
+}

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/files}/attach-grant.ts

@@ -1,8 +1,8 @@
 import { randomBytes, timingSafeEqual } from 'node:crypto';
-import { ID_RE } from '../db/ids.js';
+import { ID_RE } from '@metro-labs/core/ids';
 import { readFileSync } from 'node:fs';
-import { resolveCachedAttachment } from '../stations/attachments.js';
-import { writeSecure } from './secure-fs.js';
+import { resolveCachedAttachment } from '@metro-labs/core/stations/attachments';
+import { writeSecure } from '@metro-labs/core/secure-fs';
 
 const GRANT_SUFFIX = '.grant';
 
@@ -34,7 +34,7 @@ function parseGrant(raw: string): AttachmentGrant | undefined {
   };
 }
 
-export function readGrant(path: string): AttachmentGrant | undefined {
+function readGrant(path: string): AttachmentGrant | undefined {
   try {
     return parseGrant(readFileSync(`${path}${GRANT_SUFFIX}`, 'utf8'));
   } catch {

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/files}/attach-owner.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
-import { ID_RE } from '../db/ids.js';
-import { resolveCachedAttachment } from '../stations/attachments.js';
-import { writeSecure } from './secure-fs.js';
+import { ID_RE } from '@metro-labs/core/ids';
+import { resolveCachedAttachment } from '@metro-labs/core/stations/attachments';
+import { writeSecure } from '@metro-labs/core/secure-fs';
 
 const OWNER_SUFFIX = '.owner';
 

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/{mcp/src/daemon → daemon/src/files}/attach-serve.ts

@@ -4,49 +4,43 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import {
   guessMime,
   resolveCachedAttachment,
-} from '../stations/attachments.js';
+} from '@metro-labs/core/stations/attachments';
 import {
   allowedAgents,
-  authConfigFromEnv,
   authenticate,
   extractToken,
 } from '../mcp/request-identity.js';
 import { attachmentOwner, recordAttachmentOwner } from './attach-owner.js';
 import { grantAllows, issueAttachmentGrant } from './attach-grant.js';
-import { errMsg, log } from './log.js';
-import { loadTunnelConfig, webhookPort } from './tunnel.js';
+import { errMsg, log } from '@metro-labs/core/log';
+import { currentTunnelUrl } from '../net/tunnel.js';
+
+export const webhookPort = (): number => Number(process.env.METRO_WEBHOOK_PORT) || 8420;
 
 function authorized(req: IncomingMessage, name: string): boolean {
   const owner = attachmentOwner(name);
   if (owner === undefined) return false;
   if (grantAllows(name, owner, extractToken(req) ?? '')) return true;
-  return allowedAgents(authenticate(req, authConfigFromEnv()) ?? undefined).has(
+  return allowedAgents(authenticate(req) ?? undefined).has(
     owner,
   );
 }
 
-const DEFAULT_PUBLIC_BASE = 'https://mcp.metro.box';
-
 export function publicBaseUrl(): string | null {
   const env = process.env.METRO_PUBLIC_URL?.trim();
   if (env) return env.replace(/\/+$/, '');
-  const host = loadTunnelConfig()?.hostname;
-  return host ? `https://${host}` : null;
+  return currentTunnelUrl();
 }
 
-const localBase = (): string | null =>
-  (process.env.METRO_RUN_TOKEN?.trim() ?? '') === ''
-    ? null
-    : `http://127.0.0.1:${String(webhookPort())}`;
+export const loopbackBase = (): string => `http://127.0.0.1:${String(webhookPort())}`;
 
-export const publicBaseOrDefault = (): string =>
-  publicBaseUrl() ?? localBase() ?? DEFAULT_PUBLIC_BASE;
+export const publicBaseOrDefault = (): string => publicBaseUrl() ?? loopbackBase();
 
 export function attachmentUrl(
   pathOrName: string,
   agentId: string,
 ): string | null {
-  const base = publicBaseUrl() ?? localBase();
+  const base = publicBaseUrl() ?? loopbackBase();
   if (!base) return null;
   const name = pathOrName.split('/').pop();
   if (!name || !resolveCachedAttachment(name)) return null;
@@ -62,7 +56,7 @@ export function attachmentEventUrl(
 ): string | null {
   if (payload.contentType !== 'attachmentSaved') return null;
   if (typeof payload.url === 'string' && payload.url.length > 0) return null;
-  const p = payload.attachmentPath ?? payload.localPath;
+  const p = payload.attachmentPath;
   return typeof p === 'string' ? attachmentUrl(p, agentId) : null;
 }