claude-autorouter 0.2.0

package/src/savings.mjs

@@ -0,0 +1,208 @@
+// Published standard, global API prices in cents per million tokens. These are
+// API-equivalent estimates, not subscription charges. Exact IDs only: an
+// unfamiliar model must not inherit another model's price from its name.
+// https://platform.claude.com/docs/en/about-claude/pricing (2026-09-29)
+const HAIKU_45 = { input: 100, output: 500, write5m: 125, write1h: 200, read: 10 };
+const SONNET_5 = { input: 200, output: 1000, write5m: 250, write1h: 400, read: 20 };
+const OPUS_5 = { input: 500, output: 2500, write5m: 625, write1h: 1000, read: 50 };
+const OPUS_55 = { input: 400, output: 2000, write5m: 500, write1h: 800, read: 20 };
+const PRICES = new Map([
+  ['claude-haiku-4-5', HAIKU_45], ['claude-haiku-4-5-20251001', HAIKU_45],
+  ['claude-sonnet-5', SONNET_5], ['claude-sonnet-5-5', SONNET_5],
+  ['claude-opus-5', OPUS_5], ['claude-opus-5-5', OPUS_55],
+]);
+const OPUS_MODELS = new Set(['claude-opus-5', 'claude-opus-5-5']);
+const EVENTS = new Set(['request_start', 'route', 'upstream_response', 'upstream_model', 'upstream_usage',
+  'upstream_error', 'request_complete', 'request_error', 'request_cancelled']);
+const MAX_SESSIONS = 100;
+const MAX_INFLIGHT = 1000;
+const MAX_HISTORY = 10000;
+const identifier = value => typeof value === 'string' && /^[\w.:-]{1,200}$/.test(value) ? value : undefined;
+const count = value => Number.isSafeInteger(value) && value >= 0;
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+function standardPricing(context, allowUnavailableGeo = false) {
+  if (context === undefined) return true;
+  if (!object(context)) return false;
+  return (context.pricing_unsupported === undefined || context.pricing_unsupported === false)
+    && (context.unsupported === undefined || context.unsupported === false)
+    && (context.speed === undefined || context.speed === 'standard')
+    && (context.inference_geo === undefined || context.inference_geo === 'global'
+      || (allowUnavailableGeo && context.inference_geo === 'not_available'))
+    && (context.service_tier === undefined || ['auto', 'standard_only', 'standard'].includes(context.service_tier));
+}
+
+function normalizeUsage(usage, prices) {
+  // Haiku 4.5 predates inference geography controls: Anthropic reports
+  // "not_available" and standard pricing applies. Do not extend this exception
+  // to newer models, whose unknown geography could carry a different rate.
+  // https://platform.claude.com/docs/en/manage-claude/data-residency#pricing
+  if (!object(usage) || !count(usage.input_tokens) || !count(usage.output_tokens)
+    || !standardPricing(usage, prices === HAIKU_45)) return;
+  const read = usage.cache_read_input_tokens ?? 0;
+  // Missing counters are optional; explicit null or malformed counters are not.
+  if (!count(read) || usage.cache_read_input_tokens === null || usage.cache_creation_input_tokens === null) return;
+  const creation = usage.cache_creation_input_tokens;
+  if (creation !== undefined && !count(creation)) return;
+  let write5m = 0, write1h = 0;
+  if (usage.cache_creation !== undefined) {
+    if (!object(usage.cache_creation)) return;
+    write5m = usage.cache_creation.ephemeral_5m_input_tokens ?? 0;
+    write1h = usage.cache_creation.ephemeral_1h_input_tokens ?? 0;
+    if (!count(write5m) || !count(write1h)
+      || usage.cache_creation.ephemeral_5m_input_tokens === null || usage.cache_creation.ephemeral_1h_input_tokens === null) return;
+    if (!count(write5m + write1h) || (creation !== undefined && creation !== write5m + write1h)) return;
+  } else if (creation > 0) {
+    // The aggregate alone cannot distinguish a five-minute from a one-hour
+    // cache write, so it cannot establish the price.
+    return;
+  }
+  return { input: usage.input_tokens, output: usage.output_tokens, read, write5m, write1h };
+}
+
+function cost(usage, prices) {
+  // Integer arithmetic avoids floating-point drift over a long session. A unit
+  // here is 1/100,000,000 of a dollar (one cent per million tokens).
+  return Object.keys(usage).reduce((total, key) => total + BigInt(usage[key]) * BigInt(prices[key]), 0n);
+}
+
+export function createSavingsTracker({ baselineModel = 'claude-opus-5-5' } = {}) {
+  const baseline = OPUS_MODELS.has(baselineModel) ? PRICES.get(baselineModel) : undefined;
+  const baselineName = typeof baselineModel === 'string' && /^[\w.:/-]{1,120}$/.test(baselineModel) ? baselineModel : 'unknown';
+  const sessions = new Map();
+  const inflight = new Map();
+  const settled = new Map();
+  const evictedSessions = new Set();
+  let historyPartial = false;
+
+  function remember(key) {
+    settled.set(key, true);
+    while (settled.size > MAX_HISTORY) {
+      settled.delete(settled.keys().next().value);
+      historyPartial = true;
+    }
+  }
+
+  function finish(key, failed = false, partial = false) {
+    const request = inflight.get(key);
+    if (!request) return;
+    inflight.delete(key);
+    remember(key);
+    const session = sessions.get(request.sessionId);
+    if (!session) return;
+    if (partial) session.partial = true;
+    if (failed || request.failed || request.invalid || !request.prices || !request.usage || !baseline) {
+      session.unpriced_requests++;
+      return;
+    }
+    session.actual += cost(request.usage, request.prices);
+    session.baseline += cost(request.usage, baseline);
+    session.requests++;
+  }
+
+  function sessionFor(sessionId) {
+    let session = sessions.get(sessionId);
+    if (session) {
+      sessions.delete(sessionId);
+      sessions.set(sessionId, session);
+      return session;
+    }
+    session = { actual: 0n, baseline: 0n, requests: 0, unpriced_requests: 0,
+      partial: historyPartial || evictedSessions.has(sessionId) };
+    sessions.set(sessionId, session);
+    while (sessions.size > MAX_SESSIONS) {
+      const oldest = sessions.keys().next().value;
+      sessions.delete(oldest);
+      evictedSessions.add(oldest);
+      for (const [key, request] of inflight) {
+        if (request.sessionId === oldest) { inflight.delete(key); remember(key); }
+      }
+      if (evictedSessions.size > MAX_HISTORY) {
+        evictedSessions.delete(evictedSessions.values().next().value);
+        historyPartial = true;
+      }
+    }
+    return session;
+  }
+
+  function update(event) {
+    try {
+      if (!event || !EVENTS.has(event.event)) return;
+      const sessionId = event.session_id == null || event.session_id === '' ? '' : identifier(event.session_id);
+      const requestId = identifier(event.request_id);
+      if (sessionId === undefined || requestId === undefined) return;
+      const key = `${sessionId}\0${requestId}`;
+      if (event.event === 'request_start') {
+        if (inflight.has(key) || settled.has(key)) return;
+        sessionFor(sessionId);
+        while (inflight.size >= MAX_INFLIGHT) finish(inflight.keys().next().value, true, true);
+        inflight.set(key, { sessionId, invalid: !standardPricing(event.pricing_context) });
+        return;
+      }
+      const request = inflight.get(key);
+      if (!request) return;
+      switch (event.event) {
+        case 'route':
+          if (!standardPricing(event.pricing_context)) request.invalid = true;
+          break;
+        case 'upstream_response':
+          if (!Number.isInteger(event.status) || event.status < 200 || event.status >= 300) request.failed = true;
+          break;
+        case 'upstream_model': {
+          const prices = PRICES.get(event.model);
+          if (!prices || (request.prices && request.prices !== prices)) request.invalid = true;
+          request.prices = prices;
+          break;
+        }
+        case 'upstream_usage': {
+          const usage = normalizeUsage(event.usage, request.prices);
+          if (!usage || !standardPricing(event.pricing_context)) request.invalid = true;
+          else if (request.usage && Object.keys(usage).some(key => usage[key] !== request.usage[key])) request.invalid = true;
+          else request.usage = usage;
+          break;
+        }
+        case 'upstream_error':
+          request.failed = true;
+          break;
+        case 'request_complete':
+          finish(key);
+          break;
+        case 'request_error':
+        case 'request_cancelled':
+          finish(key, true);
+          break;
+      }
+    } catch {
+      // Telemetry must never interfere with inference. A malformed event must
+      // not make partially understood usage look billable.
+      try {
+        const sessionId = event?.session_id == null ? '' : identifier(event.session_id);
+        const requestId = identifier(event?.request_id);
+        const request = inflight.get(`${sessionId}\0${requestId}`);
+        if (request) request.invalid = true;
+      } catch {}
+    }
+  }
+
+  function snapshot() {
+    return Object.fromEntries([...sessions].map(([sessionId, session]) => {
+      const saved = session.baseline - session.actual;
+      return [sessionId, {
+        baseline_model: baselineName,
+        actual_usd: Number(session.actual) / 100000000,
+        baseline_usd: Number(session.baseline) / 100000000,
+        saved_usd: Number(saved) / 100000000,
+        percent: session.baseline === 0n ? 0 : Number(saved) / Number(session.baseline) * 100,
+        requests: session.requests,
+        unpriced_requests: session.unpriced_requests,
+        ...(session.partial || historyPartial ? { partial: true } : {}),
+      }];
+    }));
+  }
+
+  function clear() {
+    sessions.clear(); inflight.clear(); settled.clear(); evictedSessions.clear(); historyPartial = false;
+  }
+
+  return { update, snapshot, clear };
+}

