synabun 1.3.0 → 2.0.0-beta

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

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+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']);
+const own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+
+/** Session choices are scoped to account/thread and never written to config.toml. */
+export class CodexSessionSettingsStore {
+  constructor(filePath) { this.filePath = filePath; this.settings = null; }
+  load() {
+    if (this.settings) return;
+    if (!existsSync(this.filePath)) { this.settings = {}; return; }
+    const value = JSON.parse(readFileSync(this.filePath, 'utf8'));
+    if (value?.version !== 1 || !value.settings || typeof value.settings !== 'object' || Array.isArray(value.settings)) {
+      throw new Error('Invalid Codex session settings file.');
+    }
+    this.settings = value.settings;
+  }
+  key(accountId, threadId) {
+    if (!accountId || !threadId) throw new Error('Session settings require an account and thread.');
+    return JSON.stringify([String(accountId), String(threadId)]);
+  }
+  get(accountId, threadId) {
+    if (!threadId) return {};
+    this.load();
+    return structuredClone(this.settings[this.key(accountId, threadId)] || {});
+  }
+  set(accountId, threadId, patch) {
+    this.load();
+    const key = this.key(accountId, threadId);
+    const nextSettings = { ...this.settings[key] };
+    for (const name of CODEX_SESSION_SETTING_KEYS) if (own(patch, name)) nextSettings[name] = structuredClone(patch[name]);
+    const next = { ...this.settings, [key]: nextSettings };
+    mkdirSync(dirname(this.filePath), { recursive: true });
+    const temporary = `${this.filePath}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(temporary, JSON.stringify({ version: 1, settings: next }), { flag: 'wx', mode: 0o600 });
+      renameSync(temporary, this.filePath);
+    } finally {
+      try { unlinkSync(temporary); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    }
+    this.settings = next;
+    return structuredClone(nextSettings);
+  }
+}

package/neural-interface/lib/codex-sidepanel-permissions.js

@@ -0,0 +1,110 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+
+const STORE_VERSION = 1;
+export const CODEX_SIDEPANEL_APPROVAL_POLICY = 'on-request';
+
+function emptyStore() {
+  return {
+    version: STORE_VERSION,
+    filesystem: { read: [], write: [] },
+  };
+}
+
+export function normalizeCodexPermissionPath(value) {
+  if (typeof value !== 'string' || !value.trim() || !isAbsolute(value.trim())) return '';
+  try { return resolve(value.trim()); } catch { return ''; }
+}
+
+export function normalizeCodexFilesystemPermissions(permissions) {
+  const filesystem = permissions?.fileSystem || permissions?.filesystem || {};
+  const normalizeList = (values) => [...new Set(
+    (Array.isArray(values) ? values : [])
+      .map(normalizeCodexPermissionPath)
+      .filter(Boolean),
+  )];
+  return {
+    read: normalizeList(filesystem.read),
+    write: normalizeList(filesystem.write),
+  };
+}
+
+export function sanitizeCodexPermissionResponse(requestedPermissions, response) {
+  const requested = requestedPermissions && typeof requestedPermissions === 'object'
+    ? requestedPermissions
+    : {};
+  const granted = response?.permissions && typeof response.permissions === 'object'
+    ? response.permissions
+    : {};
+  return {
+    permissions: Object.keys(granted).length ? requested : {},
+    scope: response?.scope === 'session' ? 'session' : 'turn',
+  };
+}
+
+function normalizeStore(value) {
+  const filesystem = normalizeCodexFilesystemPermissions({
+    fileSystem: value?.filesystem || value?.fileSystem || {},
+  });
+  return {
+    version: STORE_VERSION,
+    filesystem,
+  };
+}
+
+export class CodexSidepanelPermissionStore {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+
+  list() {
+    try {
+      if (!existsSync(this.filePath)) return emptyStore();
+      return normalizeStore(JSON.parse(readFileSync(this.filePath, 'utf-8')));
+    } catch {
+      return emptyStore();
+    }
+  }
+
+  grant(permissions) {
+    const requested = normalizeCodexFilesystemPermissions(permissions);
+    if (!requested.read.length && !requested.write.length) {
+      throw new Error('Codex did not request a filesystem folder that can be saved');
+    }
+    const current = this.list();
+    const next = {
+      version: STORE_VERSION,
+      filesystem: {
+        read: [...new Set([...current.filesystem.read, ...requested.read])],
+        write: [...new Set([...current.filesystem.write, ...requested.write])],
+      },
+    };
+    this.save(next);
+    return { store: next, granted: requested };
+  }
+
+  revoke(access, value) {
+    if (access !== 'read' && access !== 'write') throw new Error('Unknown filesystem permission type');
+    const target = normalizeCodexPermissionPath(value);
+    if (!target) throw new Error('A valid absolute folder path is required');
+    const next = this.list();
+    next.filesystem[access] = next.filesystem[access].filter((entry) => entry !== target);
+    this.save(next);
+    return next;
+  }
+
+  save(value) {
+    const next = normalizeStore(value);
+    const dir = dirname(this.filePath);
+    mkdirSync(dir, { recursive: true });
+    const tmp = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`, 'utf-8');
+    renameSync(tmp, this.filePath);
+  }
+}

