@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.131

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

@@ -0,0 +1,140 @@
+import { execFile } from 'node:child_process';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+
+const MARKETPLACE = 'metro';
+const PLUGIN = 'metro@metro';
+const STEP_MS = 120_000;
+const SAID_MAX = 300;
+
+export interface Answer {
+  status: number;
+  stdout: string;
+  stderr: string;
+}
+
+export type Run = (args: string[]) => Promise<Answer>;
+
+export interface PluginInstallDeps {
+  run: Run | null;
+  marketplaceDir: string | null;
+}
+
+export type PluginOutcome = 'skipped' | 'unchanged' | 'installed' | 'updated' | 'failed';
+
+export function stagedMarketplaceDir(env: NodeJS.ProcessEnv = process.env): string | null {
+  const store = env.METRO_RUNTIME_STORE?.trim() ?? '';
+  if (store === '') return null;
+  const dir = join(store, 'marketplace');
+  return existsSync(join(dir, '.claude-plugin', 'marketplace.json')) ? dir : null;
+}
+
+export function stagedPluginVersion(dir: string): string | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(join(dir, 'plugin', '.claude-plugin', 'plugin.json'), 'utf8'));
+    return isRecord(parsed) && typeof parsed.version === 'string' ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+
+const runner =
+  (bin: string): Run =>
+  (args) =>
+    new Promise((resolve) => {
+      execFile(bin, args, { encoding: 'utf8', timeout: STEP_MS, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+        const status = err === null ? 0 : typeof (err as { code?: unknown }).code === 'number' ? (err as { code: number }).code : 1;
+        resolve({ status, stdout, stderr });
+      });
+    });
+
+export async function findClaude(candidates = ['claude', join(homedir(), '.local', 'bin', 'claude')]): Promise<Run | null> {
+  for (const bin of candidates) {
+    const run = runner(bin);
+    if ((await run(['--version'])).status === 0) return run;
+  }
+  return null;
+}
+
+function listOf(stdout: string): Record<string, unknown>[] {
+  try {
+    const parsed: unknown = JSON.parse(stdout);
+    return Array.isArray(parsed) ? parsed.filter(isRecord) : [];
+  } catch {
+    return [];
+  }
+}
+
+const realish = (path: string): string => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+};
+
+const samePath = (a: string | null, b: string): boolean => a !== null && realish(a) === realish(b);
+
+async function step(run: Run, args: string[]): Promise<boolean> {
+  const answer = await run(args);
+  if (answer.status === 0) {
+    log.info({ args }, 'plugin: claude');
+    return true;
+  }
+  log.warn({ args, said: `${answer.stderr}${answer.stdout}`.trim().slice(0, SAID_MAX) }, 'plugin: claude refused');
+  return false;
+}
+
+async function marketplacePath(run: Run): Promise<string | null | undefined> {
+  const mine = listOf((await run(['plugin', 'marketplace', 'list', '--json'])).stdout).find((m) => m.name === MARKETPLACE);
+  if (mine === undefined) return undefined;
+  const at = mine.installLocation ?? mine.path;
+  return typeof at === 'string' ? at : null;
+}
+
+async function ensureMarketplace(run: Run, dir: string): Promise<boolean> {
+  const at = await marketplacePath(run);
+  if (at !== undefined && samePath(at, dir)) return true;
+  if (at !== undefined) await step(run, ['plugin', 'marketplace', 'remove', MARKETPLACE]);
+  return step(run, ['plugin', 'marketplace', 'add', dir]);
+}
+
+async function installedVersion(run: Run): Promise<string | null> {
+  const mine = listOf((await run(['plugin', 'list', '--json'])).stdout).find((p) => p.id === PLUGIN);
+  return mine !== undefined && typeof mine.version === 'string' ? mine.version : null;
+}
+
+async function ensureInstalled(run: Run, wanted: string | null): Promise<PluginOutcome> {
+  const have = await installedVersion(run);
+  if (have === null) return (await step(run, ['plugin', 'install', PLUGIN, '-y', '--scope', 'user'])) ? 'installed' : 'failed';
+  if (wanted === null || have === wanted) return 'unchanged';
+  await step(run, ['plugin', 'marketplace', 'update', MARKETPLACE]);
+  return (await step(run, ['plugin', 'update', PLUGIN, '-y'])) ? 'updated' : 'failed';
+}
+
+function explainMissingMarketplace(env: NodeJS.ProcessEnv = process.env): void {
+  const store = env.METRO_RUNTIME_STORE?.trim() ?? '';
+  if (store === '') return;
+  log.warn(
+    { store },
+    'plugin: the runtime store holds no plugin marketplace, so metro cannot install its Claude Code plugin; a `metro serve` started before beta.97 never copied it, restart the service once',
+  );
+}
+
+export async function ensureMetroPlugin(deps?: Partial<PluginInstallDeps>): Promise<PluginOutcome> {
+  const dir = deps?.marketplaceDir === undefined ? stagedMarketplaceDir() : deps.marketplaceDir;
+  if (dir === null) {
+    if (deps?.marketplaceDir === undefined) explainMissingMarketplace();
+    return 'skipped';
+  }
+  const run = deps?.run === undefined ? await findClaude() : deps.run;
+  if (run === null) {
+    log.info('plugin: claude is not on this machine, so metro leaves its Claude Code plugin alone');
+    return 'skipped';
+  }
+  if (!(await ensureMarketplace(run, dir))) return 'failed';
+  return ensureInstalled(run, stagedPluginVersion(dir));
+}

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