package/src/server.mjs

@@ -0,0 +1,215 @@
+import http from 'node:http';
+import https from 'node:https';
+import { randomUUID, timingSafeEqual } from 'node:crypto';
+import { pipeline } from 'node:stream/promises';
+import { Router } from './router.mjs';
+import { LOCAL_AUTH_HEADER, isSubscriptionRequest } from './auth.mjs';
+import { prepareRequest } from './model-request.mjs';
+import { createResponseObserver } from './response-observer.mjs';
+import { createTokenCounter } from './token-counter.mjs';
+
+function cleanHeaders(headers) {
+  const blocked = new Set(['host', 'connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade', 'content-length']);
+  for (const name of String(headers.connection ?? '').split(',')) blocked.add(name.trim().toLowerCase());
+  return Object.fromEntries(Object.entries(headers).filter(([name, value]) => value !== undefined && !blocked.has(name.toLowerCase())));
+}
+
+function authorized(req, config) {
+  const credential = config.authMode === 'subscription'
+    ? req.headers[LOCAL_AUTH_HEADER]
+    : req.headers['x-api-key'] ?? req.headers.authorization?.replace(/^Bearer /i, '');
+  if (typeof credential !== 'string') return false;
+  const actual = Buffer.from(credential);
+  const expected = Buffer.from(config.localToken);
+  return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+
+function readBody(req, limit) {
+  return new Promise((resolve, reject) => {
+    let bytes = 0;
+    const chunks = [];
+    req.on('data', chunk => {
+      bytes += chunk.length;
+      if (bytes > limit) {
+        chunks.length = 0;
+        reject(Object.assign(new Error('Request body too large'), { status: 413 }));
+      } else chunks.push(chunk);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+    req.on('aborted', () => reject(new Error('Client disconnected')));
+  });
+}
+
+function jsonError(res, status, message) {
+  if (res.headersSent || res.destroyed) { res.destroy(); return; }
+  res.writeHead(status, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message } }));
+}
+
+function upstreamHeaders(incoming, config) {
+  const headers = cleanHeaders(incoming);
+  delete headers[LOCAL_AUTH_HEADER];
+  delete headers.cookie;
+  // Negotiate an uncompressed stream so the model ID can be observed without
+  // altering any response bytes or buffering generation output.
+  headers['accept-encoding'] = 'identity';
+  if (config.authMode === 'subscription') {
+    // Do not cache or refresh this credential; Claude Code owns its lifecycle.
+    // Keep Authorization and anthropic-beta intact, including on token refresh.
+    delete headers['x-api-key'];
+  } else {
+    delete headers.authorization;
+    headers['x-api-key'] = config.anthropicKey;
+  }
+  return headers;
+}
+
+async function forward(url, req, res, body, config, signal, log, status) {
+  const headers = upstreamHeaders(req.headers, config);
+  if (body) headers['content-length'] = String(body.length);
+  const transport = url.protocol === 'https:' ? https : http;
+  const upstream = await new Promise((resolve, reject) => {
+    const outgoing = transport.request(url, { method: req.method, headers, signal }, resolve);
+    outgoing.on('error', reject);
+    outgoing.end(body);
+  });
+  // Native HTTP streams retain compression and SSE bytes verbatim.
+  log({ event: 'upstream_response', status: upstream.statusCode });
+  status('upstream_response', { status: upstream.statusCode });
+  // An upstream disconnect can make pipeline destroy the downstream response.
+  // Record it before that close is mistaken for a user cancellation.
+  upstream.once('aborted', () => {
+    if (!signal.aborted) status('request_error', { status: 502 });
+  });
+  res.writeHead(upstream.statusCode, cleanHeaders(upstream.headers));
+  try {
+    if (!upstream.headers['content-encoding'] || upstream.headers['content-encoding'] === 'identity') {
+      const observer = createResponseObserver({
+        contentType: upstream.headers['content-type'],
+        onModel: ({ model }) => { log({ event: 'upstream_model', model }); status('upstream_model', { model }); },
+        onError: ({ error_type }) => { log({ event: 'upstream_error', error_type }); status('upstream_error', { error_type }); },
+        onUsage: ({ usage }) => { if (upstream.statusCode >= 200 && upstream.statusCode < 300) status('upstream_usage', { usage }); },
+      });
+      await pipeline(upstream, observer, res, { signal });
+    } else {
+      await pipeline(upstream, res, { signal });
+    }
+  } catch (error) {
+    if (!signal.aborted || signal.reason?.name === 'TimeoutError') status('request_error', { status: 502 });
+    throw error;
+  }
+}
+
+export function createRouterServer(config, { router = new Router(config), tokenCounter = createTokenCounter(config), log = entry => process.stderr.write(`${JSON.stringify(entry)}\n`), onStatus = () => {} } = {}) {
+  if (!config.localToken || config.localToken.length < 16) throw new Error('AUTOROUTER_TOKEN must contain at least 16 characters');
+  const server = http.createServer(async (req, res) => {
+    const controller = new AbortController();
+    let context;
+    let finished = false;
+    const status = (event, fields = {}) => {
+      if (!context || finished) return;
+      if (['request_complete', 'request_error', 'request_cancelled'].includes(event)) finished = true;
+      // Optional observability must never delay or fail an inference request.
+      try { Promise.resolve(onStatus({ ...context, event, ...fields })).catch(() => {}); } catch {}
+    };
+    const rejectRequest = (code, message) => {
+      status('request_error', { status: code });
+      return jsonError(res, code, message);
+    };
+    res.on('close', () => { if (!res.writableFinished) controller.abort(); });
+    req.on('aborted', () => controller.abort());
+    try {
+      if (req.headers.origin) return jsonError(res, 403, 'Browser requests are not supported');
+      if (!authorized(req, config)) return jsonError(res, 401, 'Invalid local router credential');
+      // Use a fixed upstream and an allowlist; never interpret a client URL as
+      // an upstream origin, or turn this into an open forwarding proxy.
+      const url = new URL(req.url, 'http://127.0.0.1');
+      if (req.method === 'GET' && url.pathname === '/health') {
+        res.writeHead(200, { 'content-type': 'application/json' });
+        return res.end(JSON.stringify({ status: 'ok' }));
+      }
+      if (req.method === 'HEAD' && url.pathname === '/api/hello') { res.writeHead(200); return res.end(); }
+      const inference = req.method === 'POST' && url.pathname === '/v1/messages';
+      const countTokens = req.method === 'POST' && url.pathname === '/v1/messages/count_tokens';
+      const models = req.method === 'GET' && /^\/v1\/models(?:\/[^/]+)?$/.test(url.pathname);
+      if (!inference && !countTokens && !models) return jsonError(res, 404, 'Unsupported endpoint');
+      if (inference) {
+        const hint = name => typeof req.headers[name] === 'string' ? req.headers[name] : undefined;
+        context = {
+          request_id: randomUUID(),
+          session_id: hint('x-claude-code-session-id'), agent_id: hint('x-claude-code-agent-id'),
+          prompt_id: hint('x-claude-code-prompt-id'), request_class: hint('x-claude-code-request-class'),
+        };
+        status('request_start');
+      }
+      if (config.authMode === 'subscription' && !isSubscriptionRequest(req.headers)) {
+        return rejectRequest(401, 'Subscription mode requires Claude Code OAuth authentication and its OAuth beta header, without an API key. Sign in with claude auth login and remove conflicting API-key, auth-token, custom-header, or apiKeyHelper settings.');
+      }
+      if (req.headers['content-encoding'] && req.headers['content-encoding'] !== 'identity') return rejectRequest(415, 'Compressed request bodies are not supported');
+      if (Number(req.headers['content-length']) > config.maxBodyBytes) return rejectRequest(413, 'Request body too large');
+      let body;
+      if (inference || countTokens) {
+        body = await readBody(req, config.maxBodyBytes);
+        let parsed;
+        try { parsed = JSON.parse(body); } catch { return rejectRequest(400, 'Invalid JSON body'); }
+        if (!parsed || typeof parsed.model !== 'string' || !Array.isArray(parsed.messages) || parsed.messages.some(m => !m || !['user', 'assistant', 'system'].includes(m.role) || !(typeof m.content === 'string' || (Array.isArray(m.content) && m.content.every(b => b && typeof b.type === 'string'))))) {
+          log({ event: 'invalid_request_shape', model_type: typeof parsed?.model, messages_type: Array.isArray(parsed?.messages) ? 'array' : typeof parsed?.messages,
+            messages: Array.isArray(parsed?.messages) ? parsed.messages.slice(0, 10).map(m => ({
+              role: ['user', 'assistant', 'system'].includes(m?.role) ? m.role : typeof m?.role,
+              content_type: Array.isArray(m?.content) ? 'array' : typeof m?.content,
+              blocks: Array.isArray(m?.content) ? m.content.slice(0, 10).map(b => ({ value_type: b === null ? 'null' : typeof b, type_type: typeof b?.type })) : undefined,
+            })) : undefined });
+          return rejectRequest(400, 'Expected a model and Messages API messages');
+        }
+        if (inference) {
+          const decision = await router.route(parsed, {
+            signal: controller.signal,
+            scope: JSON.stringify([req.headers['x-claude-code-session-id'], req.headers['x-claude-code-agent-id']]),
+            promptId: req.headers['x-claude-code-prompt-id'],
+            requestClass: req.headers['x-claude-code-request-class'],
+            countTokens: (body, model) => tokenCounter(body, model, {
+              headers: upstreamHeaders(req.headers, config), signal: controller.signal, search: url.search,
+            }),
+          });
+          if (controller.signal.aborted) { status('request_cancelled'); return; }
+          const prepared = prepareRequest(parsed, decision.model);
+          body = Buffer.from(JSON.stringify(prepared.request));
+          log({ event: 'route', requested_model: parsed.model, ...decision, request_adjustments: prepared.adjustments });
+          const { model, source, evaluator, reason, latency_ms, classifier_error, classifier_status, classified_tier, context_check, counted_input_tokens } = decision;
+          const pricingValue = (field, allowed, fallback) => prepared.request[field] === undefined ? fallback
+            : allowed.includes(prepared.request[field]) ? prepared.request[field] : 'unknown';
+          const pricing_context = {
+            speed: pricingValue('speed', ['standard', 'fast'], 'standard'),
+            inference_geo: pricingValue('inference_geo', ['global', 'us'], 'global'),
+            service_tier: pricingValue('service_tier', ['auto', 'standard_only'], 'auto'),
+          };
+          if (prepared.request.fallbacks != null || prepared.request.fallback_credit_token != null
+            || (Array.isArray(prepared.request.tools) && prepared.request.tools.some(tool => typeof tool?.type === 'string' && /^advisor(?:_|$)/.test(tool.type)))) pricing_context.pricing_unsupported = true;
+          status('route', { requested_model: parsed.model, model, source, evaluator, reason, latency_ms, classifier_error, classifier_status,
+            classified_tier, context_check, counted_input_tokens, pricing_context });
+        }
+      }
+      if (controller.signal.aborted) { status('request_cancelled'); return; }
+      const target = new URL(`${config.upstream}${url.pathname}${url.search}`);
+      await forward(target, req, res, body, config, AbortSignal.any([controller.signal, AbortSignal.timeout(config.upstreamTimeoutMs)]), log, status);
+      status('request_complete');
+    } catch (error) {
+      if (controller.signal.aborted) { status('request_cancelled'); return; }
+      // Error strings from providers can contain request data. Keep logs local
+      // and metadata-only, including on error paths.
+      log({ event: 'proxy_error', status: error.status ?? 502 });
+      rejectRequest(error.status ?? 502, error.status === 413 ? 'Request body too large' : 'Router could not complete the upstream request');
+    }
+  });
+  server.requestTimeout = 30000;
+  server.headersTimeout = 10000;
+  return server;
+}
+
+export function listen(server, port) {
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, '127.0.0.1', () => { server.removeListener('error', reject); resolve(server.address()); });
+  });
+}