package/neural-interface/lib/codex-thread-history.js

@@ -0,0 +1,165 @@
+import { isCodexUnsupportedMethod } from './codex-capabilities.js';
+
+const CODEX_HISTORY_PAGE_TIMEOUT_MS = 15000;
+const CODEX_TURN_PAGE_SIZE = 100;
+const CODEX_ITEM_PAGE_SIZE = 500;
+
+function codexErrorText(error) {
+  if (!error) return '';
+  const parts = [
+    typeof error === 'string' ? error : error.message,
+    typeof error === 'object' && error.data != null
+      ? (typeof error.data === 'string' ? error.data : JSON.stringify(error.data))
+      : '',
+  ];
+  return parts.filter(Boolean).join(' ');
+}
+
+function historyProtocolError(message) {
+  const error = new Error(message);
+  error.code = 'CODEX_HISTORY_PROTOCOL_ERROR';
+  return error;
+}
+
+export function isCodexItemsPaginationUnsupported(error) {
+  if (!error) return false;
+  if (isCodexUnsupportedMethod(error)) return true;
+  return /(?:method not found|unsupported[- ]method|not supported(?: yet)?|does not support item pagination)/i
+    .test(codexErrorText(error));
+}
+
+export function isCodexHistoryUnavailableBeforeFirstTurn(error) {
+  return /(?:not materialized yet|unavailable before first user message)/i.test(codexErrorText(error));
+}
+
+async function paginateCodexHistory(request, method, baseParams, {
+  timeoutMs = CODEX_HISTORY_PAGE_TIMEOUT_MS,
+} = {}) {
+  const data = [];
+  const seenCursors = new Set();
+  let cursor = null;
+
+  do {
+    const params = cursor == null ? baseParams : { ...baseParams, cursor };
+    const result = await request(method, params, timeoutMs);
+    if (!Array.isArray(result?.data)) {
+      throw historyProtocolError(`${method} returned an invalid page`);
+    }
+    data.push(...result.data);
+
+    const nextCursor = result.nextCursor ?? null;
+    if (nextCursor == null) break;
+    if (typeof nextCursor !== 'string' || !nextCursor) {
+      throw historyProtocolError(`${method} returned an invalid nextCursor`);
+    }
+    if (seenCursors.has(nextCursor)) {
+      throw historyProtocolError(`${method} repeated pagination cursor ${nextCursor}`);
+    }
+    seenCursors.add(nextCursor);
+    cursor = nextCursor;
+  } while (true);
+
+  return data;
+}
+
+async function listCodexTurns(request, threadId, itemsView, options) {
+  return paginateCodexHistory(request, 'thread/turns/list', {
+    threadId,
+    limit: options.turnPageSize ?? CODEX_TURN_PAGE_SIZE,
+    sortDirection: 'asc',
+    itemsView,
+  }, options);
+}
+
+async function listCodexItems(request, threadId, options) {
+  return paginateCodexHistory(request, 'thread/items/list', {
+    threadId,
+    limit: options.itemPageSize ?? CODEX_ITEM_PAGE_SIZE,
+    sortDirection: 'asc',
+  }, options);
+}
+
+function mergeCodexItemsIntoTurns(turns, itemEntries) {
+  const hydratedTurns = turns.map((turn) => {
+    if (!turn || typeof turn !== 'object' || !turn.id) {
+      throw historyProtocolError('thread/turns/list returned a turn without an id');
+    }
+    return { ...turn, items: [], itemsView: 'full' };
+  });
+  const turnsById = new Map();
+  const seenItemIds = new Set();
+  for (const turn of hydratedTurns) {
+    const turnId = String(turn.id);
+    if (turnsById.has(turnId)) {
+      throw historyProtocolError(`thread/turns/list returned duplicate turn ${turnId}`);
+    }
+    turnsById.set(turnId, turn);
+  }
+
+  for (const entry of itemEntries) {
+    const turnId = entry?.turnId == null ? '' : String(entry.turnId);
+    const turn = turnsById.get(turnId);
+    const itemId = entry?.item?.id == null ? '' : String(entry.item.id);
+    if (!turnId || !turn || !itemId || !entry?.item || typeof entry.item !== 'object') {
+      throw historyProtocolError('thread/items/list returned an item without a matching turn');
+    }
+    if (seenItemIds.has(itemId)) {
+      throw historyProtocolError(`thread/items/list returned duplicate item ${itemId}`);
+    }
+    seenItemIds.add(itemId);
+    turn.items.push(entry.item);
+  }
+
+  return hydratedTurns;
+}
+
+export async function hydrateCodexThreadHistory(request, threadId, options = {}) {
+  if (typeof request !== 'function') throw new TypeError('request must be a function');
+  const targetThreadId = String(threadId || '');
+  if (!targetThreadId) throw new Error('No thread provided');
+
+  let turns;
+  try {
+    turns = await listCodexTurns(request, targetThreadId, 'notLoaded', options);
+  } catch (error) {
+    if (isCodexHistoryUnavailableBeforeFirstTurn(error)) {
+      return { turns: [], source: 'unmaterialized' };
+    }
+    throw error;
+  }
+
+  try {
+    const items = await listCodexItems(request, targetThreadId, options);
+    return {
+      turns: mergeCodexItemsIntoTurns(turns, items),
+      source: 'items-pagination',
+    };
+  } catch (error) {
+    if (!isCodexItemsPaginationUnsupported(error)) throw error;
+    return {
+      turns: await listCodexTurns(request, targetThreadId, 'full', options),
+      source: 'turns-full-fallback',
+    };
+  }
+}
+
+/** 0.160 removed rollback; revert excludes a named turn and all later turns. */
+export async function revertCodexThreadHistory(request, threadId, { numTurns = 1, beforeTurnId } = {}) {
+  if (!threadId) throw new Error('No thread provided');
+  if (!Number.isSafeInteger(numTurns) || numTurns < 1) throw new Error('Turn count must be a positive integer.');
+  const turns = beforeTurnId ? null : await listCodexTurns(request, threadId, 'notLoaded', {});
+  const target = beforeTurnId || turns?.[Math.max(0, turns.length - numTurns)]?.id;
+  if (typeof target !== 'string' || !target) throw new Error('No turn is available to revert.');
+  let result;
+  try {
+    result = await request('thread/revert', { threadId, beforeTurnId: target }, CODEX_HISTORY_PAGE_TIMEOUT_MS);
+  } catch (error) {
+    if (!isCodexUnsupportedMethod(error)) throw error;
+    // Cheap compatibility with legacy 0.153 histories; do not hide real failures.
+    const count = turns ? Math.min(numTurns, turns.length) : 0;
+    if (!count) throw error;
+    return request('thread/rollback', { threadId, numTurns: count }, CODEX_HISTORY_PAGE_TIMEOUT_MS);
+  }
+  const history = await hydrateCodexThreadHistory(request, threadId);
+  return { ...result, thread: { ...result.thread, turns: history.turns } };
+}

