synabun 2.0.5 → 2.0.9

package/neural-interface/lib/codex-accounts.js

@@ -0,0 +1,502 @@
+// ═══════════════════════════════════════════
+// SynaBun — Codex accounts (per-account CODEX_HOME)
+// ═══════════════════════════════════════════
+//
+// The Codex twin of lib/claude-accounts.js (docs/codex-sidepanel.md → Codex
+// accounts). Default is the ambient CODEX_HOME (or ~/.codex); every added
+// account owns ~/.codex-accounts/<id>, whose config.toml, prompts/ and
+// AGENTS.md link back to Default's so model, MCP and tool settings stay shared,
+// while auth.json, sessions/ and the state database stay its own.
+//
+// One account, two credentials, one mode. Each account can hold a ChatGPT
+// login (Codex's own, in its CODEX_HOME: auth.json or the keyring Codex is set
+// to use) and an OpenAI API key (SynaBun's `.synabun-api-key`, 0600, in the
+// same folder). Codex keeps one credential per CODEX_HOME — `codex login
+// --with-api-key` replaces a ChatGPT login and the reverse — so SynaBun never
+// writes the key into Codex's store: it hands it to the process that runs
+// under API-key mode, and the ChatGPT login next to it stays untouched.
+//   - `codex exec` (the SDK: workers, loops) reads CODEX_API_KEY, which wins
+//     over auth.json.
+//   - `codex app-server` (panel tabs, the Assistant's brain) ignores that
+//     variable: it starts with an ephemeral credential store and is signed in
+//     with `account/login/start {type:'apiKey'}` over its stdin.
+// describe() is the one reading of an account's state; launchFor() is the one
+// place a Codex process gets its credential. A key Codex itself holds (an older
+// `codex login --with-api-key`) is shown as the account's API key and used by
+// Codex as it is.
+
+import {
+  existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync,
+} from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
+import { homedir } from 'node:os';
+import { readProfileApiKey, saveProfileApiKey, clearProfileApiKey } from './claude-profile-api-key.js';
+import { apiKeyHint, resolveClaudeAuth } from './claude-accounts.js';
+import { normalizeAdminSandbox, sandboxElevationFor } from './agent-sandbox-elevation.js';
+
+export const CODEX_DEFAULT_ACCOUNT_ID = 'default';
+export const CODEX_AUTH_MODES = Object.freeze(['subscription', 'apiKey']);
+// Everything inherited from SynaBun's own environment that would decide which
+// OpenAI identity a Codex process uses: keys and tokens, and the organization /
+// project headers that belong to an inherited key. Removed from every account
+// launch: the account and its mode decide.
+export const CODEX_CREDENTIAL_ENV = Object.freeze([
+  'OPENAI_API_KEY', 'CODEX_API_KEY', 'CODEX_ACCESS_TOKEN',
+  'OPENAI_ORGANIZATION', 'OPENAI_PROJECT',
+  'OPENAI_IDENTITY_TOKEN_FILE', 'OPENAI_WORKLOAD_IDENTITY_CONTEXT', 'OPENAI_FEDERATION_RULE_ID',
+]);
+// An app-server that runs on a key SynaBun holds: nothing it is told is kept,
+// and the account's own auth.json (its ChatGPT login) is not read or replaced.
+export const CODEX_EPHEMERAL_STORE_ARGS = Object.freeze(['-c', 'cli_auth_credentials_store="ephemeral"']);
+const SHARED_FILES = ['config.toml', 'AGENTS.md'];
+const STATUS_MAX_AGE_MS = 5 * 60_000;
+
+export class CodexAccountError extends Error {
+  constructor(code, message, status = 400) {
+    super(message);
+    this.name = 'CodexAccountError';
+    this.code = code;
+    this.status = status;
+  }
+}
+
+/** 'chatgpt' is accepted for the subscription mode (what the UI calls it). */
+export function normalizeCodexMode(mode) {
+  if (mode === 'chatgpt') return 'subscription';
+  return CODEX_AUTH_MODES.includes(mode) ? mode : null;
+}
+
+function readJson(path, fallback = null) { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return fallback; } }
+function writeJsonAtomic(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n', 'utf8');
+  renameSync(tmp, path);
+}
+function sanitizeId(value) {
+  return String(value || '').trim().toLowerCase().replace(/[^a-z0-9-]/g, '').slice(0, 64);
+}
+function sanitizeLabel(value, fallback) {
+  const label = String(value || '').replace(/[\r\n\t]/g, ' ').trim().slice(0, 80);
+  return label || fallback;
+}
+const text = (value, max = 200) => (typeof value === 'string' && value.trim() ? value.trim().slice(0, max) : null);
+
+function jwtClaims(token) {
+  try {
+    const part = String(token || '').split('.')[1];
+    if (!part) return null;
+    return JSON.parse(Buffer.from(part.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8'));
+  } catch { return null; }
+}
+
+/**
+ * What Codex's own auth.json in a CODEX_HOME holds, without its secrets:
+ * { kind: 'chatgpt', email, plan } | { kind: 'apiKey', hint } | null (no file,
+ * or nothing usable in it). With a keyring store there is no file: null says
+ * nothing about a login then.
+ */
+export function readCodexAuthRecord(home) {
+  if (!home) return null;
+  let data;
+  try { data = JSON.parse(readFileSync(join(home, 'auth.json'), 'utf8')); } catch { return null; }
+  if (!data || typeof data !== 'object') return null;
+  const mode = String(data.auth_mode || '').toLowerCase();
+  const tokens = data.tokens && typeof data.tokens === 'object' ? data.tokens : null;
+  if (tokens && (tokens.id_token || tokens.access_token) && mode !== 'apikey') {
+    const claims = jwtClaims(tokens.id_token) || {};
+    const auth = claims['https://api.openai.com/auth'] || {};
+    return { kind: 'chatgpt', email: text(claims.email), plan: text(auth.chatgpt_plan_type, 40) };
+  }
+  if (typeof data.OPENAI_API_KEY === 'string' && data.OPENAI_API_KEY.trim()) {
+    return { kind: 'apiKey', hint: apiKeyHint(data.OPENAI_API_KEY.trim()) };
+  }
+  return null;
+}
+
+/** A launch's environment applied to a base: inherited credentials out, the account's in (no key). */
+export function applyCodexLaunchEnv(base, launch) {
+  const env = { ...(base || {}) };
+  for (const key of launch?.unset || CODEX_CREDENTIAL_ENV) delete env[key];
+  return Object.assign(env, launch?.env || {});
+}
+/** What `codex exec` (the SDK) gets on top: in API-key mode, the key SynaBun holds. Spawn-only. */
+export function codexExecEnv(launch) {
+  return { ...(launch?.env || {}), ...(launch?.apiKey ? { CODEX_API_KEY: launch.apiKey } : {}) };
+}
+/** The `-c` overrides every Codex process of the launch starts with: the Windows sandbox the Admin sandbox setting allows. */
+export function codexLaunchArgs(launch) {
+  return [...(launch?.configArgs || [])];
+}
+/** The `-c` overrides an app-server of the account starts with (before the subcommand). */
+export function codexAppServerArgs(launch) {
+  return [...codexLaunchArgs(launch), ...(launch?.apiKey ? CODEX_EPHEMERAL_STORE_ARGS : [])];
+}
+
+export function createCodexAccounts({
+  dataHome,
+  homeDir = homedir(),
+  env = process.env,
+  accountsRoot = null,
+  log = () => {},
+  now = Date.now,
+  // async (id) => the `account/read` answer of an app-server run under that
+  // account's own store ({ account: { type, email, planType } | null }), or null.
+  readNativeStatus = null,
+  statusTimeoutMs = 20_000,
+  // Called before a new account links Default's config.toml (server.js repairs it there).
+  prepareDefaultConfig = () => {},
+  // () => the Admin sandbox setting (lib/agent-sandbox-setting.js): which Windows sandbox every launch may use.
+  adminSandbox = () => false,
+} = {}) {
+  if (!dataHome) throw new Error('createCodexAccounts requires dataHome');
+  const registryPath = resolve(dataHome, 'data', 'codex-accounts.json');
+  const defaultHome = resolve(env.CODEX_HOME || resolve(homeDir, '.codex'));
+  const root = resolve(accountsRoot || resolve(homeDir, '.codex-accounts'));
+  const nativeStatus = new Map();
+  const refreshing = new Map();
+  const listeners = new Set();
+  let nativeReader = typeof readNativeStatus === 'function' ? readNativeStatus : null;
+
+  // The registry keeps Default's row in the list (older readers expect it), always at Default's home.
+  function load() {
+    const data = readJson(registryPath, null);
+    const rows = Array.isArray(data?.accounts) ? data.accounts.filter((row) => row && typeof row.id === 'string' && row.id) : [];
+    let defaults = rows.find((row) => row.id === CODEX_DEFAULT_ACCOUNT_ID);
+    const others = rows.filter((row) => row.id !== CODEX_DEFAULT_ACCOUNT_ID);
+    defaults = { email: '', planType: '', type: 'chatgpt', createdAt: null, ...(defaults || {}), id: CODEX_DEFAULT_ACCOUNT_ID, label: 'Default', home: defaultHome };
+    return { accounts: [defaults, ...others], defaultId: CODEX_DEFAULT_ACCOUNT_ID };
+  }
+  function save(data) {
+    writeJsonAtomic(registryPath, { accounts: data.accounts, defaultId: CODEX_DEFAULT_ACCOUNT_ID, updatedAt: new Date(now()).toISOString() });
+  }
+  function rowOf(data, id) { return data.accounts.find((row) => row.id === id) || null; }
+  function storedMode(data, id) { return normalizeCodexMode(rowOf(data, id)?.authMode); }
+
+  /** The registry row of an account (with its home), or null. Never a fallback to another account. */
+  function profileFor(id) {
+    const wanted = typeof id === 'string' && id ? id : CODEX_DEFAULT_ACCOUNT_ID;
+    return rowOf(load(), wanted);
+  }
+  function keyHome(id) {
+    const row = profileFor(id);
+    if (!row || row.id !== id) throw new CodexAccountError('ACCOUNT_NOT_FOUND', 'Unknown Codex account', 404);
+    return row.home;
+  }
+  function readApiKey(id) { return readProfileApiKey(keyHome(id), 'codex'); }
+  function keyState(id) {
+    try {
+      const key = readApiKey(id);
+      return key ? { present: true, hint: apiKeyHint(key), error: null, key } : { present: false, hint: null, error: null, key: null };
+    } catch (error) {
+      if (error?.code === 'ACCOUNT_NOT_FOUND') throw error;
+      return { present: false, hint: null, error: 'unreadable', key: null };
+    }
+  }
+  function authFile(home) { return join(home, 'auth.json'); }
+  function fileState(file) {
+    try { return { exists: true, mtimeMs: statSync(file).mtimeMs }; } catch { return { exists: false, mtimeMs: 0 }; }
+  }
+  // Codex's own credential in the account's home: its ChatGPT login (subscription) or a key it holds.
+  function nativeOf(id, home) {
+    const file = fileState(authFile(home));
+    const status = nativeStatus.get(id);
+    // Codex rewrites auth.json when it signs in or out: a file newer than the last check, or one that
+    // appeared or went away since, outranks that check until Codex is asked again.
+    const fresh = status && file.exists === status.fileExisted && !(file.exists && file.mtimeMs > status.wall);
+    if (fresh) {
+      return {
+        subscription: { signedIn: status.kind === 'chatgpt', email: status.email, plan: status.plan, checked: true, checkedAt: status.checkedAt },
+        nativeKey: { present: status.kind === 'apiKey', hint: status.kind === 'apiKey' ? (readCodexAuthRecord(home)?.hint || null) : null },
+      };
+    }
+    const record = readCodexAuthRecord(home);
+    const signedIn = record?.kind === 'chatgpt' ? true : record?.kind === 'apiKey' ? false : status?.kind === 'none' ? false : null;
+    return {
+      subscription: { signedIn, email: record?.kind === 'chatgpt' ? record.email : null, plan: record?.kind === 'chatgpt' ? record.plan : null, checked: false, checkedAt: status?.checkedAt || null },
+      nativeKey: { present: record?.kind === 'apiKey', hint: record?.kind === 'apiKey' ? record.hint : null },
+    };
+  }
+  function describeProfile(profile, data = load()) {
+    const id = profile.id;
+    const isDefault = id === CODEX_DEFAULT_ACCOUNT_ID;
+    const home = isDefault ? defaultHome : profile.home;
+    const key = keyState(id);
+    const native = nativeOf(id, home);
+    const preferredMode = storedMode(data, id);
+    const hasKey = key.present || native.nativeKey.present;
+    const auth = resolveClaudeAuth({ preferredMode, hasKey, subscription: native.subscription.signedIn });
+    const keySource = key.present ? 'synabun' : native.nativeKey.present ? 'codex' : null;
+    const keyHint = key.present ? key.hint : native.nativeKey.hint;
+    const sub = native.subscription;
+    const identity = auth.mode === 'apiKey' ? keyHint : auth.mode === 'subscription' ? (sub.email || null) : null;
+    const row = {
+      id, provider: 'codex',
+      label: isDefault ? 'Default' : sanitizeLabel(profile.label || profile.email, 'Codex account'), home,
+      isDefault, builtin: isDefault, createdAt: profile.createdAt || null,
+      mode: auth.mode, preferredMode, signedIn: auth.signedIn, switchable: auth.switchable, identity: identity || null,
+      subscription: { signedIn: sub.signedIn, email: sub.email, plan: sub.plan, checked: sub.checked, checkedAt: sub.checkedAt },
+      apiKey: { present: hasKey, hint: keyHint || null, error: key.error, source: keySource },
+      // The fields older readers use (Automation Studio, the launch selectors), from the same state.
+      loggedIn: auth.signedIn,
+      email: auth.mode === 'subscription' ? (sub.email || '') : '',
+      planType: auth.mode === 'subscription' ? (sub.plan || '') : '',
+      type: auth.mode === 'apiKey' ? 'apiKey' : 'chatgpt',
+      authMethod: auth.mode === 'apiKey' ? 'apiKey' : auth.mode === 'subscription' && sub.signedIn ? 'chatgpt' : null,
+    };
+    return { row, key: key.key };
+  }
+  function describe(id) {
+    const wanted = sanitizeId(id) || CODEX_DEFAULT_ACCOUNT_ID;
+    const data = load();
+    const profile = rowOf(data, wanted);
+    return profile ? describeProfile(profile, data).row : null;
+  }
+  function list() {
+    const data = load();
+    return data.accounts.map((profile) => describeProfile(profile, data).row);
+  }
+  function clientRow(row) {
+    const { home, ...rest } = row;
+    return rest;
+  }
+  function listForClient() { return list().map(clientRow); }
+  function describeForClient(id) { const row = describe(id); return row ? clientRow(row) : null; }
+  function homeFor(id) { return profileFor(sanitizeId(id) || CODEX_DEFAULT_ACCOUNT_ID)?.home || null; }
+
+  /**
+   * How a Codex process runs under an account: `unset` the inherited
+   * credential variables, set `env` (its CODEX_HOME), and in API-key mode with
+   * a key SynaBun holds, `apiKey` — for codexExecEnv() / codexAppServerArgs()
+   * and the app-server's stdin login. `apiKey` is a secret: spawn and stdin
+   * only, never a log, a response, an event or a file.
+   */
+  function launchFor(id) {
+    const wanted = typeof id === 'string' && id ? id : CODEX_DEFAULT_ACCOUNT_ID;
+    const data = load();
+    const profile = rowOf(data, wanted);
+    if (!profile || !profile.home) {
+      return { ok: false, accountId: wanted, code: 'account_unavailable', message: 'That Codex account is no longer set up in SynaBun.' };
+    }
+    const { row, key } = describeProfile(profile, data);
+    const apiKey = row.mode === 'apiKey' && row.apiKey.source === 'synabun' && key ? key : null;
+    // A launch override, never written into config.toml: Default's home is the user's own ~/.codex.
+    let on = false;
+    try { on = normalizeAdminSandbox(adminSandbox()); } catch { on = false; }
+    const sandbox = sandboxElevationFor('codex', on);
+    return {
+      ok: true, accountId: wanted, label: row.label, mode: row.mode, signedIn: row.signedIn, identity: row.identity, home: row.home,
+      env: { CODEX_HOME: row.home }, unset: [...CODEX_CREDENTIAL_ENV], apiKey,
+      // Which credential a process started with: a change means the account's idle processes restart.
+      credential: [row.mode || 'none', row.apiKey.source || '', row.apiKey.hint || '', row.subscription.email || ''].join(':'),
+      // The Windows sandbox it may use ('elevated' | 'unelevated'): a change restarts idle app-servers too.
+      windowsSandbox: sandbox.value, configArgs: sandbox.args,
+    };
+  }
+
+  /** Why an account cannot run now ('' when it can, or when that is not known yet). */
+  function unusableReason(id) {
+    const row = describe(id);
+    if (!row) return 'That Codex account is no longer set up in SynaBun.';
+    if (row.apiKey.error && row.mode !== 'subscription') return `The API key saved for ${row.label} cannot be read. Save it again.`;
+    if (row.signedIn === false) return `${row.label} is signed out. Sign in with ChatGPT or add an API key to it first.`;
+    return '';
+  }
+
+  function writeMode(id, mode, data = load()) {
+    const account = rowOf(data, id);
+    if (!account) throw new CodexAccountError('ACCOUNT_NOT_FOUND', `Codex account not found: ${id}`, 404);
+    if (mode) account.authMode = mode; else delete account.authMode;
+    save(data);
+  }
+  /** Choose what an account's sessions use. The chosen credential must be there. */
+  function setMode(id, value) {
+    const wanted = sanitizeId(id) || CODEX_DEFAULT_ACCOUNT_ID;
+    const mode = normalizeCodexMode(value);
+    if (!mode) throw new CodexAccountError('MODE_INVALID', 'Choose "subscription" (ChatGPT) or "apiKey".', 400);
+    const row = describe(wanted);
+    if (!row) throw new CodexAccountError('ACCOUNT_NOT_FOUND', `Codex account not found: ${id}`, 404);
+    if (mode === 'apiKey' && !row.apiKey.present) throw new CodexAccountError('MODE_NEEDS_CREDENTIAL', `Add an API key to ${row.label} first.`, 409);
+    if (mode === 'subscription' && row.subscription.signedIn === false) throw new CodexAccountError('MODE_NEEDS_CREDENTIAL', `Sign in to ${row.label} with ChatGPT first.`, 409);
+    writeMode(wanted, mode);
+    emit(wanted);
+    return describe(wanted);
+  }
+  function saveApiKey(id, key) {
+    saveProfileApiKey(keyHome(id), key, 'codex');
+    // A key just pasted is what the user wants this account to use.
+    writeMode(id, 'apiKey');
+    emit(id);
+  }
+  function clearApiKey(id) {
+    clearProfileApiKey(keyHome(id));
+    const data = load();
+    if (storedMode(data, id) === 'apiKey') writeMode(id, null, data);
+    emit(id);
+  }
+
+  /** Remember what Codex said about the account's own store (`account/read`). */
+  function noteNativeStatus(id, status) {
+    if (!status || typeof status !== 'object' || !Object.hasOwn(status, 'account')) return;
+    const account = status.account;
+    const kind = !account ? 'none' : account.type === 'chatgpt' ? 'chatgpt' : account.type === 'apiKey' ? 'apiKey' : null;
+    if (!kind) return; // A store Codex filled another way (Bedrock): the file reading stands.
+    const profile = profileFor(id);
+    if (!profile) return;
+    const file = fileState(authFile(profile.home));
+    nativeStatus.set(id, {
+      kind,
+      email: kind === 'chatgpt' ? text(account.email) : null,
+      plan: kind === 'chatgpt' ? text(account.planType, 40) : null,
+      checkedAt: now(),
+      wall: Date.now(),
+      fileExisted: file.exists,
+    });
+  }
+  function forgetNativeStatus(id) { nativeStatus.delete(id); }
+  function setNativeStatusReader(reader) { nativeReader = typeof reader === 'function' ? reader : null; }
+  function signature(row) { return row ? JSON.stringify([row.label, row.mode, row.signedIn, row.identity, row.subscription.signedIn, row.subscription.email, row.subscription.plan, row.apiKey.present, row.apiKey.hint, row.apiKey.source, row.preferredMode]) : ''; }
+  function checkOne(id) {
+    if (refreshing.has(id)) return refreshing.get(id);
+    const job = (async () => {
+      let timer;
+      try {
+        const status = await Promise.race([
+          Promise.resolve().then(() => nativeReader(id)),
+          new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('timeout')), statusTimeoutMs); timer.unref?.(); }),
+        ]);
+        if (status && profileFor(id)) noteNativeStatus(id, status);
+      } catch (error) {
+        log('codex-accounts', `status check failed for ${id}: ${String(error?.message || error).slice(0, 120)}`);
+      } finally { clearTimeout(timer); refreshing.delete(id); }
+    })();
+    refreshing.set(id, job);
+    return job;
+  }
+  function stale(id, maxAgeMs = STATUS_MAX_AGE_MS) {
+    const known = nativeStatus.get(id);
+    if (!known || now() - known.checkedAt >= maxAgeMs) return true;
+    const profile = profileFor(id);
+    if (!profile) return false;
+    const file = fileState(authFile(profile.home));
+    return file.exists !== known.fileExisted || (file.exists && file.mtimeMs > known.wall);
+  }
+  /** Ask Codex about these accounts' own stores (all by default); listeners hear about every change. */
+  async function refreshStatus(ids = null, { force = false, maxAgeMs = STATUS_MAX_AGE_MS } = {}) {
+    if (!nativeReader) return list();
+    const wanted = (Array.isArray(ids) ? ids : load().accounts.map((row) => row.id)).filter((id) => profileFor(id));
+    const before = new Map(wanted.map((id) => [id, signature(describe(id))]));
+    await Promise.all(wanted.map((id) => (!force && !stale(id, maxAgeMs) ? null : checkOne(id))));
+    for (const id of wanted) if (before.get(id) !== signature(describe(id))) emit(id);
+    return list();
+  }
+
+  function subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); }
+  function emit(accountId, extra = {}) {
+    for (const listener of [...listeners]) { try { listener({ accountId, ...extra }); } catch {} }
+  }
+
+  function linkShared(home) {
+    try { prepareDefaultConfig(); } catch (error) { log('codex-accounts', `config repair failed: ${error?.message || error}`); }
+    const linked = [];
+    const link = (name, kind) => {
+      const source = resolve(defaultHome, name);
+      const target = resolve(home, name);
+      try { lstatSync(target); return; } catch {}
+      try {
+        if (!existsSync(source)) {
+          // config.toml and prompts/ are made when missing (shared from the start); AGENTS.md is not ours to create.
+          if (name === 'AGENTS.md') return;
+          if (kind === 'dir') mkdirSync(source, { recursive: true }); else { mkdirSync(defaultHome, { recursive: true }); writeFileSync(source, '', 'utf8'); }
+        }
+        symlinkSync(source, target, kind === 'dir' ? (process.platform === 'win32' ? 'junction' : 'dir') : 'file');
+        linked.push(name);
+      } catch (error) { log('codex-accounts', `link ${name} failed: ${error?.message || error}`); }
+    };
+    for (const name of SHARED_FILES) link(name, 'file');
+    link('prompts', 'dir');
+    return linked;
+  }
+  function seedHome(id) {
+    const account = id && id !== CODEX_DEFAULT_ACCOUNT_ID ? profileFor(id) : null;
+    if (!account) throw new CodexAccountError('ACCOUNT_NOT_FOUND', `Codex account not found: ${id}`, 404);
+    mkdirSync(resolve(account.home, 'sessions'), { recursive: true });
+    return { home: account.home, linked: linkShared(account.home) };
+  }
+
+  function create({ label } = {}) {
+    const data = load();
+    const id = `acct-${now().toString(36)}${Math.floor(Math.random() * 1296).toString(36).padStart(2, '0')}`;
+    const account = {
+      id, label: sanitizeLabel(label, `Codex ${data.accounts.length + 1}`), email: '', planType: '', type: 'chatgpt',
+      home: resolve(root, id), createdAt: new Date(now()).toISOString(),
+    };
+    if (label && String(label).trim()) account.labelCustom = true;
+    data.accounts.push(account);
+    save(data);
+    const seeded = seedHome(id);
+    // A folder made a moment ago holds no login: nothing to ask Codex.
+    noteNativeStatus(id, { account: null });
+    emit(id, { created: true });
+    return { ...describe(id), seeded };
+  }
+  function rename(id, label) {
+    const wanted = sanitizeId(id);
+    if (wanted === CODEX_DEFAULT_ACCOUNT_ID) throw new CodexAccountError('DEFAULT_ACCOUNT', 'The default account cannot be renamed here', 409);
+    const data = load();
+    const account = rowOf(data, wanted);
+    if (!account) throw new CodexAccountError('ACCOUNT_NOT_FOUND', `Codex account not found: ${id}`, 404);
+    account.label = sanitizeLabel(label, account.label);
+    account.labelCustom = true;
+    save(data);
+    emit(wanted);
+    return describe(wanted);
+  }
+  function remove(id, { inUse = () => null } = {}) {
+    const wanted = sanitizeId(id);
+    if (wanted === CODEX_DEFAULT_ACCOUNT_ID) throw new CodexAccountError('DEFAULT_ACCOUNT', 'The default account cannot be removed', 409);
+    const data = load();
+    const index = data.accounts.findIndex((row) => row.id === wanted);
+    if (index === -1) throw new CodexAccountError('ACCOUNT_NOT_FOUND', `Codex account not found: ${id}`, 404);
+    const reason = inUse(wanted);
+    if (reason) throw new CodexAccountError('ACCOUNT_IN_USE', typeof reason === 'string' ? reason : `Codex account ${wanted} is in use`, 409);
+    const [account] = data.accounts.splice(index, 1);
+    save(data);
+    nativeStatus.delete(wanted);
+    const home = account.home ? resolve(account.home) : '';
+    // Only a folder SynaBun made for the account, under ~/.codex-accounts: never Default's home.
+    if (home && home !== defaultHome && home.startsWith(`${root}${sep}`)) {
+      try { rmSync(home, { recursive: true, force: true }); } catch (error) { log('codex-accounts', `remove home failed: ${error?.message || error}`); }
+    }
+    emit(wanted, { removed: true });
+    return { ok: true, removed: account.id };
+  }
+  /** A ChatGPT sign-in just finished: it is what the account uses from now on, and names a still unnamed account. */
+  function noteSubscriptionSignIn(id, status = null) {
+    const wanted = sanitizeId(id) || CODEX_DEFAULT_ACCOUNT_ID;
+    if (!profileFor(wanted)) return null;
+    if (status) noteNativeStatus(wanted, status);
+    const data = load();
+    const account = rowOf(data, wanted);
+    const row = describe(wanted);
+    if (account && wanted !== CODEX_DEFAULT_ACCOUNT_ID && row?.subscription.email) {
+      account.email = row.subscription.email;
+      account.planType = row.subscription.plan || '';
+      if (!account.labelCustom && /^(Codex \d+|New account)$/.test(account.label || '')) account.label = row.subscription.email;
+    }
+    if (account) account.authMode = 'subscription';
+    save(data);
+    emit(wanted);
+    return describe(wanted);
+  }
+
+  return {
+    registryPath, defaultHome, root,
+    list, listForClient, describe, describeForClient, profileFor, homeFor, readApiKey, saveApiKey, clearApiKey,
+    // The registry rows (id, label, home, …) for readers that only need where an account lives.
+    registryRows: () => load().accounts,
+    get: describe, find: describe,
+    launchFor, unusableReason, setMode, noteNativeStatus, forgetNativeStatus, noteSubscriptionSignIn, setNativeStatusReader,
+    refreshStatus, stale, subscribe, create, rename, remove, seedHome,
+  };
+}

