synabun 2.0.0 → 2.0.7

package/neural-interface/lib/provider-panel-api-key-auth.js

@@ -0,0 +1,92 @@
+const API_KEY_ERRORS = {
+  invalid_key: { status: 400, message: "That doesn't look like an API key for this provider." },
+  oauth_token: { status: 400, message: "That's a Claude sign-in token. Use Sign in with Claude." },
+  key_rejected: { status: 401, message: 'The provider rejected that key.' },
+  account_unavailable: { status: 404, message: 'This account is no longer available. Select an account again.' },
+  account_busy: { status: 409, message: 'Finish sign-in or reconnect this account and try again.' },
+  verification_unreachable: { status: 503, message: "Couldn't reach {vendor} to check the key. Try again." },
+  verification_unavailable: { status: 503, message: "{vendor} couldn't check the key. Try again shortly." },
+  storage_failed: { status: 500, message: "Couldn't save the key for this account." },
+};
+// `provider` names the vendor in the two verification messages (Anthropic for Claude, OpenAI for Codex).
+export function providerApiKeyError(code, provider = 'claude') {
+  const { status, message } = Object.hasOwn(API_KEY_ERRORS, code) ? API_KEY_ERRORS[code] : API_KEY_ERRORS.storage_failed;
+  return Object.assign(new Error(message.replace('{vendor}', provider === 'codex' ? 'OpenAI' : 'Anthropic')), { status, code });
+}
+
+// Return the normalized value: clipboard padding is not part of a credential.
+export function validateProviderApiKey(provider, key) {
+  if (!['claude', 'codex'].includes(provider)) throw Object.assign(new Error('Unknown provider'), { status: 404 });
+  if (typeof key !== 'string' || key.length > 4096) throw providerApiKeyError('invalid_key');
+  key = key.trim();
+  // setup-token produces an OAuth token, not an Anthropic API key. Never send
+  // it to x-api-key or persist it under the API-key authentication method.
+  if (provider === 'claude' && key.startsWith('sk-ant-oat01-')) throw providerApiKeyError('oauth_token');
+  const pattern = provider === 'claude' ? /^sk-ant-[A-Za-z0-9_-]{16,}$/ : /^sk-(?!ant-)[A-Za-z0-9_-]{16,}$/;
+  if (!pattern.test(key)) throw providerApiKeyError('invalid_key');
+  return key;
+}
+
+// Defense in depth for native diagnostics/events. Never forward credential fields.
+export function redactProviderSecrets(value) {
+  if (typeof value === 'string') return value.replace(/sk-[A-Za-z0-9_-]{16,}/g, '[redacted]');
+  if (Array.isArray(value)) return value.map(redactProviderSecrets);
+  if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value)
+    .filter(([key]) => !/^(api_?key|access_?token|refresh_?token|id_?token|authorization)$/i.test(key))
+    .map(([key, item]) => [key, redactProviderSecrets(item)]));
+  return value;
+}
+
+export function registerProviderPanelApiKeyAuthRoutes(app, { guard, claude, codex }) {
+  app.post('/api/provider-panel-auth/:provider/:accountId/api-key', guard, async (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    const { provider, accountId } = req.params;
+    let key = req.body?.key;
+    // Express's parsed request body must not outlive this handler with a secret.
+    if (req.body) delete req.body.key;
+    try {
+      key = validateProviderApiKey(provider, key);
+      if (!/^[a-z0-9-]{1,64}$/.test(accountId)) throw providerApiKeyError('account_unavailable');
+      // Codex keys are kept by SynaBun per account too (lib/codex-accounts.js): an older
+      // page may still send the `target` of its live connection, which is not needed now.
+      if (provider === 'claude') await claude(accountId, key);
+      else await codex(accountId, key);
+      res.json({ ok: true });
+    } catch (error) {
+      // Never serialize provider exceptions; a native error may echo its input.
+      const fallback = { 400: 'invalid_key', 401: 'key_rejected', 404: 'account_unavailable', 409: 'account_busy', 503: 'verification_unavailable' }[error.status] || 'storage_failed';
+      const code = Object.hasOwn(API_KEY_ERRORS, error.code) ? error.code : fallback;
+      const safe = providerApiKeyError(code, provider);
+      res.status(safe.status).json({ code, error: safe.message });
+    } finally { key = null; }
+  });
+}
+
+// Install immediately after the global JSON parser: its SyntaxError may contain
+// a fragment of the secret-bearing body. Never pass that error to Express logs.
+export function providerApiKeyBodyError(error, req, res, next) {
+  if (req.method !== 'POST' || !/^\/api\/provider-panel-auth\/[^/]+\/[^/]+\/api-key(?:\?|$)/.test(req.originalUrl || req.url || '')) return next(error);
+  delete error.body;
+  req.body = undefined;
+  res.setHeader('Cache-Control', 'no-store');
+  return res.status(error.status === 413 ? 413 : 400).json({ code: 'invalid_key', error: API_KEY_ERRORS.invalid_key.message });
+}
+
+// Native stderr arrives in arbitrary chunks. Redact complete lines so a split
+// credential cannot leave an unmasked suffix; omit unterminated/oversized lines.
+export function providerDiagnosticSink(write, maxChars = 65536) {
+  let buffer = '', dropping = false;
+  return chunk => {
+    const parts = String(chunk).split(/\r?\n/);
+    for (let i = 0; i < parts.length; i++) {
+      if (!dropping) {
+        buffer += parts[i];
+        if (buffer.length > maxChars) { buffer = ''; dropping = true; }
+      }
+      if (i < parts.length - 1) {
+        if (!dropping && buffer.trim()) write(redactProviderSecrets(buffer.trim()));
+        buffer = ''; dropping = false;
+      }
+    }
+  };
+}

