synabun 2.0.0 → 2.0.7

package/neural-interface/lib/claude-agent-bridge.js

@@ -1,3 +1,5 @@
+import { redactProviderSecrets } from './provider-panel-api-key-auth.js';
+import { applyClaudeLaunchEnv, CLAUDE_CREDENTIAL_ENV } from './claude-accounts.js';
 import { claudeStallSeconds } from './claude-stall-policy.js';
 import { detectProject as memoryProject } from '../../mcp-server/dist/config.js';
 // ── Claude Agent SDK bridge for the Claude sidepanel (claude-skin) ──
@@ -30,7 +32,7 @@ import { CLAUDE_NOT_INSTALLED, resolveClaudeSdkExecutable } from './claude-execu
 import { diagnoseLaunchFailure, isNativeBinaryLaunchFailure } from './native-binary-runtime.js';
 import { normalizePanelSession, startSignature, applyPanelSessionOptions, liveSettingsPatch, normalizeMcpServers, mergeTabMcpServers } from './claude-panel-session.js';
 import { SESSION_REQUESTS, runSessionRequest, slimRewind, slimMcpStatus } from './claude-panel-requests.js';
-import { applyTemporaryOptions, plansDirsOf, planFileOfToolCall, removeTemporaryPlanFiles } from './claude-temporary.js';
+import { applyTemporaryOptions, plansDirsOf, snapshotPlanFiles, planFileOfToolCall, removeTemporaryPlanFiles } from './claude-temporary.js';
 import { rootBypassBlock } from './claude-bypass-policy.js';
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
@@ -107,6 +109,7 @@ export const PANEL_CAPABILITIES = Object.freeze([
   'message_flags',    // session.hookEvents / promptSuggestions / subagentText / agentSummaries → the matching SDK options
   'task_control',     // inbound `stop_task` / `background_tasks` → `task_control_result`; system/session_crons events
   'origin_human',     // a query marked `typed: true` is sent with origin {kind:'human'}
+  'greeting',         // query `greetingId`: the model is told once what SynaBun greeted the user with (lib/greeting/)
   'session_requests', // inbound `session_request {id, what, args}` → `session_response`: context_usage, usage, mcp_status, mcp_reconnect, mcp_toggle, rewind_preview
   'rewind_stats',     // `rewind_result` carries filesChanged / insertions / deletions
   'session_title',    // query `title` names a new session where the CLI reads it
@@ -222,11 +225,11 @@ const _allSessions = new Set();
 
 function _orphanKey(wid, sid) { return sid ? `${wid}:${sid}` : wid; }
 
-function log(...args) { console.log('[claude-sdk]', ...args); }
+function log(...args) { console.log('[claude-sdk]', ...args.map(redactProviderSecrets)); }
 
 // Panel sessions, a temporary chat (lib/claude-temporary.js): the plan files
 // Claude Code wrote for one that still have to be removed. path → { plansDirs,
-// since, ended, last }. One is removed once the pump of the process that wrote
+// since, before, ended, last }. One is removed once the pump of the process that wrote
 // it has settled (`ended`), and stays owed after that removal, whether it
 // removed the file or found none: the pump settles when the SDK's own cleanup
 // stops waiting for the process, which can be before the process is gone, and
@@ -414,6 +417,7 @@ export class ClaudeSession {
   // ── wire helpers ──────────────────────────────────────────────────────────
 
   send(data) {
+    data = redactProviderSecrets(data);
     if (this.destroyed) return;
     if (this.orphanBuffer) {
       // High-volume deltas are not buffered while detached — full assistant
@@ -450,6 +454,7 @@ export class ClaudeSession {
   // without a prompt: the first real ensureQuery() adopts it if the session's
   // configuration is still the one it was started with.
   ensureQuery({ warm = false } = {}) {
+    if (this._authChanging) { this._startRefused = { code: 'auth_changing', message: 'Sign-in is changing. Try again.' }; return null; }
     if (this.q) return this.q;
     // Panel sessions under a named Claude account: every process start checks
     // the account again (a message, a recreation after a stall, a lost-session
@@ -479,6 +484,16 @@ export class ClaudeSession {
       return null;
     }
     let accountEnv = null;
+    if (!this.panel && typeof this.opts.claudeAccountId === 'string' && this.opts.claudeAccountId && this.opts.claudeAccountId !== 'default'
+      && typeof deps.claudeAccountLaunch === 'function') {
+      let launch = null;
+      try { launch = deps.claudeAccountLaunch(this.opts.claudeAccountId); } catch { launch = null; }
+      if (!launch?.ok) {
+        this._startRefused = { code: 'account_unavailable', message: ACCOUNT_UNAVAILABLE };
+        log(`session create refused: the account "${this.opts.claudeAccountId}" is no longer set up`);
+        return null;
+      }
+    }
     if (this.panel && this.accountId) {
       accountEnv = this._accountEnvOf(this.accountId);
       if (!accountEnv) {
@@ -602,14 +617,30 @@ export class ClaudeSession {
       // `typesafe:'off'` on a query (the live skin test) keeps this CLI's hooks
       // from paying for judgments: they read the kill switch from their env.
       // (Panel sessions: the CLI reports running / idle / requires_action only when
-      // asked to; `idle` is its own word that a turn is over. See _noteSessionState.)
-      env: { ...cleanEnv(), ...(this.typesafeOff ? { SYNABUN_TYPESAFE: 'off' } : {}), ...(sessionOpts.env || {}), ...(accountEnv || {}), ...(this.panel ? { CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS: '1' } : {}) },
+      // asked to; `idle` is its own word that a turn is over. See _noteSessionState.
+      // SYNABUN_PANEL_SESSION tells the user-level SynaBun hooks that the panel greets here, not they.)
+      env: { ...cleanEnv(), ...(this.typesafeOff ? { SYNABUN_TYPESAFE: 'off' } : {}), ...(sessionOpts.env || {}), ...(accountEnv || {}), ...(this.panel ? { CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS: '1', SYNABUN_PANEL_SESSION: '1' } : {}) },
       abortController: this.abortController,
       stderr: (text) => {
         const t = String(text || '').trim();
-        if (t) this.send({ type: 'stderr', text: t });
+        // Raw diagnostic chunks can split a credential. API-key sessions use
+        // the SDK's structured errors instead of forwarding raw stderr.
+        if (t && !this._usesProfileApiKey) this.send({ type: 'stderr', text: t });
       },
     };
+    // The account decides the credential (lib/claude-accounts.js launchFor()):
+    // every inherited credential variable is removed, then the account's own
+    // config directory and, in API-key mode, its key are added. Subscription
+    // mode adds no key, so Claude Code uses the login in that directory. No
+    // other account's key, and nothing SynaBun was started with, reaches it.
+    const launch = this._launchFor(accountEnv);
+    this._usesProfileApiKey = !!launch?.env?.ANTHROPIC_API_KEY;
+    this._credentialMode = launch?.mode || null; // what the process was given: 'subscription' | 'apiKey'
+    if (launch) options.env = applyClaudeLaunchEnv(options.env, launch);
+    // On Windows, the Git Bash the host names for this process (lib/git-bash/: SynaBun's own copy on a PC without
+    // one); without it Claude Code has no Bash tool and runs the hooks in PowerShell. Panel tabs and the brain.
+    if (typeof deps?.childEnv === 'function') options.env = deps.childEnv(options.env);
+
     if (Array.isArray(sessionOpts.disallowedTools) && sessionOpts.disallowedTools.length) options.disallowedTools = [...sessionOpts.disallowedTools];
     if (this.panel) {
       // The process is launched able to take Bypass, so the tab's mode control
@@ -643,6 +674,16 @@ export class ClaudeSession {
       // Resuming a session whose prompt cache has expired pays to write it
       // again: the CLI says how much at SessionStart.
       options.hooks = mergeHookMatchers(options.hooks, {
+        // The greeting SynaBun showed when this conversation opened (lib/greeting/): said to the
+        // model once, with the first prompt, as background. The model is never asked to greet.
+        UserPromptSubmit: [{
+          hooks: [async () => {
+            const note = gen === this._queryGen ? this._greetingNote : '';
+            if (!note) return {};
+            this._greetingNote = '';
+            return { hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: note } };
+          }],
+        }],
         SessionStart: [{
           hooks: [async (input) => {
             if (gen === this._queryGen && input?.prompt_cache_likely_expired === true && Number(input?.estimated_cache_write_usd) > 0) {
@@ -744,7 +785,10 @@ export class ClaudeSession {
       // (Which of the session's MCP connections is SynaBun's is asked of the live process when a tool of one is called.)
       applyTemporaryOptions(options, { mcpUrl: deps.mcpUrl || '', mcpStatus: () => this.q?.mcpServerStatus?.() });
       this._tempPlansDirs = plansDirsOf(options.env, { cwd: workDir, settings: options.settings });
-      if (!this._tempSince) this._tempSince = Date.now();
+      if (!this._tempSince) {
+        this._tempPlansBefore = snapshotPlanFiles(this._tempPlansDirs);
+        this._tempSince = Date.now();
+      }
     }
     // The executable resolved at the top of this call. The SDK uses
     // pathToClaudeCodeExecutable verbatim with zero validation, so it was vetted
@@ -905,6 +949,29 @@ export class ClaudeSession {
     return env;
   }
 
+  // The launch of the account this session runs under (the host's
+  // claudeAccountLaunch(), lib/claude-accounts.js launchFor()), or null when
+  // the session names none: panel sessions always do ('' = the default
+  // account); any other session only when it was given `claudeAccountId` (the
+  // Assistant's brain). A host without claudeAccountLaunch gets what it had:
+  // the named account's directory and the profile key, nothing stripped for
+  // a default account without a key.
+  _launchFor(accountEnv) {
+    const named = this.panel ? (this.accountId || 'default') : (typeof this.opts.claudeAccountId === 'string' && this.opts.claudeAccountId ? this.opts.claudeAccountId : null);
+    if (!named) return null;
+    if (typeof deps.claudeAccountLaunch === 'function') {
+      let launch = null;
+      try { launch = deps.claudeAccountLaunch(named); } catch { launch = null; }
+      if (launch?.ok) return launch;
+      return null;
+    }
+    if (!this.panel) return null;
+    let key = null;
+    try { key = deps.claudeAccountApiKey?.(named) || null; } catch { key = null; }
+    if (!accountEnv && !key) return null;
+    return { ok: true, accountId: named, mode: key ? 'apiKey' : 'subscription', env: { ...(accountEnv || {}), ...(key ? { ANTHROPIC_API_KEY: key } : {}) }, unset: [...CLAUDE_CREDENTIAL_ENV] };
+  }
+
   // A start ensureQuery() refused (see there): tell the tab why and close the
   // turn it is waiting on. False when the last start was not refused.
   _announceRefusedStart() {
@@ -1079,7 +1146,7 @@ export class ClaudeSession {
   // stay owed and are swept once more when it can no longer be alive.
   _removeTemporaryPlans() {
     if (!this._tempPlans?.size) return;
-    const owed = { plansDirs: this._tempPlansDirs, since: this._tempSince, ended: false, last: false };
+    const owed = { plansDirs: this._tempPlansDirs, since: this._tempSince, before: this._tempPlansBefore, ended: false, last: false };
     for (const path of this._tempPlans) _temporaryPlansOwed.set(path, owed);
     this._tempPlans.clear();
     Promise.resolve(this.pumpPromise).catch(() => {}).then(() => {
@@ -1098,6 +1165,7 @@ export class ClaudeSession {
     this._tempLive = false;
     this._tempOver = false;
     this._tempSince = 0;
+    this._tempPlansBefore = null;
   }
 
   // Whether this message makes, keeps or may not make the conversation a
@@ -1367,6 +1435,11 @@ export class ClaudeSession {
         }
         return;
       }
+      case 'rate_limit_event': {
+        try { deps?.accountRateLimit?.(this.panel ? this.accountId || 'default' : this.opts.claudeAccountId || 'default', m.rate_limit_info); } catch {}
+        this.sendEvent(m);
+        return;
+      }
       case 'result': {
         this._flushDeltas();
         this._handleResult(m);
@@ -1629,7 +1702,7 @@ export class ClaudeSession {
           this.sendEvent({
             type: 'system', subtype: 'session_info',
             info: {
-              account: r.account || null,
+              account: this._usesProfileApiKey ? { authMethod: 'apiKey' } : r.account || null,
               outputStyle: r.output_style || '',
               availableOutputStyles: Array.isArray(r.available_output_styles) ? r.available_output_styles : [],
               models: Array.isArray(r.models) ? r.models : [],
@@ -2811,6 +2884,17 @@ export class ClaudeSession {
       } catch {}
     }
 
+    // The panel echoes the id of the greeting it showed when this conversation opened: the model is
+    // told once, with this prompt (the UserPromptSubmit hook in _startQuery). A slash command takes none.
+    // (A prompt the person typed in the panel is also them being here, whether or not the user-level hooks are installed.)
+    if (this.panel && !warmOnly && msg.typed === true && typeof prompt === 'string' && prompt.trim() && typeof deps.greetingActivity === 'function') {
+      try { deps.greetingActivity({ cwd: cwd || this.cwd || null, words: prompt, temporary: this.temporary === true }); } catch { /* the prompt goes on */ }
+    }
+    if (this.panel && !warmOnly && typeof msg.greetingId === 'string' && typeof deps.greetingNote === 'function') {
+      try { this._greetingNote = String(deps.greetingNote(msg.greetingId, { skip: typeof prompt === 'string' && prompt.trimStart().startsWith('/') }) || ''); }
+      catch { this._greetingNote = ''; }
+    }
+
     // SynaBun skill injection runs FIRST; unrecognized /commands pass through to the CLI
     if (prompt && prompt.startsWith('/')) {
       try {
@@ -3101,6 +3185,28 @@ export class ClaudeSession {
   }
 }
 
+// Credentials are fixed in the CLI environment. Retire only this account's
+// idle panel processes before changing its key; hold starts until storage/logout
+// finishes. Other accounts and non-panel SDK callers are unaffected.
+// (The Assistant's brain names its account with `claudeAccountId`: retired the same way.)
+const sessionAccountOf = (s) => (s.panel ? (s.accountId || 'default') : (typeof s.opts?.claudeAccountId === 'string' && s.opts.claudeAccountId ? s.opts.claudeAccountId : null));
+export async function withPanelAccountAuthChange(accountId, change) {
+  const sessions = [..._allSessions].filter(s => !s.destroyed && sessionAccountOf(s) === accountId);
+  if (sessions.some(s => s.inTurn || s.pendingTurns || s.pendingPerms.size || s._hasPendingWork() || s._authChanging)) {
+    throw Object.assign(new Error('Finish or stop this account’s work before changing sign-in.'), { status: 409 });
+  }
+  for (const session of sessions) session._authChanging = true;
+  try {
+    await Promise.all(sessions.map(session => session._endQuery({ graceful: false })));
+    return await change();
+  } finally { for (const session of sessions) session._authChanging = false; }
+}
+
+/** Whether a live session (a panel tab's, the Assistant brain's) runs under this account. */
+export function accountInUse(accountId) {
+  return [..._allSessions].some(s => !s.destroyed && sessionAccountOf(s) === accountId);
+}
+
 // ── connection layer ─────────────────────────────────────────────────────────
 
 export function createClaudeBridge(ws) {
@@ -3189,6 +3295,14 @@ export function isSessionLive(sessionId) {
   return [..._allSessions].some(s => !s.destroyed && s.sessionId === sessionId && !!s.q);
 }
 
+// How many side-panel sessions are working (a turn, a question, background tasks
+// or crons, a sign-in change): the desktop app waits for them before it restarts
+// into an update (GET /api/system/activity). The Assistant's brain counts there itself.
+export function panelSessionsWorking() {
+  return [..._allSessions].filter(s => s.panel && !s.destroyed
+    && (s.inTurn || s.pendingTurns || s.pendingPerms.size || s._hasPendingWork() || s._authChanging)).length;
+}
+
 export function shutdownAllBridges() {
   for (const session of [..._allSessions]) {
     try { session.destroy(); } catch {}

package/neural-interface/lib/claude-executable.js

@@ -10,7 +10,12 @@
 //
 //   resolveClaudeLauncher        what a terminal or a shell would start: the
 //                                user's configured command, else the first
-//                                `claude` on PATH that is not inside SynaBun
+//                                `claude` on PATH that is not inside SynaBun.
+//                                server.js asks lib/cli-resolver.js instead
+//                                (Settings, PATH and the OS PATH, the known
+//                                install folders, a --version that answers),
+//                                which follows a Windows `claude.cmd` with
+//                                windowsClaudeTargets below
 //   resolveClaudeSdkExecutable   what the SDK can start. It spawns with
 //                                shell:false, so an npm command file on Windows
 //                                is followed to the executable behind it

package/neural-interface/lib/claude-model-catalog.js

@@ -14,7 +14,7 @@ import { spawn } from 'node:child_process';
 import { dirname, join, sep } from 'node:path';
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { getAugmentedPath } from './augmented-path.js';
+import { withPathEnv, getAugmentedPath } from './augmented-path.js';
 
 // Effort ladder the Claude Code CLI accepts for --effort. Models advertise their
 // own subset via supportedEffortLevels; this is the superset used as a fallback
@@ -45,6 +45,32 @@ const CACHE_TTL_MS = 10 * 60 * 1000;
 let _cache = { at: 0, key: '', models: [] };
 let _inflight = null;
 
+// Who else keeps a copy of this list (the Assistant's model catalog). Told when a
+// discovery returns a list that differs from the one before it, so a copy is
+// dropped the moment the picker's own source changes: after a CLI update, or
+// when the account's models change. The first discovery after a start counts.
+const _changeListeners = new Set();
+
+export function onClaudeModelsChanged(listener) {
+  if (typeof listener !== 'function') return () => {};
+  _changeListeners.add(listener);
+  return () => { _changeListeners.delete(listener); };
+}
+
+// What makes two lists the same list for a picker: ids in order, the model each
+// runs as, the label, the context window and the effort levels.
+export function claudeModelsSignature(models) {
+  return JSON.stringify((Array.isArray(models) ? models : []).map(m => [
+    m?.id || '', m?.resolvedModel || '', m?.label || '', m?.contextWindow || 0, (m?.effortLevels || []).join(','),
+  ]));
+}
+
+function notifyModelsChanged(models) {
+  for (const listener of [..._changeListeners]) {
+    try { listener(models); } catch {}
+  }
+}
+
 // What a cache keyed on "the CLI" has to key on. An update never changes the
 // configured path: the native installer and Homebrew re-point a symlink at a new
 // version directory, and npm rewrites the entrypoint in place. The resolved target
@@ -214,7 +240,7 @@ export function queryClaudeCliModels(claudeBin, { cwd, timeoutMs = DISCOVERY_TIM
     try {
       child = spawnImpl(shellCommand(bin, useShell), args, {
         cwd: cwd || process.cwd(),
-        env: { ...process.env, PATH: getAugmentedPath(), CLAUDE_CODE_ENTRYPOINT: 'sdk-cli' },
+        env: { ...withPathEnv(process.env, getAugmentedPath()), CLAUDE_CODE_ENTRYPOINT: 'sdk-cli' },
         stdio: ['pipe', 'pipe', 'ignore'],
         shell: useShell,
       });
@@ -262,7 +288,7 @@ export function queryClaudeCliModels(claudeBin, { cwd, timeoutMs = DISCOVERY_TIM
 // Cached discovery. `source` lets the UI distinguish a verified list from the
 // baked-in fallback. Cache is keyed on the binary's identity, so switching the
 // configured CLI (Settings > Terminal) or updating it re-discovers.
-export async function discoverClaudeModels(claudeBin, { force = false, cwd } = {}) {
+export async function discoverClaudeModels(claudeBin, { force = false, cwd, query = queryClaudeCliModels } = {}) {
   const bin = String(claudeBin || '');
   const key = binaryIdentity(bin);
   const fresh = _cache.models.length
@@ -273,10 +299,12 @@ export async function discoverClaudeModels(claudeBin, { force = false, cwd } = {
 
   _inflight = (async () => {
     try {
-      const raw = await queryClaudeCliModels(bin, { cwd });
+      const raw = await query(bin, { cwd });
       const models = normalizeClaudeModels(raw);
       if (models.length) {
+        const changed = claudeModelsSignature(models) !== claudeModelsSignature(_cache.models);
         _cache = { at: Date.now(), key, models };
+        if (changed) notifyModelsChanged(models);
         return { source: 'cli', models };
       }
       return { source: 'fallback', models: [...CLAUDE_FALLBACK_MODELS] };
@@ -372,7 +400,7 @@ export function queryClaudeCliVersion(claudeBin, { timeoutMs = 10000 } = {}) {
 
     try {
       child = spawn(shellCommand(bin, useShell), args, {
-        env: { ...process.env, PATH: getAugmentedPath() },
+        env: withPathEnv(process.env, getAugmentedPath()),
         stdio: ['ignore', 'pipe', 'ignore'],
         shell: useShell,
       });

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

@@ -0,0 +1,221 @@
+// Claude owns OAuth credentials and refresh. SynaBun owns only pasted keys
+// in a separate private profile file; this adapter exposes safe auth status.
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { verifyClaudeApiKey } from './claude-profile-api-key.js';
+import { validateProviderApiKey, redactProviderSecrets } from './provider-panel-api-key-auth.js';
+
+export function claudeAuthEnv(env, accountEnv) {
+  const clean = { ...env };
+  for (const key of Object.keys(clean)) {
+    if (/^(CLAUDECODE|CLAUDE_CONFIG_DIR|CLAUDE_CODE_OAUTH_TOKEN|CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR|ANTHROPIC_AUTH_TOKEN|ANTHROPIC_API_KEY|ANTHROPIC_API_KEY_FILE_DESCRIPTOR|CLAUDE_CODE_USE_BEDROCK|CLAUDE_CODE_USE_VERTEX|CLAUDE_CODE_USE_FOUNDRY)$/.test(key)) delete clean[key];
+  }
+  return { ...clean, ...accountEnv, NO_COLOR: '1', FORCE_COLOR: '0' };
+}
+
+export function claudeAuthorizationUrl(text) {
+  for (const match of text.matchAll(/https:\/\/[^\s<>"\x1b]+/g)) {
+    try {
+      const url = new URL(match[0]);
+      if (['claude.ai', 'console.anthropic.com', 'platform.claude.com'].includes(url.hostname)
+        && !url.username && !url.password && url.searchParams.has('client_id') && url.searchParams.has('code_challenge')) return url.href;
+    } catch {}
+  }
+  return '';
+}
+
+export function createClaudePanelAuth({ accounts, executable, env = () => process.env, spawnProcess = spawn, timeoutMs = 10 * 60_000, statusTimeoutMs = 15_000, verifyKey = verifyClaudeApiKey, changeCredentials = async (_id, change) => change() } = {}) {
+  const operations = new Map();
+  function account(id = 'default') {
+    if (typeof id !== 'string' || !/^[a-z0-9-]{1,64}$/.test(id)) throw Object.assign(new Error('Unknown Claude account'), { status: 404 });
+    const row = accounts.profileFor ? accounts.profileFor(id) : accounts.get(id);
+    if (!row || row.id !== id) throw Object.assign(new Error('Unknown Claude account'), { status: 404 });
+    return row;
+  }
+  function launch(id, args, extraEnv = {}) {
+    account(id);
+    const found = executable();
+    if (!found?.path) throw new Error(found?.reason || 'Claude CLI not found. Install Claude Code to sign in.');
+    const script = /\.[cm]?js$/i.test(found.path);
+    const proc = spawnProcess(script ? process.execPath : found.path, script ? [found.path, ...args] : args, {
+      env: { ...claudeAuthEnv(env(), accounts.envFor(id)), ...extraEnv }, stdio: ['pipe', 'pipe', 'pipe'], shell: false, windowsHide: true,
+    });
+    proc.stdin?.on('error', () => {}); // A native exit can race a manual-code write.
+    return proc;
+  }
+  // Claude Code's own answer about the account's login (never a credential).
+  function nativeStatus(id = 'default') {
+    account(id);
+    return new Promise((resolve, reject) => {
+      let proc;
+      try { proc = launch(id, ['auth', 'status', '--json']); } catch (error) { reject(error); return; }
+      let output = '', settled = false;
+      const finish = (error, result) => { if (settled) return; settled = true; clearTimeout(timer); error ? reject(error) : resolve(result); };
+      const timer = setTimeout(() => { proc.kill(); finish(new Error('Claude authentication status timed out. Try Refresh.')); }, statusTimeoutMs);
+      proc.stdout.on('data', chunk => { output = (output + chunk).slice(-65536); });
+      proc.stderr.on('data', () => {}); // Never forward CLI output or credential-bearing errors.
+      proc.on('error', () => finish(new Error('Could not start Claude Code. Check its installation.')));
+      proc.on('close', () => {
+        try {
+          const data = JSON.parse(output);
+          if (typeof data.loggedIn !== 'boolean') throw new Error();
+          finish(null, {
+            loggedIn: data.loggedIn, email: redactProviderSecrets(data.email || null), orgName: redactProviderSecrets(data.orgName || null),
+            authMethod: redactProviderSecrets(data.authMethod || null), subscriptionType: redactProviderSecrets(data.subscriptionType || null),
+          });
+        } catch { finish(new Error('Could not read Claude authentication. Update Claude Code to a version supporting auth status --json.')); }
+      });
+    });
+  }
+  // The account as every surface shows it (lib/claude-accounts.js describe()),
+  // after asking Claude Code about its subscription login. A failed check of an
+  // account that still has a usable API key is not an error: the key is used.
+  async function read(id = 'default') {
+    account(id);
+    // An account running on its API key is signed in whatever its subscription
+    // says: no process is started for the answer. The subscription half is
+    // asked in the background, so the account list can show it later.
+    const current = accounts.describeForClient?.(id);
+    if (current?.mode === 'apiKey' && current.signedIn === true) {
+      Promise.resolve(accounts.refreshStatus?.([id])).catch(() => {});
+      return { accountId: id, account: current, state: snapshot(id) };
+    }
+    let status = null, failure = null;
+    try { status = await nativeStatus(id); } catch (error) { failure = error; }
+    account(id); // A profile removed meanwhile is gone, whatever the CLI said.
+    if (status) accounts.noteNativeStatus?.(id, status);
+    const row = accounts.describeForClient ? accounts.describeForClient(id) : null;
+    if (failure && !(row?.mode === 'apiKey' && row.signedIn)) throw failure;
+    return { accountId: id, account: row || legacyAccount(id, status), state: snapshot(id) };
+  }
+  // A host without the account model (an older caller, a test double).
+  function legacyAccount(id, status) {
+    if (accounts.readApiKey?.(id)) return { loggedIn: true, email: null, authMethod: 'apiKey', subscriptionType: null };
+    return { loggedIn: status.loggedIn, email: status.email, authMethod: status.authMethod, subscriptionType: status.subscriptionType };
+  }
+  const keyPending = new Set();
+  async function signInApiKey(id, key) {
+    account(id); key = validateProviderApiKey('claude', key);
+    if (keyPending.has(id) || ['starting', 'pending'].includes(snapshot(id).status)) throw Object.assign(new Error('Sign-in already pending'), { status: 409 });
+    keyPending.add(id);
+    try {
+      await verifyKey(key);
+      account(id); // A removed profile must never be recreated by a late reply.
+      await changeCredentials(id, () => { account(id); accounts.saveApiKey(id, key); });
+      operations.set(id, { status: 'success', authUrl: '' });
+    } finally { keyPending.delete(id); key = null; }
+  }
+  // `credential`: 'apiKey' removes the key SynaBun keeps, 'subscription' runs
+  // Claude Code's own logout in the account's config directory, 'all' both.
+  async function signOut(id, credential = 'all') {
+    account(id);
+    if (!['all', 'apiKey', 'subscription'].includes(credential)) throw Object.assign(new Error('Choose which sign-in to remove.'), { status: 400 });
+    if (keyPending.has(id)) throw Object.assign(new Error('Sign-in already pending'), { status: 409 });
+    const op = operations.get(id);
+    if (op && ['starting', 'pending'].includes(op.status) && credential !== 'apiKey') cancel(id, op.operationId);
+    keyPending.add(id);
+    try {
+      await changeCredentials(id, async () => {
+        if (credential !== 'subscription') accounts.clearApiKey(id);
+        if (credential === 'apiKey') return;
+        operations.delete(id);
+        await new Promise((resolve, reject) => {
+          let proc, timer;
+          try { proc = launch(id, ['auth', 'logout']); } catch { reject(new Error('Could not sign out of Claude. Try again.')); return; }
+          let settled = false;
+          const finish = ok => { if (settled) return; settled = true; clearTimeout(timer); ok ? resolve() : reject(new Error('Could not sign out of Claude. Try again.')); };
+          proc.stdout.on('data', () => {}); proc.stderr.on('data', () => {});
+          proc.on('error', () => finish(false)); proc.on('close', code => finish(code === 0));
+          timer = setTimeout(() => { proc.kill(); finish(false); }, statusTimeoutMs);
+        });
+        accounts.noteNativeStatus?.(id, { loggedIn: false });
+      });
+    } finally { keyPending.delete(id); }
+  }
+  // What the account's sessions use from now on; its idle panel processes end
+  // so the next message starts under the new credential.
+  async function setMode(id, mode) {
+    account(id);
+    if (keyPending.has(id) || ['starting', 'pending'].includes(snapshot(id).status)) throw Object.assign(new Error('Finish sign-in first.'), { status: 409 });
+    return changeCredentials(id, () => accounts.setMode(id, mode));
+  }
+  function snapshot(id) {
+    const op = operations.get(id);
+    return op ? { accountId: id, operationId: op.operationId, status: op.status, authUrl: op.authUrl, error: op.error || '' } : { accountId: id, status: 'idle' };
+  }
+  function start(id = 'default') {
+    account(id);
+    if (keyPending.has(id)) throw Object.assign(new Error('Sign-in already pending'), { status: 409 });
+    const existing = operations.get(id);
+    if (existing && ['starting', 'pending'].includes(existing.status)) return snapshot(id);
+    // BROWSER is a supported Claude Code handoff. Suppress its OS browser launch:
+    // the panel opens the URL printed by the native command instead.
+    const dir = mkdtempSync(join(tmpdir(), 'synabun-claude-oauth-'));
+    const browser = join(dir, process.platform === 'win32' ? 'browser.cmd' : 'browser');
+    writeFileSync(browser, process.platform === 'win32' ? '@exit /b 0\r\n' : '#!/bin/sh\nexit 0\n', { mode: 0o700 });
+    const op = { operationId: randomUUID(), status: 'starting', authUrl: '', process: null };
+    operations.set(id, op);
+    let timer, forceTimer, output = '';
+    const cleanup = () => { clearTimeout(timer); clearTimeout(forceTimer); rmSync(dir, { recursive: true, force: true }); };
+    const finish = (status, error = '') => {
+      if (!['starting', 'pending'].includes(op.status)) return;
+      op.status = status; op.error = error; op.authUrl = '';
+      clearTimeout(timer);
+    };
+    op.stop = (status, error) => {
+      finish(status, error);
+      op.process?.kill();
+      forceTimer = setTimeout(() => op.process?.kill('SIGKILL'), 2000); forceTimer.unref?.();
+    };
+    try {
+      op.process = launch(id, ['auth', 'login', '--claudeai'], { BROWSER: browser });
+      const collect = chunk => {
+        output = (output + chunk).slice(-65536);
+        if (['starting', 'pending'].includes(op.status)) {
+          const url = claudeAuthorizationUrl(output.slice(0, output.lastIndexOf('\n') + 1));
+          if (url) { op.authUrl = url; op.status = 'pending'; }
+        }
+      };
+      op.process.stdout.on('data', collect); op.process.stderr.on('data', collect);
+      op.process.on('error', () => { finish('error', 'Could not start Claude Code. Check its installation.'); cleanup(); });
+      op.process.on('close', async code => {
+        cleanup();
+        if (!['starting', 'pending'].includes(op.status)) return;
+        if (code !== 0) { finish('error', 'Claude sign-in failed. Retry, or update Claude Code if auth login is unavailable.'); return; }
+        try {
+          const status = await nativeStatus(id);
+          if (status.loggedIn) {
+            // A subscription just signed into is what the account uses from now on.
+            if (accounts.noteSubscriptionSignIn) accounts.noteSubscriptionSignIn(id, status);
+            else accounts.recordIdentity?.(id);
+            finish('success');
+          } else finish('error', 'Claude Code finished without confirming sign-in. Try again.');
+        } catch (error) { finish('error', error.message); }
+      });
+      timer = setTimeout(() => op.stop('error', 'Claude sign-in timed out. Try again.'), timeoutMs); timer.unref?.();
+    } catch (error) { finish('error', error.message); cleanup(); }
+    return snapshot(id);
+  }
+  function cancel(id, operationId) {
+    account(id);
+    const op = operations.get(id);
+    if (!op || op.operationId !== operationId) throw Object.assign(new Error('This sign-in attempt is no longer active. Refresh its status.'), { status: 409 });
+    if (['starting', 'pending'].includes(op.status)) op.stop('cancelled', '');
+    return snapshot(id);
+  }
+  function submitCode(id, operationId, code) {
+    account(id);
+    const op = operations.get(id);
+    if (!op || op.operationId !== operationId || op.status !== 'pending') throw Object.assign(new Error('This sign-in attempt is no longer active. Refresh its status.'), { status: 409 });
+    if (typeof code !== 'string' || !code.trim() || code.length > 4096 || /[\r\n\0]/.test(code)) throw Object.assign(new Error('Paste a single sign-in code from Claude.'), { status: 400 });
+    if (!op.process?.stdin?.writable) throw new Error('Claude Code is no longer accepting a sign-in code. Retry sign-in.');
+    op.process.stdin.write(`${code.trim()}\n`, error => {
+      if (error && op.status === 'pending') op.stop('error', 'Claude Code stopped accepting the sign-in code. Retry sign-in.');
+    });
+    return snapshot(id);
+  }
+  return { start, read, nativeStatus, cancel, submitCode, snapshot, signInApiKey, signOut, setMode, close: () => { for (const [id, op] of operations) if (['starting', 'pending'].includes(op.status)) cancel(id, op.operationId); } };
+}

package/neural-interface/lib/claude-profile-api-key.js

@@ -0,0 +1,62 @@
+// SynaBun's own file, never Claude's native credential store. Atomic 0600 writes
+// work on every supported platform without a Keychain prompt or service naming.
+import { constants, openSync, closeSync, fstatSync, readFileSync, writeFileSync, mkdirSync, renameSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { validateProviderApiKey, providerApiKeyError } from './provider-panel-api-key-auth.js';
+export const CLAUDE_API_KEY_FILE = '.synabun-api-key';
+// The same file holds an account's key for either provider (Claude: an
+// Anthropic key in its CLAUDE_CONFIG_DIR; Codex: an OpenAI key in its
+// CODEX_HOME, lib/codex-accounts.js), checked against that provider's format.
+export function readProfileApiKey(home, provider = 'claude') {
+  let fd;
+  try {
+    fd = openSync(join(home, CLAUDE_API_KEY_FILE), constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || (process.platform !== 'win32' && (stat.mode & 0o077))) throw new Error('Unsafe credential permissions');
+    return validateProviderApiKey(provider, readFileSync(fd, 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw new Error('Could not read the saved API key. Sign in again.');
+  } finally { if (fd !== undefined) closeSync(fd); }
+}
+export function readClaudeProfileApiKey(home) { return readProfileApiKey(home, 'claude'); }
+export function saveProfileApiKey(home, key, provider = 'claude') {
+  key = validateProviderApiKey(provider, key);
+  mkdirSync(home, { recursive: true, mode: 0o700 });
+  const target = join(home, CLAUDE_API_KEY_FILE), temp = `${target}.${randomUUID()}.tmp`;
+  try { writeFileSync(temp, key, { mode: 0o600, flag: 'wx' }); renameSync(temp, target); }
+  finally { rmSync(temp, { force: true }); }
+}
+export function saveClaudeProfileApiKey(home, key) { saveProfileApiKey(home, key, 'claude'); }
+export function clearProfileApiKey(home) { rmSync(join(home, CLAUDE_API_KEY_FILE), { force: true }); }
+export function clearClaudeProfileApiKey(home) { clearProfileApiKey(home); }
+export async function verifyClaudeApiKey(key, fetchRequest = fetch) {
+  let response;
+  try {
+    response = await fetchRequest('https://api.anthropic.com/v1/models?limit=1', {
+      headers: { 'x-api-key': key, 'anthropic-version': '2023-06-01' }, signal: AbortSignal.timeout(15000), redirect: 'error',
+    });
+  } catch { throw providerApiKeyError('verification_unreachable'); }
+  finally { key = null; }
+  // Discard the body without letting a cleanup failure mask the HTTP result.
+  // Neither provider response bodies nor exception text are surfaced or logged.
+  try { await response.body?.cancel(); } catch {}
+  if ([401, 403].includes(response.status)) throw providerApiKeyError('key_rejected');
+  if (!response.ok) throw providerApiKeyError('verification_unavailable');
+}
+
+// OpenAI's read-only model list answers whether a key is accepted. The key goes
+// in the Authorization header only; the body and any error text are dropped.
+export async function verifyOpenAiApiKey(key, fetchRequest = fetch) {
+  let response;
+  try {
+    response = await fetchRequest('https://api.openai.com/v1/models', {
+      headers: { authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(15000), redirect: 'error',
+    });
+  } catch { throw providerApiKeyError('verification_unreachable', 'codex'); }
+  finally { key = null; }
+  try { await response.body?.cancel(); } catch {}
+  if ([401, 403].includes(response.status)) throw providerApiKeyError('key_rejected', 'codex');
+  if (!response.ok) throw providerApiKeyError('verification_unavailable', 'codex');
+}