package/neural-interface/lib/codex-capabilities.js

@@ -138,7 +138,8 @@ export function validateCodexConfigRequirements(config, result) {
     throw error;
   }
   for (const [name, required] of Object.entries(requirements.featureRequirements || {})) {
-    if (config.features?.[name] !== undefined && config.features[name] !== required) {
+    const value = config.features?.[name] ?? config[`features.${name}`];
+    if (value !== undefined && value !== required) {
       const error = new Error(`Feature ${name} is restricted by managed requirements.`);
       error.code = 'MANAGED_REQUIREMENT';
       throw error;

package/neural-interface/lib/codex-compat-rpc.js

@@ -108,7 +108,7 @@ export async function listCodexPages(request, method, params = {}, key = 'data')
   throw new Error(`${method} exceeded the catalog pagination limit.`);
 }
 
-export function buildCodexCompatParams(message, { activeThreadId, cwd } = {}) {
+export function buildCodexCompatParams(message, { activeThreadId, cwd, sandboxPolicyForMode } = {}) {
   const threadId = owns(message, 'threadId') ? message.threadId : (activeThreadId || null);
   const params = threadActions.has(message.type) ? { threadId: required(threadId, 'Thread') } : {};
   switch (message.type) {
@@ -183,6 +183,10 @@ export function buildCodexCompatParams(message, { activeThreadId, cwd } = {}) {
           && Object.values(message.tags).every(value => typeof value === 'string') ? { tags: message.tags } : {}),
       };
     case 'thread_settings_update':
+      if (owns(message, 'sandboxMode')) {
+        if (!sandboxPolicyForMode) invalid('Sandbox settings are unavailable.');
+        params.sandboxPolicy = message.sandboxMode === null ? null : sandboxPolicyForMode(message.sandboxMode, message.cwd || cwd);
+      }
       if (owns(message, 'disabledPluginIds')) {
         if (!Array.isArray(message.disabledPluginIds) || message.disabledPluginIds.some(id => typeof id !== 'string' || !id.trim())) invalid('Disabled plugins must be a list of plugin ids.');
         params.disabledPluginIds = [...new Set(message.disabledPluginIds)];
@@ -223,7 +227,9 @@ export async function handleCodexCompatMessage(message, context) {
     }
     if (message.type === 'thread_settings_update' && context.activeTurnId) invalid('Wait for the current turn before changing session settings.');
     await context.beforeRequest?.(message.type, params);
-    const run = () => context.request(route[0], params, /^verification_(enroll|delete|verify)$/.test(message.type) ? 120000 : message.type === 'feedback_upload' ? 30000 : 10000);
+    const run = () => message.type === 'experimental_features_set' && context.setFeatureEnablement
+      ? context.setFeatureEnablement(params.enablement)
+      : context.request(route[0], params, /^verification_(enroll|delete|verify)$/.test(message.type) ? 120000 : message.type === 'feedback_upload' ? 30000 : 10000);
     const result = mutations.has(message.type) ? await context.withWriterOperation(message.type, run) : await run();
     if (message.type === 'mcp_app_resource_read') {
       validateAppResources(result);

package/neural-interface/lib/codex-mcp-approvals.js

@@ -18,7 +18,11 @@ export function buildCodexConfigEdits(config, prefix = []) {
   const edits = [];
   for (const [key, value] of Object.entries(config)) {
     if (value === undefined) continue;
-    const path = [...prefix, key];
+    // Settings uses dotted feature paths. Quoting the entire path creates an
+    // ignored top-level literal key ("features.apps"), rather than [features].
+    // Keep quoting nested MCP server identities such as "team.docs".
+    const path = !prefix.length && /^features\.[A-Za-z0-9_-]+$/.test(key)
+      ? key.split('.') : [...prefix, key];
     if (value && typeof value === 'object' && !Array.isArray(value)) {
       edits.push(...buildCodexConfigEdits(value, path));
       continue;

package/neural-interface/lib/codex-panel-auth.js

@@ -0,0 +1,62 @@
+// Managed ChatGPT auth stays inside the existing account-scoped app-server. An API key never goes
+// through here: Codex keeps one credential per CODEX_HOME, so a native API-key login would replace the
+// account's ChatGPT sign-in. SynaBun keeps the key per account instead (lib/codex-accounts.js).
+export function createCodexPanelAuth({ request, accountId, onChange = () => {}, onSuccess = async () => {}, timeoutMs = 10 * 60_000 }) {
+  let state = { status: 'idle' }, generation = 0, timer, early = [];
+  const snapshot = () => state.accountId && state.accountId !== accountId() ? { status: 'idle', accountId: accountId() } : ({ ...state, accountId: state.accountId || accountId() });
+  const update = patch => { state = { ...state, ...patch }; onChange(snapshot()); return snapshot(); };
+  const active = () => ['starting', 'pending'].includes(state.status);
+  async function complete(params) {
+    if (state.status === 'starting') { early.push(params); return; }
+    if (state.status !== 'pending' || !params.loginId || params.loginId !== state.loginId || state.accountId !== accountId()) return;
+    const epoch = generation;
+    clearTimeout(timer);
+    update({ status: params.success ? 'success' : 'error', authUrl: '', verificationUrl: '', userCode: '', error: params.success ? '' : (params.error || 'Codex sign-in failed. Try again.') });
+    if (params.success) {
+      try { await onSuccess(state.accountId); }
+      catch { if (epoch === generation) update({ error: 'Signed in, but account details could not refresh. Use Refresh.' }); }
+    }
+  }
+  async function start(loginType = 'chatgpt') {
+    if (!['chatgpt', 'chatgptDeviceCode'].includes(loginType)) throw new Error('Unsupported managed login type');
+    if (active()) return snapshot();
+    const epoch = ++generation;
+    early = [];
+    update({ status: 'starting', accountId: accountId(), loginId: null, authUrl: '', verificationUrl: '', userCode: '', error: '' });
+    try {
+      const login = await request('account/login/start', { type: loginType }, 15000);
+      if (epoch !== generation) {
+        if (login?.loginId) await request('account/login/cancel', { loginId: login.loginId }, 10000);
+        return snapshot();
+      }
+      if (!login?.loginId) throw new Error('Codex did not return a managed sign-in attempt. Update Codex and retry.');
+      update({ status: 'pending', loginId: login.loginId, authUrl: login.authUrl || '', verificationUrl: login.verificationUrl || '', userCode: login.userCode || '' });
+      timer = setTimeout(() => {
+        const timedGeneration = generation;
+        void cancel().then(() => {
+          if (generation === timedGeneration + 1 && state.status === 'cancelled') update({ status: 'error', error: 'Codex sign-in timed out. Try again.' });
+        }).catch(() => {});
+      }, timeoutMs); timer.unref?.();
+      for (const params of early) await complete(params);
+      early = [];
+    } catch (error) { if (epoch === generation) update({ status: 'error', error: error.message }); }
+    return snapshot();
+  }
+  async function cancel() {
+    if (!active()) return snapshot();
+    const loginId = state.loginId;
+    const epoch = ++generation; clearTimeout(timer);
+    update({ status: 'cancelled', authUrl: '', verificationUrl: '', userCode: '', error: '' });
+    if (loginId) {
+      try { await request('account/login/cancel', { loginId }, 10000); }
+      catch (error) { if (epoch === generation) update({ status: 'error', error: `Could not cancel Codex sign-in: ${error.message}` }); throw error; }
+    }
+    return snapshot();
+  }
+  function interrupted() {
+    ++generation; clearTimeout(timer);
+    if (active()) update({ status: 'error', authUrl: '', verificationUrl: '', userCode: '', error: 'Codex disconnected during sign-in. Reconnect and retry.' });
+  }
+  function reset() { ++generation; clearTimeout(timer); state = { status: 'idle', accountId: accountId() }; return update({}); }
+  return { start, cancel, complete, snapshot, active, interrupted, reset };
+}

package/neural-interface/lib/codex-session-settings.js

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileS
 import { dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 
-export const CODEX_SESSION_SETTING_KEYS = Object.freeze(['model', 'effort', 'summary', 'personality', 'serviceTier', 'approvalPolicy', 'approvalsReviewer', 'disabledPluginIds']);
+export const CODEX_SESSION_SETTING_KEYS = Object.freeze(['model', 'effort', 'summary', 'personality', 'serviceTier', 'approvalPolicy', 'sandboxPolicy', 'approvalsReviewer', 'disabledPluginIds']);
 const own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
 
 /** Session choices are scoped to account/thread and never written to config.toml. */