negotium 0.2.18 → 0.2.20

package/dist/{chunk-fc58cqry.js → chunk-g2kqfdwm.js}

@@ -132,11 +132,12 @@ function versionAtLeast(actualVersion, minimumVersion) {
   }
   return true;
 }
+var BROWSER_RS_VERSION_PROBE_TIMEOUT_MS = 15000;
 function browserRsMeetsMinimumVersion(candidate) {
   try {
     const output = execFileSync(candidate, ["--version"], {
       encoding: "utf8",
-      timeout: 2000,
+      timeout: BROWSER_RS_VERSION_PROBE_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     const match = output.match(/^browser-rs (\d+)\.(\d+)\.(\d+)$/);
@@ -761,11 +762,11 @@ function isPoisonedAssistantEntry(entry) {
 // ../../packages/core/src/agents/rollout/codex.ts
 import { randomBytes as randomBytes4 } from "crypto";
 import { existsSync as existsSync3, readFileSync as readFileSync4, realpathSync as realpathSync2, statSync as statSync2, unlinkSync as unlinkSync3 } from "fs";
-import { basename, dirname as dirname4, join as join4, resolve as resolve4 } from "path";
+import { basename, dirname as dirname5, join as join5, resolve as resolve5 } from "path";
 
 // ../../packages/core/src/agents/execution-host.ts
 import { AsyncLocalStorage } from "async_hooks";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname4 } from "path";
 
 // ../../packages/core/src/security/sensitive-path.ts
 import { realpathSync } from "fs";
@@ -1725,8 +1726,8 @@ function getMcpServersForQuery(opts) {
 }
 
 // ../../packages/core/src/storage/vault.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync4 } from "fs";
-import { join as join3 } from "path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync5 } from "fs";
+import { join as join4 } from "path";
 
 // ../../packages/core/src/storage/sqlite.ts
 var isBun = typeof process.versions.bun === "string";
@@ -1779,6 +1780,134 @@ if (isBun) {
   Database = NodeDatabase;
 }
 
+// ../../packages/core/src/storage/storage-host.ts
+import { mkdirSync as mkdirSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname3, join as join3, resolve as resolve4 } from "path";
+var STORAGE_HOST_STATE = Symbol.for("negotium.storage-host.state.v1");
+function storageState() {
+  const holder = globalThis;
+  const existing = holder[STORAGE_HOST_STATE];
+  if (existing)
+    return existing;
+  const created = {
+    configuredHost: {},
+    fallbackDatabase: null,
+    fallbackDatabasePath: null,
+    frames: [],
+    schemaInitializers: [],
+    initializedSchemas: new WeakMap,
+    initializingDatabases: new WeakSet
+  };
+  Object.defineProperty(holder, STORAGE_HOST_STATE, {
+    value: created,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  return created;
+}
+function envPath(name, fallback) {
+  const value = process.env[name]?.trim();
+  return resolve4(value || fallback);
+}
+function defaultStateDir() {
+  return envPath("NEGOTIUM_STATE_DIR", join3(homedir3(), ".negotium"));
+}
+function defaultDataDir() {
+  return envPath("NEGOTIUM_DATA_DIR", join3(defaultStateDir(), "data"));
+}
+function defaultSessionsDatabasePath() {
+  return envPath("SESSIONS_DB_PATH", join3(resolveStorageDataDir(), "sessions.db"));
+}
+var SQLITE_INIT_RETRY_MS = 25;
+var SQLITE_INIT_TIMEOUT_MS = 5000;
+var SQLITE_INIT_SLEEP = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function isSqliteBusy(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /database is (?:locked|busy)|SQLITE_(?:BUSY|LOCKED)/i.test(message);
+}
+function execWithBusyRetry(database, sql, timeoutMs = SQLITE_INIT_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    try {
+      database.exec(sql);
+      return;
+    } catch (error) {
+      if (!isSqliteBusy(error) || Date.now() >= deadline)
+        throw error;
+      Atomics.wait(SQLITE_INIT_SLEEP, 0, 0, Math.min(SQLITE_INIT_RETRY_MS, deadline - Date.now()));
+    }
+  }
+}
+function initializeDatabase(database) {
+  database.exec("PRAGMA busy_timeout = 5000");
+  execWithBusyRetry(database, "PRAGMA journal_mode = WAL");
+  database.exec("PRAGMA foreign_keys = ON");
+  database.exec("PRAGMA wal_autocheckpoint = 1000");
+  try {
+    database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  } catch {}
+}
+function defaultDatabase() {
+  const path = defaultSessionsDatabasePath();
+  const state = storageState();
+  if (state.fallbackDatabase && state.fallbackDatabasePath === path)
+    return state.fallbackDatabase;
+  if (state.fallbackDatabase)
+    state.fallbackDatabase.close();
+  mkdirSync4(dirname3(path), { recursive: true });
+  state.fallbackDatabase = new Database(path, { create: true });
+  state.fallbackDatabasePath = path;
+  initializeDatabase(state.fallbackDatabase);
+  return state.fallbackDatabase;
+}
+function resolveStorageDatabase() {
+  return storageState().configuredHost.database ?? defaultDatabase();
+}
+function resolveStorageDataDir() {
+  return storageState().configuredHost.dataDir ?? defaultDataDir();
+}
+function ensureStorageSchemas(database = resolveStorageDatabase()) {
+  const state = storageState();
+  if (state.initializingDatabases.has(database))
+    return;
+  let initialized = state.initializedSchemas.get(database);
+  if (!initialized) {
+    initialized = new Set;
+    state.initializedSchemas.set(database, initialized);
+  }
+  state.initializingDatabases.add(database);
+  try {
+    for (const entry of state.schemaInitializers) {
+      if (initialized.has(entry.initialize))
+        continue;
+      initialized.add(entry.initialize);
+      try {
+        entry.initialize(database);
+      } catch (error) {
+        initialized.delete(entry.initialize);
+        throw error;
+      }
+    }
+  } finally {
+    state.initializingDatabases.delete(database);
+  }
+}
+var internalStorageDatabase = new Proxy({}, {
+  get(_target, property) {
+    const database = resolveStorageDatabase();
+    ensureStorageSchemas(database);
+    const value = Reflect.get(database, property, database);
+    return typeof value === "function" ? value.bind(database) : value;
+  },
+  set(_target, property, value) {
+    const database = resolveStorageDatabase();
+    ensureStorageSchemas(database);
+    return Reflect.set(database, property, value, database);
+  }
+});
+
 // ../../packages/core/src/storage/vault-crypto-core.ts
 import { createCipheriv, createDecipheriv, createHash as createHash2, randomBytes as randomBytes3 } from "crypto";
 var ENVELOPE_PREFIX = "otium-vault:v1:";
@@ -1868,17 +1997,18 @@ function initializeVaultDatabase(database) {
   }
 }
 function openVaultDatabase(dataDir) {
-  const vaultDir = join3(dataDir, "vault");
-  const path = join3(vaultDir, "vault.db");
-  mkdirSync4(vaultDir, { recursive: true, mode: 448 });
+  const vaultDir = join4(dataDir, "vault");
+  const path = join4(vaultDir, "vault.db");
+  mkdirSync5(vaultDir, { recursive: true, mode: 448 });
   const database = new Database(path, { create: true });
   chmodSync2(path, 384);
   initializeVaultDatabase(database);
   return database;
 }
 function activeVaultDatabase() {
-  if (!vaultDb)
-    vaultDb = openVaultDatabase(DATA_DIR);
+  if (!vaultDb) {
+    vaultDb = openVaultDatabase(resolveStorageDataDir());
+  }
   return vaultDb;
 }
 var VAULT_VALUE_MAX_BYTES = 64 * 1024;
@@ -1991,18 +2121,18 @@ function hostedCodexAuthFilePath() {
   return activeHost().codexAuthFilePath();
 }
 function hostedCodexHomePath() {
-  return dirname3(hostedCodexAuthFilePath());
+  return dirname4(hostedCodexAuthFilePath());
 }
 
 // ../../packages/core/src/agents/rollout/codex.ts
 function codexSessionsDir() {
-  return join4(hostedCodexHomePath(), "sessions");
+  return join5(hostedCodexHomePath(), "sessions");
 }
 var _shellCache = null;
 function loadCodexShell() {
   if (_shellCache)
     return _shellCache;
-  const raw = readFileSync4(join4(FIXTURES_DIR, "codex-shell.jsonl"), "utf8");
+  const raw = readFileSync4(join5(FIXTURES_DIR, "codex-shell.jsonl"), "utf8");
   const lines = parseJsonlText(raw);
   if (lines.length < 5) {
     throw new Error(`loadCodexShell: expected >=5 entries in codex-shell.jsonl, got ${lines.length}`);
@@ -2069,16 +2199,16 @@ function codexRolloutPath(threadId, fallback) {
   const hh = String(createdAt.getHours()).padStart(2, "0");
   const min = String(createdAt.getMinutes()).padStart(2, "0");
   const ss = String(createdAt.getSeconds()).padStart(2, "0");
-  const dir = join4(codexSessionsDir(), yyyy, mm, dd);
-  return join4(dir, `rollout-${yyyy}-${mm}-${dd}T${hh}-${min}-${ss}-${threadId}.jsonl`);
+  const dir = join5(codexSessionsDir(), yyyy, mm, dd);
+  return join5(dir, `rollout-${yyyy}-${mm}-${dd}T${hh}-${min}-${ss}-${threadId}.jsonl`);
 }
 function canonicalFilePath(path) {
-  const absolute = resolve4(path);
+  const absolute = resolve5(path);
   try {
     return realpathSync2(absolute);
   } catch {
     try {
-      return join4(realpathSync2(dirname4(absolute)), basename(absolute));
+      return join5(realpathSync2(dirname5(absolute)), basename(absolute));
     } catch {
       return absolute;
     }
@@ -2267,19 +2397,19 @@ function latestCodexRolloutPath(threadId) {
   try {
     if (buckets) {
       for (const bucket of buckets) {
-        const dir = join4(sessionsDir, bucket);
+        const dir = join5(sessionsDir, bucket);
         if (!existsSync3(dir))
           continue;
         const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
         for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-          candidates.push(join4(dir, rel));
+          candidates.push(join5(dir, rel));
         }
       }
     }
     if (candidates.length === 0) {
       const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
       for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
-        candidates.push(join4(sessionsDir, rel));
+        candidates.push(join5(sessionsDir, rel));
       }
     }
     return candidates.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
@@ -2400,13 +2530,13 @@ function sweepPriorRolloutsForThread(threadId) {
     return;
   }
   for (const bucket of buckets) {
-    const dir = join4(sessionsDir, bucket);
+    const dir = join5(sessionsDir, bucket);
     if (!existsSync3(dir))
       continue;
     try {
       const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
       for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-        const fullPath = join4(dir, rel);
+        const fullPath = join5(dir, rel);
         try {
           unlinkSync3(fullPath);
         } catch (e) {
@@ -2424,7 +2554,7 @@ function sweepPriorRolloutsFullTree(threadId, sessionsDir) {
   try {
     const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
     for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
-      const fullPath = join4(sessionsDir, rel);
+      const fullPath = join5(sessionsDir, rel);
       try {
         unlinkSync3(fullPath);
       } catch (e) {
@@ -2483,4 +2613,4 @@ function formatDateBucket(d) {
 
 export { __require, logger, CLAUDE_EFFORT_VALUES, CODEX_EFFORT_VALUES, MAESTRO_EFFORT_VALUES, MODEL_SONNET, MODEL_OPUS, MODEL_FABLE, configureRolloutHost, assertUuidLike, ensureCwdExists, extractChatPairs, encodeClaudeCwd, writeClaudeRollout, repairPoisonedRollout, hostedCodexHomePath, extractLatestCodexPatchPreview, extractCodexPatchCallIds, readCodexPatchCallIds, readLatestCodexPatchPreview, extractLatestCodexContextUsage, readLatestCodexContextUsage, migrateCodexRolloutNativeMultiAgentMetadata, latestCodexRolloutPath, writeCodexRollout, decodeUuidV7Timestamp };
 
-//# debugId=3244605FC4A7370364756E2164756E21
+//# debugId=3BC854CFD07F1E6C64756E2164756E21