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

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

@@ -23,7 +23,6 @@ export const loadedAgentOf = (bundle: AgentBundle): LoadedAgent => ({
   name: bundle.agent.name,
   key: null,
   accounts: bundle.agent.stations,
-  connectors: [],
 });
 
 export interface RestoredAgent {
@@ -36,8 +35,8 @@ export interface RestoredAgent {
 export type ImportMode = 'append' | 'overwrite';
 
 export interface BundleApiDeps {
-  bundle: (subject: string, agentId: string) => Promise<AgentBundle>;
-  restore: (subject: string, bundle: AgentBundle, mode: ImportMode) => Promise<RestoredAgent>;
+  bundle: (agentId: string) => Promise<AgentBundle>;
+  restore: (bundle: AgentBundle, mode: ImportMode) => Promise<RestoredAgent>;
 }
 
 export function parseMode(raw: unknown): ImportMode {
@@ -62,7 +61,7 @@ function connectorOf(raw: unknown): LoadedConnector {
   if (!isRecord(raw) || typeof raw.id !== 'string' || typeof raw.name !== 'string' || typeof raw.url !== 'string')
     throw bad('a connector is missing its id, name or url');
   if (!isRecord(raw.config)) throw bad('a connector has no config');
-  return { id: raw.id, name: raw.name, url: raw.url, transport: 'http', config: raw.config };
+  return { id: raw.id, name: raw.name, url: raw.url, config: raw.config };
 }
 
 function agentOf(raw: unknown): AgentBundle['agent'] {
@@ -79,14 +78,14 @@ export function parseBundle(raw: unknown): AgentBundle {
   return { version: 1, agent: agentOf(raw.agent), connectors: connectors.map(connectorOf) };
 }
 
-async function answer(req: IncomingMessage, deps: BundleApiDeps, subject: string, path: string): Promise<unknown> {
+async function answer(req: IncomingMessage, deps: BundleApiDeps, path: string): Promise<unknown> {
   if (path === RESTORE_PATH) {
     const body: unknown = await readJsonBody(req, BUNDLE_MAX);
-    return deps.restore(subject, parseBundle(body), parseMode(body));
+    return deps.restore(parseBundle(body), parseMode(body));
   }
   const id = parseId(path.slice(AGENTS.length + 1).split('/')[0] ?? '');
   if (id === null) throw new ApiError('no such agent', 404);
-  return deps.bundle(subject, id);
+  return deps.bundle(id);
 }
 
 export function handleBundleRequest(req: IncomingMessage, res: ServerResponse, deps: BundleApiDeps): boolean {
@@ -106,7 +105,7 @@ export function handleBundleRequest(req: IncomingMessage, res: ServerResponse, d
     .then((session) => {
       if (!session) throw new ApiError('unauthorized', 401);
       requireAdmin(session);
-      return answer(req, deps, session.subject, path);
+      return answer(req, deps, path);
     })
     .then((body) => {
       sendJson(req, res, isRestore ? 201 : 200, body);

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

@@ -1,4 +1,4 @@
-import { readFileSync, rmdirSync, rmSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ApiError } from '@metro-labs/http/api-error';
 import { isOrganizationId } from '@metro-labs/http/workos-token';
@@ -9,8 +9,6 @@ import {
   normalizeAgentName,
   type AgentSummary,
   type CreatedAgent,
-  type DeletedAgent,
-  type OwnedAgent,
 } from './admin.js';
 import type { AccountRef } from './account-attach.js';
 import {
@@ -23,12 +21,11 @@ import {
   type AgentFile,
 } from './files.js';
 import { newId } from '@metro-labs/core/ids';
-import { registerKey, unregisterAgentKey } from './keys.js';
+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';
 
-export const LOCAL_PROJECT_ID = 'localdaemon';
 const OWNER_FILE = '.owner';
 
 interface Stored {
@@ -59,12 +56,6 @@ export function setLocalOwner(raw: string, dir = agentsDir()): string {
   return owner;
 }
 
-
-function isOwner(subject: string, dir: string): boolean {
-  const owner = localOwner(dir);
-  return owner !== null && owner === parseOwner(subject);
-}
-
 export function storedAgents(dir: string): Stored[] {
   return listAgentFiles(dir).map((path) => ({ path, file: readAgentFile(path) }));
 }
@@ -73,34 +64,14 @@ function save(stored: Stored): void {
   writeSecure(stored.path, `${JSON.stringify(stored.file, null, 2)}\n`);
 }
 
-function ownedOrThrow(subject: string, id: string, dir: string): Stored {
-  if (!isOwner(subject, dir)) throw missing();
+function agentOrThrow(id: string, dir: string): Stored {
   const found = storedAgents(dir).find((s) => s.file.id === id);
   if (found === undefined) throw missing();
   return found;
 }
 
-export async function localOwnedAgentOrThrow(
-  subject: string,
-  id: string,
-  dir = agentsDir(),
-): Promise<{ agent: OwnedAgent }> {
-  const { file } = ownedOrThrow(subject, id, dir);
-  return Promise.resolve({ agent: { id: file.id, name: file.name } });
-}
-
-export async function localListAgents(
-  subject: string,
-  project: string,
-  dir = agentsDir(),
-): Promise<AgentSummary[]> {
-  if (project !== LOCAL_PROJECT_ID || !isOwner(subject, dir))
-    throw new AgentAdminError('no such project', 404);
-  return Promise.resolve(
-    storedAgents(dir)
-      .map(({ file }) => ({ id: file.id, name: file.name, owned: true, key: file.key }))
-      .sort((a, b) => a.id.localeCompare(b.id)),
-  );
+export async function localListAgents(dir = agentsDir()): Promise<AgentSummary[]> {
+  return Promise.resolve(storedAgents(dir).map(({ file }) => ({ id: file.id, name: file.name })));
 }
 
 function freshId(taken: Set<string>): string {
@@ -111,14 +82,7 @@ function freshId(taken: Set<string>): string {
   throw new AgentAdminError('could not allocate a free id', 500);
 }
 
-export async function localCreateAgent(
-  subject: string,
-  project: string,
-  rawName?: string,
-  dir = agentsDir(),
-): Promise<CreatedAgent> {
-  if (project !== LOCAL_PROJECT_ID || !isOwner(subject, dir))
-    throw new AgentAdminError('no such project', 404);
+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);
@@ -127,7 +91,7 @@ export async function localCreateAgent(
   ensureSecureDir(dir);
   save({
     path: agentFilePath(dir),
-    file: { version: 1, id, name, key, owner: localOwner(dir), stations: [], connectors: [] },
+    file: { version: 1, id, name, key, stations: [] },
   });
   registerKey(key, id);
   return Promise.resolve({ id, name, key });
@@ -137,30 +101,11 @@ export type Ensured = 'created' | 'present' | 'no-owner';
 
 export async function ensureLocalAgent(dir = agentsDir()): Promise<Ensured> {
   if (storedAgents(dir).length > 0) return 'present';
-  const owner = localOwner(dir);
-  if (owner === null) return 'no-owner';
-  await localCreateAgent(owner, LOCAL_PROJECT_ID, undefined, dir);
+  if (localOwner(dir) === null) return 'no-owner';
+  await localCreateAgent(undefined, dir);
   return 'created';
 }
 
-export async function localDeleteAgent(
-  subject: string,
-  id: string,
-  dir = agentsDir(),
-): Promise<DeletedAgent> {
-  const stored = ownedOrThrow(subject, id, dir);
-  const attached = stored.file.stations.length;
-  if (attached > 0)
-    throw new AgentAdminError(
-      `the agent still has ${String(attached)} station account(s) attached — detach them first`,
-      409,
-    );
-  rmSync(stored.path);
-  removeIfEmpty(join(stored.path, '..'));
-  unregisterAgentKey(id);
-  return Promise.resolve({ id, name: stored.file.name });
-}
-
 function assertUnclaimed(existing: Stored[], agent: LoadedAgent): void {
   for (const { file } of existing) {
     if (file.id === agent.id)
@@ -170,10 +115,6 @@ function assertUnclaimed(existing: Stored[], agent: LoadedAgent): void {
   }
 }
 
-export function assertLocalOwner(subject: string, dir = agentsDir()): void {
-  if (!isOwner(subject, dir)) throw new AgentAdminError('no such project', 404);
-}
-
 function assertImportable(agent: LoadedAgent): void {
   const immovable = agent.accounts.find((a) => !MOVABLE_STATIONS.has(a.station));
   if (immovable !== undefined)
@@ -200,16 +141,14 @@ function importTarget(dir: string, agent: LoadedAgent): ImportTarget {
 export type ImportMode = 'append' | 'overwrite';
 
 export async function localImportAgent(
-  subject: string,
   agent: LoadedAgent,
   dir = agentsDir(),
   mode: ImportMode = 'overwrite',
 ): Promise<{ id: string; name: string; key: string; stations: number }> {
-  assertLocalOwner(subject, dir);
   assertImportable(agent);
   const { path, previous } = importTarget(dir, agent);
   const key = previous?.key ?? agent.key ?? newApiKey();
-  const file = fileFor({ ...agent, key }, localOwner(dir), path, previous, mode);
+  const file = fileFor({ ...agent, key }, path, previous, mode);
   ensureSecureDir(join(path, '..'));
   save({ path, file });
   registerKey(key, agent.id);
@@ -237,7 +176,6 @@ function mergedStations(
 
 function fileFor(
   agent: LoadedAgent,
-  owner: string | null,
   path: string,
   previous: AgentFile | undefined,
   mode: ImportMode,
@@ -249,9 +187,7 @@ function fileFor(
         id: agent.id,
         name: previous?.name ?? null,
         key: agent.key,
-        owner,
         stations: mergedStations(agent, previous, mode),
-        connectors: previous?.connectors ?? [],
       }),
       path,
     );
@@ -268,14 +204,6 @@ export function readLocalAgentFile(agentId: string, dir = agentsDir()): AgentFil
   return found.file;
 }
 
-function removeIfEmpty(folder: string): void {
-  try {
-    rmdirSync(folder);
-  } catch {
-    return;
-  }
-}
-
 function assertTokenFree(all: Stored[], station: StationName, token: string): void {
   const taken = all.some((s) =>
     s.file.stations.some(
@@ -290,13 +218,12 @@ function assertTokenFree(all: Stored[], station: StationName, token: string): vo
 }
 
 export async function localAttachAccount(
-  subject: string,
   agentId: string,
   station: StationName,
   config: Record<string, unknown>,
   dir = agentsDir(),
 ): Promise<AccountRef> {
-  const stored = ownedOrThrow(subject, agentId, dir);
+  const stored = agentOrThrow(agentId, dir);
   if (!MOVABLE_STATIONS.has(station))
     throw new AgentAdminError(
       `a ${station} endpoint needs a public url and cannot live on a local daemon`,
@@ -312,14 +239,13 @@ export async function localAttachAccount(
 }
 
 export async function localSetAllowlist(
-  subject: string,
   agentId: string,
   station: StationName,
   accountId: string,
   allowlist: string[],
   dir = agentsDir(),
 ): Promise<string[]> {
-  const stored = ownedOrThrow(subject, agentId, dir);
+  const stored = agentOrThrow(agentId, dir);
   const account = stored.file.stations.find((a) => a.station === station && a.id === accountId);
   if (account === undefined) throw new AgentAdminError('no such account on this agent', 404);
   account.allowlist = allowlist;
@@ -328,14 +254,13 @@ export async function localSetAllowlist(
 }
 
 export async function localSetAccountEnabled(
-  subject: string,
   agentId: string,
   station: StationName,
   accountId: string,
   enabled: boolean,
   dir = agentsDir(),
 ): Promise<boolean> {
-  const stored = ownedOrThrow(subject, agentId, dir);
+  const stored = agentOrThrow(agentId, dir);
   const account = stored.file.stations.find((a) => a.station === station && a.id === accountId);
   if (account === undefined) throw new AgentAdminError('no such account on this agent', 404);
   account.enabled = enabled;
@@ -344,13 +269,12 @@ export async function localSetAccountEnabled(
 }
 
 export async function localDetachAccount(
-  subject: string,
   agentId: string,
   station: StationName,
   accountId: string,
   dir = agentsDir(),
 ): Promise<AccountRef> {
-  const stored = ownedOrThrow(subject, agentId, dir);
+  const stored = agentOrThrow(agentId, dir);
   const before = stored.file.stations.length;
   stored.file.stations = stored.file.stations.filter(
     (a) => !(a.station === station && a.id === accountId),

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

@@ -19,9 +19,7 @@ export interface AgentFile {
   id: string;
   name: string | null;
   key: string | null;
-  owner: string | null;
   stations: LoadedAccount[];
-  connectors: string[];
 }
 
 export const agentFilePath = (dir = agentsDir()): string => join(dir, AGENT_FILE);
@@ -33,8 +31,6 @@ export function agentsDir(): string {
     : join(homedir(), '.metro', 'agents');
 }
 
-const OWNER_RE = /^(0x[0-9a-f]{40}|org_[A-Za-z0-9]{10,64})$/;
-
 function fail(path: string, reason: string): never {
   throw new AgentFileError(`${path}: ${reason}`);
 }
@@ -74,9 +70,6 @@ function optionalMatch(
   return value;
 }
 
-const connectorsOf = (raw: unknown): string[] =>
-  Array.isArray(raw) ? raw.filter((id): id is string => typeof id === 'string' && ID_RE.test(id)) : [];
-
 function nameOf(raw: unknown, path: string): string | null {
   if (raw === undefined || raw === null) return null;
   if (typeof raw !== 'string' || !AGENT_NAME_RE.test(raw)) fail(path, 'name is not a valid agent name');
@@ -97,21 +90,13 @@ export function parseAgentFile(raw: string, path: string): AgentFile {
     fail(path, 'id is not an 11-character id');
   const label = nameOf(name, path);
   const key = optionalMatch(parsed.key, KEY_RE, path, 'key is not an agent key');
-  const owner = optionalMatch(
-    parsed.owner,
-    OWNER_RE,
-    path,
-    'owner is neither an organization id nor a lowercase Ethereum address',
-  );
   if (!Array.isArray(stations)) fail(path, 'stations is not a list');
   return {
     version: 1,
     id,
     name: label,
     key,
-    owner,
     stations: stations.map((s, i) => stationOf(s, path, i)),
-    connectors: connectorsOf(parsed.connectors),
   };
 }
 
@@ -155,26 +140,8 @@ export function migrateAgentLayout(dir = agentsDir()): 'moved' | 'kept' | 'none'
   return 'moved';
 }
 
-function assertUnique(agents: AgentFile[], paths: string[]): void {
-  const ids = new Map<string, string>();
-  const keys = new Map<string, string>();
-  agents.forEach((agent, i) => {
-    const path = paths[i] ?? '';
-    const sameId = ids.get(agent.id);
-    if (sameId !== undefined) fail(path, `id ${agent.id} is already used by ${sameId}`);
-    ids.set(agent.id, path);
-    if (agent.key === null) return;
-    const sameKey = keys.get(agent.key);
-    if (sameKey !== undefined) fail(path, `its key is already used by ${sameKey}`);
-    keys.set(agent.key, path);
-  });
-}
-
 export function loadFileAgents(dir = agentsDir()): LoadedAgent[] {
-  const paths = listAgentFiles(dir);
-  const agents = paths.map(readAgentFile);
-  assertUnique(agents, paths);
-  return agents.map((agent) => ({
+  return listAgentFiles(dir).map(readAgentFile).map((agent) => ({
     id: agent.id,
     name: agent.name ?? agent.id,
     key: agent.key,

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

@@ -25,11 +25,6 @@ export function registerKey(key: string, agentId: string): void {
   agentIdByKeyHash.set(digest(key), agentId);
 }
 
-export function unregisterAgentKey(agentId: string): void {
-  for (const [hash, id] of agentIdByKeyHash)
-    if (id === agentId) agentIdByKeyHash.delete(hash);
-}
-
 export function agentIdForKey(token: string): string | undefined {
   if (token === '') return undefined;
   return agentIdByKeyHash.get(digest(token));

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

@@ -6,7 +6,8 @@ import { errMsg, log, logFatalSync } from '@metro-labs/core/log';
 import { acquireLock, STATE_DIR, trainsDir } from './paths.js';
 import { installCrashGuard, markDaemonReady } from './crash-guard.js';
 import { METRO_VERSION } from '@metro-labs/core/version';
-import { funnelDriver, Tunnel, tunnelWanted, webhookPort } from '../net/tunnel.js';
+import { funnelDriver, Tunnel, tunnelWanted } from '../net/tunnel.js';
+import { webhookPort } from '../files/attach-serve.js';
 import {
   localConnectHint,
   publicConnectHint,
@@ -31,10 +32,7 @@ import { migrateAgentLayout } from '../agents/files.js';
 import { ensureStationDeps } from '../stations/runtime-deps.js';
 import { localSessionApis } from '../routes/local-mode.js';
 import type { SessionApis } from '../routes/session-apis.js';
-import {
-  agentLiveness,
-  createMetroMcp,
-} from '../mcp/index.js';
+import { createMetroMcp } from '../mcp/index.js';
 import { gatherAccountsForAgents } from '../mcp/accounts.js';
 import {
   accountStationCapabilities,
@@ -106,7 +104,6 @@ function sessionApis(): SessionApis {
       },
       gatherAccounts: gatherAccountsForAgents,
       capabilities: accountStationCapabilities,
-      liveness: agentLiveness,
       prepareAccount,
     });
 }
@@ -117,7 +114,7 @@ async function main(): Promise<void> {
 installBearerSessions(agentsDir(), localOwner);
   migrateAgentLayout();
   log.info({ agent: await ensureLocalAgent() }, 'local daemon: agent');
-  await materializeFrom(fileSource, { allowEmpty: true });
+  await materializeFrom(fileSource);
   supervisor.start();
   const metroMcp = await createMetroMcp();
   webhookServer = await startWebhookServer(

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

@@ -1,24 +1,12 @@
-import { accountFromLine, agentIdForAccount } from '../agents/map.js';
-
 const accountStrippedLine = (line: string): string => {
   const parts = line.split('/');
   if (parts.length < 5) return line;
   return [parts[0], parts[1], parts[2], ...parts.slice(4)].join('/');
 };
 
-export const dedupeOwner = (line: string): string => {
-  const acct = accountFromLine(line);
-  if (!acct) return 'unowned';
-  const agentId = agentIdForAccount(acct.station, acct.accountId);
-  return agentId === undefined
-    ? `account:${acct.accountId}`
-    : `agent:${agentId}`;
-};
-
 export const dedupeKey = (
   station: string,
   line: string,
   kind: string,
   messageId: string,
-): string =>
-  `${dedupeOwner(line)} ${station} ${accountStrippedLine(line)} ${kind} ${messageId}`;
+): string => `${station} ${accountStrippedLine(line)} ${kind} ${messageId}`;

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

@@ -83,7 +83,7 @@ export class ChannelRelay {
   private withhold(event: MetroEvent, busSeq: number): void {
     this.ledger.delivered.delete(busSeq);
     this.deps.log(
-      'relay: withheld (line outside the channel session scope)',
+      'relay: withheld (no stream, or line outside the agent scope)',
       'busSeq',
       busSeq,
       'line',

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

@@ -43,7 +43,7 @@ import {
   type SessionDeps,
 } from './session.js';
 import { claudeVersion, updateClaude, type VersionDeps } from './version.js';
-import { readSessionFile, receiveSessionFile, SESSION_FILE_MAX, sessionFilePath, writeSessionFile } from './session-files.js';
+import { receiveSessionFile, sessionFilePath } from './session-files.js';
 import { createReadStream } from 'node:fs';
 import { pipeline } from 'node:stream/promises';
 import {
@@ -60,13 +60,11 @@ import {
 
 const PREFIX = '/api/claude';
 const BODY_MAX = SETTINGS_MAX + 4096;
-const SESSION_BODY_MAX = SESSION_FILE_MAX + 4096;
 const WRITABLE = new Set(['GET', 'DELETE', 'PUT', 'POST']);
 const PAGE = 100;
 const PAGE_MAX = 500;
 
 export interface ClaudeApiDeps {
-  authorize: (subject: string) => void;
   dir?: () => string;
   login?: LoginDeps;
   session?: SessionDeps;
@@ -98,7 +96,6 @@ const COLLECTIONS: Record<string, Handler> = {
 
 const ITEMS: Record<string, Handler> = {
   sessions: (query, dir, id) => {
-    if (query.get('raw') === '1') return { id, text: readSessionFile(projectOf(query), id, dir) };
     const { offset, limit } = pageOf(query);
     return readTranscript(projectOf(query), id, offset, limit, dir);
   },
@@ -111,7 +108,7 @@ const parts = (path: string): string[] => path.slice(PREFIX.length + 1).split('/
 const seenIn = (body: Record<string, unknown>): string | null | undefined =>
   'seenAt' in body ? (typeof body.seenAt === 'string' ? body.seenAt : null) : undefined;
 
-const WRITE_HEADS = new Set(['settings', 'skills', 'memory', 'sessions']);
+const WRITE_HEADS = new Set(['settings', 'skills', 'memory']);
 
 interface Write {
   text: string;
@@ -121,7 +118,6 @@ interface Write {
 
 function writeItem(head: string, item: string, write: Write, search: string, dir: string): unknown {
   if (head === 'skills') return writeClaudeSkill(decodeURIComponent(item), write.text, write.seen, dir);
-  if (head === 'sessions') return writeSessionFile(projectOf(new URLSearchParams(search)), item, write.text, dir);
   if (head === 'memory') return writeMemoryFile(projectOf(new URLSearchParams(search)), decodeURIComponent(item), write.text, dir, write.modifiedAt);
   return writeClaudeSettings(item, write.text, write.seen, dir);
 }
@@ -129,7 +125,7 @@ function writeItem(head: string, item: string, write: Write, search: string, dir
 async function writeAnswer(req: IncomingMessage, path: string, search: string, dir: string): Promise<unknown> {
   const [head = '', item = ''] = parts(path);
   if (!WRITE_HEADS.has(head) || item === '') throw new ApiError('method not allowed', 405);
-  const body = await readJsonBody(req, head === 'sessions' ? SESSION_BODY_MAX : BODY_MAX);
+  const body = await readJsonBody(req, BODY_MAX);
   if (!isRecord(body) || typeof body.text !== 'string') throw new ApiError('text is required', 400);
   const modifiedAt = typeof body.modifiedAt === 'string' ? body.modifiedAt : undefined;
   return writeItem(head, item, { text: body.text, seen: seenIn(body), modifiedAt }, search, dir);
@@ -315,7 +311,8 @@ async function streamed(req: IncomingMessage, res: ServerResponse, path: string,
     });
     return true;
   }
-  if (req.method === 'PUT' && !(req.headers['content-type'] ?? '').includes('json')) {
+  if (req.method === 'PUT') {
+    if ((req.headers['content-type'] ?? '').includes('json')) throw new ApiError('send the session file as text/plain', 415);
     sendJson(req, res, 200, await receiveSessionFile(projectOf(query), item, req, dir));
     return true;
   }
@@ -340,7 +337,6 @@ export function handleClaudeRequest(
   apiSession(req)
     .then(async (session) => {
       if (!session) throw new ApiError('unauthorized', 401);
-      deps.authorize(session.subject);
       if (req.method !== 'GET' && ADMIN_ONLY.test(path)) requireAdmin(session);
       if (await streamed(req, res, path, search, (deps.dir ?? claudeDir)())) return;
       sendJson(req, res, 200, await routed(req, path, search, deps));

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

@@ -2,21 +2,19 @@ import {
   closeSync,
   createReadStream,
   existsSync,
-  mkdirSync,
   openSync,
   readdirSync,
   readSync,
-  renameSync,
   rmSync,
   statSync,
   utimesSync,
-  writeFileSync,
 } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { ApiError } from '@metro-labs/http/api-error';
 import { isRecord } from '@metro-labs/core/is-record';
+import { writeAtomic } from '@metro-labs/core/secure-fs';
 
 export const PROJECT_RE = /^[A-Za-z0-9._-]{1,200}$/;
 export const SESSION_RE = /^[A-Za-z0-9][A-Za-z0-9-]{7,63}$/;
@@ -340,11 +338,8 @@ export function writeMemoryFile(project: string, name: string, text: string, dir
     throw new ApiError(`a memory file is at most ${String(MEMORY_MAX)} bytes`, 400);
   const folder = memoryDir(project, dir);
   const file = safeName(name, MEMORY_RE, 'memory file name');
-  mkdirSync(folder, { recursive: true });
   const path = join(folder, file);
-  const tmp = `${path}.metro-${String(process.pid)}`;
-  writeFileSync(tmp, text, { mode: MEMORY_MODE });
-  renameSync(tmp, path);
+  writeAtomic(path, text, MEMORY_MODE);
   const stamp = stampOf(modifiedAt);
   if (stamp !== null) utimesSync(path, stamp, stamp);
   const stat = statSync(path);

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

@@ -1,4 +1,4 @@
-import { createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { createWriteStream, existsSync, mkdirSync, renameSync, rmSync, statSync } from 'node:fs';
 import type { Readable } from 'node:stream';
 import { join } from 'node:path';
 import { ApiError } from '@metro-labs/http/api-error';
@@ -23,10 +23,6 @@ export function sessionFilePath(project: string, session: string, dir = claudeDi
   return path;
 }
 
-export function readSessionFile(project: string, session: string, dir = claudeDir()): string {
-  return readFileSync(sessionFilePath(project, session, dir), 'utf8');
-}
-
 const HEAD_BYTES = 64 * 1024;
 
 async function spool(body: Readable, tmp: string): Promise<string> {
@@ -77,14 +73,3 @@ function firstLineIsJson(text: string): boolean {
     return false;
   }
 }
-
-export function writeSessionFile(project: string, session: string, text: string, dir = claudeDir()): SessionFile {
-  if (!firstLineIsJson(text)) throw new ApiError('a session file is JSON lines, one Claude Code entry per line', 400);
-  if (Buffer.byteLength(text, 'utf8') > SESSION_FILE_MAX) throw new ApiError(`a session file is at most ${String(SESSION_FILE_MAX)} bytes`, 400);
-  const path = transcriptPath(project, session, dir);
-  mkdirSync(join(path, '..'), { recursive: true });
-  const tmp = `${path}.metro-${String(process.pid)}`;
-  writeFileSync(tmp, text, { mode: FILE_MODE });
-  renameSync(tmp, path);
-  return { id: safeName(session, SESSION_RE, 'session id'), bytes: statSync(path).size };
-}

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

@@ -1,14 +1,14 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { join } from 'node:path';
 import { ApiError } from '@metro-labs/http/api-error';
 import { claudeDir, listClaudeProjects } from './files.js';
 import { isRecord } from '@metro-labs/core/is-record';
 import { errMsg } from '@metro-labs/core/log';
+import { writeAtomic } from '@metro-labs/core/secure-fs';
 
 export const SETTINGS_MAX = 256 * 1024;
 const USER_ID = 'user';
 const LOCAL_SUFFIX = '.local';
-const DEFAULT_MODE = 0o644;
 
 export type SettingsScope = 'user' | 'project' | 'local';
 
@@ -92,23 +92,6 @@ function assertSettingsJson(text: string): void {
   if (!isRecord(parsed)) throw new ApiError('Claude Code settings must be a JSON object', 400);
 }
 
-function modeOf(path: string): number {
-  try {
-    return statSync(path).mode & 0o777;
-  } catch {
-    return DEFAULT_MODE;
-  }
-}
-
-function writeAtomic(path: string, text: string): void {
-  const mode = existsSync(path) ? modeOf(path) : DEFAULT_MODE;
-  mkdirSync(dirname(path), { recursive: true });
-  const tmp = `${path}.metro-${String(process.pid)}`;
-  writeFileSync(tmp, text, { mode });
-  chmodSync(tmp, mode);
-  renameSync(tmp, path);
-}
-
 export function writeClaudeSettings(
   id: string,
   text: string,