@@ -0,0 +1,90 @@
+import { createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import type { Readable } from 'node:stream';
+import { join } from 'node:path';
+import { ApiError } from '@metro-labs/http/api-error';
+import { isRecord } from '@metro-labs/core/is-record';
+import { claudeDir, PROJECT_RE, safeName, SESSION_RE } from './files.js';
+
+export const SESSION_FILE_MAX = 512 * 1024 * 1024;
+const FILE_MODE = 0o644;
+
+export interface SessionFile {
+  id: string;
+  bytes: number;
+}
+
+const transcriptPath = (project: string, session: string, dir: string): string =>
+  join(dir, 'projects', safeName(project, PROJECT_RE, 'Claude project id'), `${safeName(session, SESSION_RE, 'session id')}.jsonl`);
+
+export function sessionFilePath(project: string, session: string, dir = claudeDir()): string {
+  const path = transcriptPath(project, session, dir);
+  if (!existsSync(path)) throw new ApiError('no such session', 404);
+  if (statSync(path).size > SESSION_FILE_MAX) throw new ApiError(`a session file is at most ${String(SESSION_FILE_MAX)} bytes`, 400);
+  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> {
+  const out = createWriteStream(tmp, { mode: FILE_MODE });
+  const head: Buffer[] = [];
+  let total = 0;
+  let kept = 0;
+  for await (const chunk of body) {
+    const buf = chunk as Buffer;
+    total += buf.length;
+    if (total > SESSION_FILE_MAX) {
+      out.destroy();
+      rmSync(tmp, { force: true });
+      throw new ApiError(`a session file is at most ${String(SESSION_FILE_MAX)} bytes`, 413);
+    }
+    if (kept < HEAD_BYTES) {
+      head.push(buf.subarray(0, HEAD_BYTES - kept));
+      kept += buf.length;
+    }
+    if (!out.write(buf)) await new Promise<void>((r) => out.once('drain', r));
+  }
+  await new Promise<void>((resolve, reject) => {
+    out.once('error', reject);
+    out.end(resolve);
+  });
+  return Buffer.concat(head).toString('utf8');
+}
+
+export async function receiveSessionFile(project: string, session: string, body: Readable, dir = claudeDir()): Promise<SessionFile> {
+  const path = transcriptPath(project, session, dir);
+  mkdirSync(join(path, '..'), { recursive: true });
+  const tmp = `${path}.metro-${String(process.pid)}`;
+  const head = await spool(body, tmp);
+  if (!firstLineIsJson(head)) {
+    rmSync(tmp, { force: true });
+    throw new ApiError('a session file is JSON lines, one Claude Code entry per line', 400);
+  }
+  renameSync(tmp, path);
+  return { id: safeName(session, SESSION_RE, 'session id'), bytes: statSync(path).size };
+}
+
+function firstLineIsJson(text: string): boolean {
+  const first = text.split('\n').find((line) => line.trim() !== '');
+  if (first === undefined) return false;
+  try {
+    return isRecord(JSON.parse(first));
+  } catch {
+    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/session.ts

@@ -0,0 +1,253 @@
+import { spawnSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { readJson, writeJson } from '@metro-labs/core/secure-fs';
+import { METRO_VERSION } from '@metro-labs/core/version';
+import { agentsDir, listAgentFiles } from '../agents/files.js';
+import { notReady, readModelConfig } from '../gateway/model-config.js';
+import { claudeDir, listClaudeProjects } from './files.js';
+import { claudeAccount, claudeInstalled } from './login.js';
+import { trustFolder } from './onboarding.js';
+
+export const SESSION_NAME = 'metro';
+const STATE_FILE = 'claude-session.json';
+const WARNING = 'WARNING: Loading development channels';
+const CONFIRM_POLL_MS = 500;
+const CONFIRM_WAIT_MS = 60_000;
+const WATCH_MS = 15_000;
+const STRIKE_WINDOW_MS = 60_000;
+const MAX_STRIKES = 5;
+const PAUSE_MS = 30 * 60_000;
+
+export interface SessionDeps {
+  tmux?: string;
+  metro?: string[];
+  home?: string;
+  agents?: string;
+  signedIn?: () => boolean;
+  now?: () => number;
+  version?: string;
+  continues?: (home: string) => boolean;
+}
+
+export interface SessionStatus {
+  name: string;
+  running: boolean;
+  autostart: boolean;
+  blocked: string | null;
+  lastStartedAt: string | null;
+  lastError: string | null;
+}
+
+interface Memory {
+  lastStartedAt: number | null;
+  lastError: string | null;
+  strikes: number;
+  pausedUntil: number;
+}
+
+const memory: Memory = { lastStartedAt: null, lastError: null, strikes: 0, pausedUntil: 0 };
+
+const statePath = (agents: string): string => join(agents, STATE_FILE);
+
+function readState(agents: string): Record<string, unknown> {
+  const raw = readJson<unknown>(statePath(agents), null);
+  return isRecord(raw) ? raw : {};
+}
+
+const writeState = (agents: string, patch: Record<string, unknown>): void => {
+  writeJson(statePath(agents), { ...readState(agents), ...patch });
+};
+
+export const autostartEnabled = (agents = agentsDir()): boolean => readState(agents).autostart !== false;
+
+export function setAutostart(enabled: boolean, agents = agentsDir()): void {
+  writeState(agents, { autostart: enabled });
+}
+
+export function startedVersion(agents = agentsDir()): string | null {
+  const version = readState(agents).version;
+  return typeof version === 'string' ? version : null;
+}
+
+function tmuxOk(tmux: string, args: string[]): boolean {
+  const run = spawnSync(tmux, args, { stdio: 'ignore' });
+  return run.error === undefined && run.status === 0;
+}
+
+export const sessionRunning = (tmux = 'tmux'): boolean => tmuxOk(tmux, ['has-session', '-t', SESSION_NAME]);
+
+function realDir(dir: string): string {
+  try {
+    return realpathSync(dir);
+  } catch {
+    return dir;
+  }
+}
+
+export function hasConversation(home: string, dir = claudeDir()): boolean {
+  const cwd = realDir(home);
+  return listClaudeProjects(dir).some((project) => project.sessions > 0 && project.cwd !== null && realDir(project.cwd) === cwd);
+}
+
+function metroCommand(deps: SessionDeps, home: string): string[] {
+  const bin = process.env.METRO_CLI_BIN?.trim() ?? '';
+  const base = deps.metro ?? (bin === '' ? ['metro', 'claude'] : [process.execPath, bin, 'claude']);
+  const continues = (deps.continues ?? hasConversation)(home);
+  return continues ? [...base, '-c'] : base;
+}
+
+function credentialReady(deps: SessionDeps): string | null {
+  const signedIn = deps.signedIn ?? (() => claudeAccount().signedIn);
+  if (signedIn()) return null;
+  try {
+    const cfg = readModelConfig(deps.agents ?? agentsDir());
+    if (cfg.provider !== 'anthropic' && notReady(cfg) === null) return null;
+  } catch (err) {
+    return `the Model page is not readable (${errMsg(err)})`;
+  }
+  return 'Claude Code is not signed in and the Model page routes nowhere yet';
+}
+
+export function sessionBlocked(deps: SessionDeps = {}): string | null {
+  const agents = deps.agents ?? agentsDir();
+  if (listAgentFiles(agents).length === 0) return 'no agent on this machine yet';
+  if (deps.metro === undefined && !claudeInstalled()) return 'Claude Code is not installed on this machine';
+  if (!tmuxOk(deps.tmux ?? 'tmux', ['-V'])) return 'tmux is not installed on this machine';
+  return credentialReady(deps);
+}
+
+function capturePane(tmux: string): string {
+  const run = spawnSync(tmux, ['capture-pane', '-p', '-t', SESSION_NAME], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  return run.error === undefined && run.status === 0 ? run.stdout : '';
+}
+
+function confirmChannels(tmux: string, until: number): void {
+  const tick = (): void => {
+    const pane = capturePane(tmux);
+    if (pane.includes(WARNING) && pane.includes('server:metro')) {
+      spawnSync(tmux, ['send-keys', '-t', SESSION_NAME, 'Enter'], { stdio: 'ignore' });
+      log.info('claude-session: confirmed the development channels dialog for server:metro');
+      return;
+    }
+    if (Date.now() < until && sessionRunning(tmux)) setTimeout(tick, CONFIRM_POLL_MS).unref();
+  };
+  setTimeout(tick, CONFIRM_POLL_MS).unref();
+}
+
+function recordStart(deps: SessionDeps, tmux: string, now: number, run: { error?: Error; status: number | null; stderr: string }): void {
+  memory.lastStartedAt = now;
+  if (run.error !== undefined || run.status !== 0) {
+    memory.lastError = run.error === undefined ? `tmux new-session exited ${String(run.status)}: ${run.stderr.trim()}` : errMsg(run.error);
+    log.warn({ err: memory.lastError }, 'claude-session: tmux could not start');
+    return;
+  }
+  memory.lastError = null;
+  writeState(deps.agents ?? agentsDir(), { version: deps.version ?? METRO_VERSION });
+  confirmChannels(tmux, now + CONFIRM_WAIT_MS);
+}
+
+export function startSession(deps: SessionDeps = {}): SessionStatus {
+  const tmux = deps.tmux ?? 'tmux';
+  const home = deps.home ?? homedir();
+  const now = (deps.now ?? Date.now)();
+  const trusted = trustFolder(home);
+  const [command = 'metro', ...args] = metroCommand(deps, home);
+  const run = spawnSync(tmux, ['new-session', '-d', '-s', SESSION_NAME, '-c', home, '-x', '200', '-y', '50', command, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], cwd: home });
+  recordStart(deps, tmux, now, run);
+  if (memory.lastError === null) log.info({ home, trusted, command: [command, ...args].join(' ') }, 'claude-session: started Claude Code in tmux');
+  return sessionStatus(deps);
+}
+
+export function stopSession(deps: SessionDeps = {}): SessionStatus {
+  spawnSync(deps.tmux ?? 'tmux', ['kill-session', '-t', SESSION_NAME], { stdio: 'ignore' });
+  return sessionStatus(deps);
+}
+
+export function sessionStatus(deps: SessionDeps = {}): SessionStatus {
+  return {
+    name: SESSION_NAME,
+    running: sessionRunning(deps.tmux ?? 'tmux'),
+    autostart: autostartEnabled(deps.agents ?? agentsDir()),
+    blocked: sessionBlocked(deps),
+    lastStartedAt: memory.lastStartedAt === null ? null : new Date(memory.lastStartedAt).toISOString(),
+    lastError: memory.lastError,
+  };
+}
+
+function strike(now: number): boolean {
+  if (memory.lastStartedAt !== null && now - memory.lastStartedAt < STRIKE_WINDOW_MS) memory.strikes += 1;
+  else memory.strikes = 1;
+  if (memory.strikes < MAX_STRIKES) return false;
+  memory.pausedUntil = now + PAUSE_MS;
+  memory.strikes = 0;
+  log.warn({ pauseMinutes: PAUSE_MS / 60_000 }, 'claude-session: Claude Code keeps exiting right after starting; not restarting it for a while');
+  return true;
+}
+
+export type Ensured = 'started' | 'restarted' | 'running' | 'blocked' | 'off' | 'paused';
+
+function holdsBack(deps: SessionDeps, now: number): Ensured | null {
+  if (now < memory.pausedUntil) return 'paused';
+  if (sessionBlocked(deps) !== null) return 'blocked';
+  return strike(now) ? 'paused' : null;
+}
+
+interface Resolved {
+  now: number;
+  agents: string;
+  version: string;
+  tmux: string;
+}
+
+const resolved = (deps: SessionDeps): Resolved => ({
+  now: (deps.now ?? Date.now)(),
+  agents: deps.agents ?? agentsDir(),
+  version: deps.version ?? METRO_VERSION,
+  tmux: deps.tmux ?? 'tmux',
+});
+
+function situation(r: Resolved): 'running' | 'stale' | 'absent' {
+  if (!sessionRunning(r.tmux)) return 'absent';
+  return startedVersion(r.agents) === r.version ? 'running' : 'stale';
+}
+
+export function ensureSession(deps: SessionDeps = {}): Ensured {
+  const r = resolved(deps);
+  if (!autostartEnabled(r.agents)) return 'off';
+  const found = situation(r);
+  if (found === 'running') return 'running';
+  const held = holdsBack(deps, r.now);
+  if (held !== null) return held;
+  if (found === 'stale') {
+    log.info({ was: startedVersion(r.agents), now: r.version }, 'claude-session: restarting the session an older metro started, so the new plugin and flags load');
+    stopSession(deps);
+  }
+  startSession(deps);
+  return found === 'stale' ? 'restarted' : 'started';
+}
+
+let watcher: ReturnType<typeof setInterval> | null = null;
+
+export function watchSession(deps: SessionDeps = {}, everyMs = WATCH_MS): void {
+  if (watcher !== null) return;
+  const tick = (): void => {
+    try {
+      const outcome = ensureSession(deps);
+      if (outcome === 'started' || outcome === 'restarted') log.info({ outcome }, 'claude-session: Claude Code is up');
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'claude-session: check failed');
+    }
+  };
+  watcher = setInterval(tick, everyMs);
+  watcher.unref();
+  setTimeout(tick, 1_000).unref();
+}
+
+export function unwatchSession(): void {
+  if (watcher !== null) clearInterval(watcher);
+  watcher = null;
+}

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

@@ -0,0 +1,117 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, 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';
+
+export const SETTINGS_MAX = 256 * 1024;
+const USER_ID = 'user';
+const LOCAL_SUFFIX = '.local';
+const DEFAULT_MODE = 0o644;
+
+export type SettingsScope = 'user' | 'project' | 'local';
+
+export interface ClaudeSettingsFile {
+  id: string;
+  scope: SettingsScope;
+  label: string;
+  path: string;
+  exists: boolean;
+  editable: boolean;
+  text: string;
+  modifiedAt: string | null;
+}
+
+const missing = (id: string, scope: SettingsScope, label: string, path: string): ClaudeSettingsFile => ({
+  id,
+  scope,
+  label,
+  path,
+  exists: false,
+  editable: true,
+  text: '',
+  modifiedAt: null,
+});
+
+function entryOf(id: string, scope: SettingsScope, label: string, path: string): ClaudeSettingsFile {
+  if (!existsSync(path)) return missing(id, scope, label, path);
+  const stat = statSync(path);
+  const editable = stat.size <= SETTINGS_MAX;
+  return {
+    id,
+    scope,
+    label,
+    path,
+    exists: true,
+    editable,
+    text: editable ? readFileSync(path, 'utf8') : '',
+    modifiedAt: stat.mtime.toISOString(),
+  };
+}
+
+const PROJECT_FILES: [string, SettingsScope, string][] = [
+  ['', 'project', 'settings.json'],
+  [LOCAL_SUFFIX, 'local', 'settings.local.json'],
+];
+
+function projectEntries(dir: string): ClaudeSettingsFile[] {
+  const out: ClaudeSettingsFile[] = [];
+  for (const project of listClaudeProjects(dir)) {
+    const cwd = project.cwd;
+    if (cwd === null) continue;
+    for (const [suffix, scope, name] of PROJECT_FILES) {
+      const path = join(cwd, '.claude', name);
+      if (existsSync(path)) out.push(entryOf(`${project.id}${suffix}`, scope, cwd, path));
+    }
+  }
+  return out;
+}
+
+export function listClaudeSettings(dir = claudeDir()): ClaudeSettingsFile[] {
+  return [entryOf(USER_ID, 'user', 'This machine', join(dir, 'settings.json')), ...projectEntries(dir)];
+}
+
+function assertSettingsJson(text: string): void {
+  if (text.length > SETTINGS_MAX) throw new ApiError('that is more text than a settings file may hold', 413);
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    throw new ApiError(`that is not valid JSON: ${errMsg(err)}`, 400);
+  }
+  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,
+  seenAt: string | null | undefined,
+  dir = claudeDir(),
+): ClaudeSettingsFile {
+  const target = listClaudeSettings(dir).find((file) => file.id === id);
+  if (target === undefined) throw new ApiError('no such settings file', 404);
+  if (!target.editable) throw new ApiError('that settings file is too large to edit here', 409);
+  assertSettingsJson(text);
+  if (seenAt !== undefined && seenAt !== target.modifiedAt)
+    throw new ApiError('that file changed on disk since you opened it; reload it before saving', 409);
+  writeAtomic(target.path, text);
+  return entryOf(target.id, target.scope, target.label, target.path);
+}