package/neural-interface/lib/codex-user-verification.js

@@ -0,0 +1,34 @@
+// The tab displays only these fields; challenge and proof remain transport-local.
+export function codexVerificationCardParams(params = {}) {
+  if (params.mode !== 'openai/userVerification') return params;
+  return { mode: params.mode, title: typeof params.title === 'string' ? params.title : '',
+    description: typeof params.description === 'string' ? params.description : '' };
+}
+
+/** Per-elicitation gate. Never log challenges or proofs. */
+export class CodexVerificationOperation {
+  constructor() { this.started = false; this.inFlight = false; this.resolved = false; this.rpcId = null; this.proof = null; }
+  start() {
+    if (this.started || this.resolved) throw new Error('Verification is already started or resolved.');
+    this.started = true; this.inFlight = true;
+  }
+  captureRpcId(id) { this.rpcId = id; }
+  complete(result) {
+    this.inFlight = false;
+    if (this.resolved) return false;
+    if (typeof result?.proof?.credentialId !== 'string' || typeof result?.proof?.signature !== 'string') throw new Error('Codex did not return a verification proof.');
+    this.proof = result.proof;
+    return true;
+  }
+  finish(action, content = null) {
+    if (this.resolved) return null;
+    if (!['accept', 'decline', 'cancel'].includes(action)) throw new Error('Invalid verification decision.');
+    if (action === 'accept' && (!this.proof || content?.credentialId !== this.proof.credentialId || content?.signature !== this.proof.signature)) throw new Error('Verify before accepting this request.');
+    this.resolved = true;
+    const cancelId = this.inFlight ? this.rpcId : null;
+    this.inFlight = false;
+    const result = { action, content: action === 'accept' ? this.proof : null };
+    this.proof = null;
+    return { cancelId, result };
+  }
+}