package/src/status-settings.mjs

@@ -0,0 +1,88 @@
+import { readFileSync, statSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+
+// Claude executes statusLine.command through a shell, including when paths have
+// spaces, quotes, dollar signs, or backticks. Never interpolate them unquoted.
+export function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+export function statusLineSettings() {
+  const script = fileURLToPath(new URL('../bin/statusline.mjs', import.meta.url));
+  return { type: 'command', command: `${shellQuote(process.execPath)} ${shellQuote(script)}`, padding: 0, refreshInterval: 1 };
+}
+
+function rebasePermissionRules(settings, sourceDirectory) {
+  if (!settings.permissions || typeof settings.permissions !== 'object' || Array.isArray(settings.permissions)) return settings;
+  // Read/Edit /path patterns anchor at dirname(--settings file), or cwd for
+  // inline settings. Preserve that anchor when moving the settings to temp.
+  // Absolute permission patterns use //path, unlike ordinary filesystem paths.
+  // https://code.claude.com/docs/en/permissions#read-and-edit
+  let anchor = sourceDirectory;
+  if (process.platform === 'win32') anchor = anchor.replaceAll('\\', '/').replace(/^([a-z]):/i, (_, drive) => `/${drive.toLowerCase()}`);
+  anchor = anchor.replace(/\/$/, '').replace(/[\\*?\[\]]/g, '\\$&');
+  const permissions = { ...settings.permissions };
+  for (const kind of ['allow', 'ask', 'deny']) {
+    if (!Array.isArray(permissions[kind])) continue;
+    permissions[kind] = permissions[kind].map(rule => {
+      const match = typeof rule === 'string' && /^(Read|Edit)\((\/(?!\/)[\s\S]*)\)$/.exec(rule);
+      return match ? `${match[1]}(/${anchor}${match[2]})` : rule;
+    });
+  }
+  return { ...settings, permissions };
+}
+
+function checkSandboxPaths(settings) {
+  // Sandbox paths use conventional /absolute and ~/home syntax, not the
+  // Read/Edit // syntax. Documentation specifies source-dependent relative
+  // paths but does not define the --settings file/inline anchor explicitly.
+  // Keep original settings intact by declining the overlay for that case.
+  const paths = [];
+  for (const key of ['allowRead', 'allowWrite', 'denyRead', 'denyWrite']) {
+    const values = settings.sandbox?.filesystem?.[key];
+    if (Array.isArray(values)) paths.push(...values);
+  }
+  if (Array.isArray(settings.sandbox?.credentials?.files)) {
+    paths.push(...settings.sandbox.credentials.files.map(entry => entry?.path));
+  }
+  if (paths.some(path => typeof path === 'string' && !path.startsWith('/') && !path.startsWith('~/'))) {
+    throw new Error('Cannot safely relocate source-relative sandbox paths; keep the original Claude settings');
+  }
+}
+
+export function addStatusLineSettings(args, directory) {
+  const forwarded = [];
+  let supplied;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--') { forwarded.push(...args.slice(i)); break; }
+    if (args[i] === '--settings') {
+      supplied = args[++i];
+      if (!supplied || supplied.startsWith('--')) throw new Error('--settings requires a JSON object or settings file');
+    } else if (args[i].startsWith('--settings=')) supplied = args[i].slice('--settings='.length);
+    else forwarded.push(args[i]);
+  }
+  let settings = {};
+  let sourceDirectory = process.cwd();
+  if (supplied !== undefined) {
+    try {
+      let json = supplied;
+      if (!supplied.trimStart().startsWith('{')) {
+        const stat = statSync(supplied);
+        if (!stat.isFile() || stat.size > 2 * 1024 * 1024) throw new Error();
+        json = readFileSync(supplied, 'utf8');
+        sourceDirectory = dirname(resolve(supplied));
+      }
+      settings = JSON.parse(json);
+      if (!settings || typeof settings !== 'object' || Array.isArray(settings)) throw new Error();
+    } catch {
+      throw new Error('Could not read --settings as a JSON object; set AUTOROUTER_STATUSLINE=0 to pass it directly to Claude');
+    }
+  }
+  // Use a private temporary file instead of putting user settings (which may
+  // include sensitive env values) into process arguments. Saved files are intact.
+  checkSandboxPaths(settings);
+  const path = join(directory, 'claude-settings.json');
+  writeFileSync(path, JSON.stringify({ ...rebasePermissionRules(settings, sourceDirectory), statusLine: statusLineSettings() }), { mode: 0o600 });
+  return ['--settings', path, ...forwarded];
+}