package/neural-interface/lib/provider-panel-terminal-auth.js

@@ -0,0 +1,95 @@
+import { randomBytes } from 'node:crypto';
+import { isAbsolute } from 'node:path';
+import { claudeAuthEnv } from './claude-panel-auth.js';
+import { applyCodexLaunchEnv } from './codex-accounts.js';
+
+// Only server-owned account records and resolved executables enter the PTY.
+export function providerLoginSpec({ provider, accountId, claudeAccounts, codexAccount, claudeExecutable, codexExecutable, env }) {
+  if (!['claude', 'codex'].includes(provider) || typeof accountId !== 'string' || !/^[a-z0-9-]{1,64}$/.test(accountId)) {
+    throw Object.assign(new Error('Unknown provider account'), { status: 404 });
+  }
+  const account = provider === 'claude' ? claudeAccounts.profileFor(accountId) : codexAccount(accountId);
+  if (!account || account.id !== accountId) throw Object.assign(new Error('Unknown provider account'), { status: 404 });
+  const file = provider === 'claude' ? claudeExecutable()?.path : codexExecutable();
+  if (!file || !isAbsolute(file) || /\.(cmd|bat)$/i.test(file)) {
+    throw new Error(`Could not resolve the ${provider === 'claude' ? 'Claude' : 'Codex'} executable. Check its installation.`);
+  }
+  let baseEnv = { ...env };
+  if (provider === 'codex') {
+    // Every Codex account, Default too: `codex login` writes to that account's CODEX_HOME, with no
+    // inherited OpenAI/Codex credential around it (lib/codex-accounts.js CODEX_CREDENTIAL_ENV).
+    if (!account.home) throw new Error('This Codex account has no home folder.');
+    baseEnv = applyCodexLaunchEnv(baseEnv, { env: { CODEX_HOME: account.home } });
+  } else if (accountId !== 'default') {
+    if (!account.home) throw new Error('This Claude account has no isolated home.');
+    baseEnv = claudeAuthEnv(baseEnv, { CLAUDE_CONFIG_DIR: account.home });
+  }
+  const args = provider === 'claude' ? ['auth', 'login', '--claudeai'] : ['login'];
+  return { launch: /\.[cm]?js$/i.test(file) ? { shell: process.execPath, args: [file, ...args] } : { shell: file, args }, baseEnv };
+}
+
+// `onSettled(provider, id, status)` (optional): told once when a sign-in terminal ends ('exited' when the
+// CLI exited 0, else 'error'), so the host can ask the provider what it now says about the account.
+export function createProviderPanelTerminalAuth({ resolveSpec, createSession, whenSpawned, killSession, timeoutMs = 10 * 60_000, onSettled = null }) {
+  const operations = new Map();
+  const key = (provider, id) => `${provider}:${id}`;
+  const snapshot = op => ({ sessionId: op.sessionId, status: op.status, error: op.error || '' });
+  function read(provider, id) {
+    resolveSpec(provider, id); // Validate deleted accounts and unsupported providers on reads too.
+    const op = operations.get(key(provider, id));
+    return op ? snapshot(op) : { status: 'idle' };
+  }
+  async function start(provider, id) {
+    const spec = resolveSpec(provider, id);
+    const existing = operations.get(key(provider, id));
+    if (existing && ['starting', 'pending'].includes(existing.status)) { await existing.ready; return snapshot(existing); }
+    const op = { sessionId: randomBytes(16).toString('hex'), status: 'starting' };
+    operations.set(key(provider, id), op);
+    let timer;
+    const finish = (status, error = '') => {
+      if (!['starting', 'pending'].includes(op.status)) return;
+      clearTimeout(timer); op.status = status; op.error = error;
+      if (typeof onSettled === 'function') Promise.resolve().then(() => onSettled(provider, id, status)).catch(() => {});
+    };
+    op.ready = (async () => {
+      try {
+        createSession('shell', 120, 30, undefined, { ...spec, sessionId: op.sessionId,
+          onExit: ({ exitCode }) => finish(exitCode === 0 ? 'exited' : 'error', exitCode === 0 ? '' : 'Sign-in failed. Try again.'),
+          onClosed: () => finish('error', 'Sign-in terminal closed. Try again.'),
+        });
+        let spawnTimer;
+        try {
+          await Promise.race([whenSpawned(op.sessionId), new Promise((_, reject) => {
+            spawnTimer = setTimeout(() => reject(new Error('Terminal host did not respond')), 15000);
+          })]);
+        } finally { clearTimeout(spawnTimer); }
+        if (op.status === 'starting') {
+          op.status = 'pending';
+          timer = setTimeout(() => { finish('error', 'Sign-in timed out. Try again.'); killSession(op.sessionId); }, timeoutMs);
+          timer.unref?.();
+        }
+      } catch {
+        finish('error', 'Could not open the sign-in terminal. Try again.');
+        killSession(op.sessionId);
+      }
+    })();
+    await op.ready;
+    return snapshot(op);
+  }
+  return { start, read };
+}
+
+export function registerProviderPanelTerminalAuthRoutes(app, { guard, auth }) {
+  const route = '/api/provider-panel-auth/:provider/:id/terminal';
+  app.get(route, guard, (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    try { res.json({ terminal: auth.read(req.params.provider, req.params.id) }); }
+    catch (error) { res.status(error.status || 500).json({ error: error.message }); }
+  });
+  app.post(route, guard, async (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    if (Object.keys(req.body || {}).length) return res.status(400).json({ error: 'Only provider and account selection are accepted.' });
+    try { res.json({ terminal: await auth.start(req.params.provider, req.params.id) }); }
+    catch (error) { res.status(error.status || 500).json({ error: error.message }); }
+  });
+}