package/neural-interface/lib/codex-writer-lifecycle.js

@@ -0,0 +1,152 @@
+import { resolve } from 'node:path';
+
+const ACTIVE_WRITER_PATTERN = /already has an active writer/i;
+
+export function codexWriterKey(codexHome, threadId) {
+  if (!codexHome || !threadId) return '';
+  return `${resolve(String(codexHome))}\u0000${String(threadId)}`;
+}
+
+export function isCodexActiveWriterConflict(error) {
+  if (!error) return false;
+  const parts = [
+    typeof error === 'string' ? error : error.message,
+    typeof error === 'object' && error.data != null
+      ? (typeof error.data === 'string' ? error.data : JSON.stringify(error.data))
+      : '',
+  ];
+  return ACTIVE_WRITER_PATTERN.test(parts.filter(Boolean).join(' '));
+}
+
+export function codexWriterHasActiveWork({
+  activeTurnId = null,
+  pendingServerRequestCount = 0,
+  pendingRpcRequestCount = 0,
+  operationsInFlight = 0,
+} = {}) {
+  return !!activeTurnId
+    || Number(pendingServerRequestCount || 0) > 0
+    || Number(pendingRpcRequestCount || 0) > 0
+    || Number(operationsInFlight || 0) > 0;
+}
+
+export function shouldReleaseCodexWriter({
+  requested = false,
+  activeTurnId = null,
+  pendingServerRequestCount = 0,
+  pendingRpcRequestCount = 0,
+  operationsInFlight = 0,
+} = {}) {
+  return !!requested && !codexWriterHasActiveWork({
+    activeTurnId,
+    pendingServerRequestCount,
+    pendingRpcRequestCount,
+    operationsInFlight,
+  });
+}
+
+export function codexOrphanCollisionAction({
+  hasPrevious = false,
+  previousIdle = false,
+  currentIdle = false,
+} = {}) {
+  if (!hasPrevious) return 'register-current';
+  if (previousIdle) return 'replace-idle-previous';
+  if (currentIdle) return 'retire-idle-current';
+  return 'retain-both';
+}
+
+export function retireCodexChildProcess(proc, { forceAfterMs = 2000 } = {}) {
+  if (!proc || proc.exitCode != null || proc.signalCode != null) {
+    return Promise.resolve({ exited: true, forced: false });
+  }
+
+  return new Promise((resolveRetirement) => {
+    let settled = false;
+    let forceTimer = null;
+    let forced = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      if (forceTimer) clearTimeout(forceTimer);
+      proc.off?.('close', onClose);
+      resolveRetirement({ exited: true, forced });
+    };
+    const onClose = () => finish();
+    proc.once('close', onClose);
+    if (proc.exitCode != null || proc.signalCode != null) return finish();
+
+    try { proc.kill('SIGTERM'); } catch {}
+    forceTimer = setTimeout(() => {
+      if (proc.exitCode != null || proc.signalCode != null) return finish();
+      forced = true;
+      try { proc.kill('SIGKILL'); } catch {}
+    }, Math.max(0, Number(forceAfterMs) || 0));
+    forceTimer.unref?.();
+  });
+}
+
+export class CodexWriterRetirementRegistry {
+  constructor() {
+    this.entries = new Map();
+    this.recentlySettled = new Map();
+  }
+
+  register(codexHome, threadIds, retirement) {
+    const keys = [...new Set((threadIds || [])
+      .map((threadId) => codexWriterKey(codexHome, threadId))
+      .filter(Boolean))];
+    if (!keys.length) return Promise.resolve(retirement);
+
+    const tracked = Promise.resolve(retirement).catch(() => {});
+    for (const key of keys) {
+      let pending = this.entries.get(key);
+      if (!pending) {
+        pending = new Set();
+        this.entries.set(key, pending);
+      }
+      pending.add(tracked);
+    }
+
+    tracked.finally(() => {
+      const settledAt = Date.now();
+      for (const key of keys) {
+        const pending = this.entries.get(key);
+        pending?.delete(tracked);
+        if (!pending?.size) this.entries.delete(key);
+        this.recentlySettled.set(key, settledAt);
+      }
+    });
+    return tracked;
+  }
+
+  has(codexHome, threadId) {
+    return !!this.entries.get(codexWriterKey(codexHome, threadId))?.size;
+  }
+
+  settledRecently(codexHome, threadId, { withinMs = 2000 } = {}) {
+    const key = codexWriterKey(codexHome, threadId);
+    const settledAt = key ? this.recentlySettled.get(key) : null;
+    if (!settledAt) return false;
+    if (Date.now() - settledAt <= Math.max(0, Number(withinMs) || 0)) return true;
+    this.recentlySettled.delete(key);
+    return false;
+  }
+
+  async wait(codexHome, threadId, { timeoutMs = 5000 } = {}) {
+    const key = codexWriterKey(codexHome, threadId);
+    const pending = key ? [...(this.entries.get(key) || [])] : [];
+    if (!pending.length) return { waited: false, timedOut: false };
+
+    let timer = null;
+    const timeout = new Promise((resolveTimeout) => {
+      timer = setTimeout(() => resolveTimeout('timeout'), Math.max(0, Number(timeoutMs) || 0));
+    });
+    const outcome = await Promise.race([
+      Promise.allSettled(pending).then(() => 'settled'),
+      timeout,
+    ]);
+    if (timer) clearTimeout(timer);
+    return { waited: true, timedOut: outcome === 'timeout' };
+  }
+}