package/neural-interface/lib/pty-host/core.js

@@ -18,6 +18,7 @@ import { createTerminalModel } from './snapshot.js';
 import { evaluateFlow } from './flow.js';
 import { EV, OP, HOST_DEFAULTS } from './protocol.js';
 import { createEventLoopMonitor } from '../event-loop-monitor.js';
+import { withPathEnv } from '../augmented-path.js';
 
 const IS_WIN = process.platform === 'win32';
 const IS_LINUX = process.platform === 'linux';
@@ -74,7 +75,7 @@ export function createPtyHostCore({ send, config = {}, pty: injectedPty = null }
     }
     const cols = clampInt(spec.cols, 2, 1000) || 120;
     const rows = clampInt(spec.rows, 1, 500) || 30;
-    const env = { ...(spec.env || {}) };
+    const env = withPathEnv(spec.env || {});
     for (const k of Object.keys(env)) if (k.startsWith('NODE_CHANNEL_') || k === 'NODE_UNIQUE_ID') delete env[k];
 
     let file = spec.file;

package/neural-interface/lib/pty-host/manager.js

@@ -38,6 +38,7 @@ export function createPtyHostManager({
 } = {}) {
   const handlers = new Map();     // id → { onSpawned, onTap, onResized, onClients, onExit }
   const spawnWaiters = new Map(); // id → waiter
+  const preparing = new Map();   // id → operations queued while PATH is read
   const requests = new Map();     // reqId → { resolve, reject, timer }
   let reqSeq = 0;
   let child = null;
@@ -158,6 +159,7 @@ export function createPtyHostManager({
     heldSockets = [];
     queue = [];
     const lost = [...handlers.entries()];
+    preparing.clear();
     handlers.clear();
     for (const [id] of lost) settleSpawn(id, new Error('pty-host exited'));
     spawnWaiters.clear();
@@ -175,6 +177,13 @@ export function createPtyHostManager({
 
   // ── Main → host ──
   function sendOp(msg) {
+    if (preparing.has(msg.id) && msg.op !== OP.SPAWN) {
+      if (msg.op === OP.KILL) {
+        preparing.delete(msg.id);
+        dispatch({ t: EV.SPAWN_ERROR, id: msg.id, message: 'Terminal closed before it started' });
+      } else preparing.get(msg.id).push(msg);
+      return;
+    }
     if (mode === 'inproc') {
       if (!core || !ready) { queue.push(msg); return; }
       core.handleMessage(msg);
@@ -190,11 +199,23 @@ export function createPtyHostManager({
     for (const msg of q) sendOp(msg);
   }
 
-  function spawn(spec, h = {}) {
+  function spawn(spec, h = {}, prepare = null) {
     handlers.set(spec.id, h);
     const w = makeWaiter();
     spawnWaiters.set(spec.id, w);
-    sendOp({ op: OP.SPAWN, ...spec });
+    if (prepare) {
+      const pending = [];
+      preparing.set(spec.id, pending);
+      Promise.resolve().then(prepare).then(prepared => {
+        if (shuttingDown || !handlers.has(spec.id) || preparing.get(spec.id) !== pending) return;
+        preparing.delete(spec.id);
+        sendOp({ op: OP.SPAWN, ...spec, ...prepared });
+        for (const message of pending) sendOp(message);
+      }).catch(error => {
+        preparing.delete(spec.id);
+        dispatch({ t: EV.SPAWN_ERROR, id: spec.id, message: error.message });
+      });
+    } else sendOp({ op: OP.SPAWN, ...spec });
     return w.promise;
   }
 
@@ -315,6 +336,8 @@ export function createPtyHostManager({
 
   async function shutdown({ timeoutMs = 1500 } = {}) {
     shuttingDown = true;
+    for (const id of preparing.keys()) settleSpawn(id, new Error('Terminal host is shutting down'));
+    preparing.clear();
     if (restartTimer) { clearTimeout(restartTimer); restartTimer = null; }
     if (mode === 'inproc') {
       try { core?.shutdownAll(); } catch {}
@@ -332,6 +355,8 @@ export function createPtyHostManager({
 
   function killNow() {
     shuttingDown = true;
+    for (const id of preparing.keys()) settleSpawn(id, new Error('Terminal host is shutting down'));
+    preparing.clear();
     if (restartTimer) { clearTimeout(restartTimer); restartTimer = null; }
     try { child?.kill('SIGTERM'); } catch {}
     try { core?.shutdownAll(); } catch {}

package/neural-interface/lib/remote-policy.js

@@ -10,7 +10,9 @@
 //                refuse, user allow rules included; routing always asks (one
 //                route card per task is the task's approval); workers get no
 //                computer, no "user-authorized-full" and a registered cwd.
-//   autonomous — the modes as configured, until autonomousUntil; then ask.
+//   autonomous — the modes as configured. On WhatsApp it stays until the owner
+//                lowers it in Settings; any other channel only until its
+//                autonomousUntil, then ask.
 // Ask and Autonomous hold only on a Claude brain: its in-process PreToolUse
 // hook sees every call with its arguments. A Codex or OpenCode brain runs
 // ordinary commands inside its own sandbox / permissions without asking, so a
@@ -25,7 +27,7 @@
 //
 // Computer use (the Assistant's own computer tools) is off unless the owner
 // turned on its switch at this computer (the policy's `computerUse`), and then
-// only as remoteComputerUse says: unasked while Autonomous is active, after
+// only as remoteComputerUse says: unasked while Autonomous is on, after
 // one yes per turn at Ask, never at Read-only, while paused or on a Codex /
 // OpenCode brain. That function is the one place that decides; the runtime,
 // the brain's hook, the desktop gate, the persona and the panel all ask it.
@@ -81,16 +83,17 @@ export class RemotePolicyError extends Error {
 
 /**
  * The level that applies now: null without a policy. Paused reads as
- * read-only, an expired (or never armed) autonomous as ask, a turn whose
- * prompt carried untrusted content is capped at ask, and a session whose brain
- * cannot hold Ask/Autonomous (`provider`, else the policy's brainProvider:
- * Codex, OpenCode) is read-only.
+ * read-only, a turn whose prompt carried untrusted content is capped at ask,
+ * and a session whose brain cannot hold Ask/Autonomous (`provider`, else the
+ * policy's brainProvider: Codex, OpenCode) is read-only. Autonomous on
+ * WhatsApp has no time limit (it stays until the owner lowers it); on any
+ * other channel an expired (or never armed) autonomousUntil reads as ask.
  */
 export function effectiveLevel(policy, { untrusted = false, now = Date.now(), provider = null } = {}) {
   if (!policy) return null;
   let level = normalizeLevel(policy.level);
   if (policy.paused === true) level = 'read-only';
-  if (level === 'autonomous') {
+  if (level === 'autonomous' && policy.channel !== 'whatsapp') {
     const until = toMs(policy.autonomousUntil);
     if (!(until > now)) level = 'ask';
   }
@@ -139,7 +142,8 @@ export const COMPUTER_REASONS = Object.freeze({
  *            read_only           the Read-only level (or a session nobody registered since a restart)
  *            unsupported, setup  computer use is not available, or not set up, on this machine (`desktop`)
  *   ask      ask                 the Ask level: one yes per turn turns it on for that turn
- *            autonomous_expired  Autonomous is configured but its window is closed (or was never armed)
+ *            autonomous_expired  Autonomous is configured but its autonomousUntil passed (or was never set): never
+ *                                on WhatsApp, where Autonomous has no time limit
  *            untrusted           Autonomous is active, but this turn carries content the owner did not write
  *   allowed  autonomous          Autonomous is active: the computer tools run unasked
  * `desktop`: { supported, ready } of the desktop service (omitted: not checked).
@@ -288,17 +292,20 @@ function defaultDataHome(env = process.env) {
   if (osPlatform() === 'win32' && env.APPDATA) return resolve(env.APPDATA, 'synabun');
   return resolve(homedir(), '.synabun');
 }
-/** Every place the WhatsApp Link may keep its session and connector (lib/whatsapp/paths.js), the refused override too. */
+/**
+ * Every place the WhatsApp Link may keep its session and connector (lib/whatsapp/paths.js), the refused
+ * override too, and the voice-note folder whose programs the WhatsApp host runs (transcriptionDir).
+ */
 function whatsappLocations(dataHome, env, platform) {
   const out = [];
   try {
     const wa = resolveWhatsAppPaths({ dataHome, env, platform });
-    out.push(wa.waHome, wa.defaultWaHome, wa.runtimeDir, wa.stagingDir);
+    out.push(wa.waHome, wa.defaultWaHome, wa.runtimeDir, wa.stagingDir, wa.transcriptionDir);
   } catch {}
   const override = typeof env.SYNABUN_WHATSAPP_HOME === 'string' ? env.SYNABUN_WHATSAPP_HOME.trim() : '';
   if (override) out.push(resolve(override));
   if (env.LOCALAPPDATA) out.push(resolve(env.LOCALAPPDATA, 'synabun', 'whatsapp'));
-  out.push(resolve(dataHome, 'whatsapp'), resolve(dataHome, 'runtime', 'whatsapp'));
+  out.push(resolve(dataHome, 'whatsapp'), resolve(dataHome, 'runtime', 'whatsapp'), resolve(dataHome, 'runtime', 'whatsapp-transcription'));
   return [...new Set(out.filter(Boolean))];
 }
 const slash = (value) => String(value || '').replace(/\\/g, '/').replace(/\/{2,}/g, '/').toLowerCase();
@@ -359,6 +366,8 @@ const DENIED_PATTERNS = [
   { re: /\/etc\/cron|\/var\/at\/tabs|\/usr\/lib\/cron|\/var\/spool\/cron/, why: 'crontab' },
   { re: /\/api\/whatsapp\b/, why: 'the WhatsApp link' },
   { re: /(?:^|[^a-z0-9_-])runtime\/whatsapp\b/, why: 'the WhatsApp link' },
+  // The voice-note folder by name, wherever it sits (a relative path, a moved home): the WhatsApp host runs the programs in it.
+  { re: /(?:^|[^a-z0-9_.-])whatsapp-transcription(?=$|[^a-z0-9_-])/, why: 'the WhatsApp link (voice-note programs)' },
   { re: /(?:^|[^a-z0-9_-])\.?synabun\/whatsapp\b/, why: 'the WhatsApp link' },
   // The session store by name, wherever it sits (a relative path, a moved home): state.db and its -wal/-shm/-journal.
   { re: /(?:^|[^a-z0-9_.-])state\.db(?:-(?:wal|shm|journal))?(?=$|[^a-z0-9_.-])/, why: 'the WhatsApp login (state.db)' },