negotium 0.2.19 → 0.2.20

package/dist/hosted-agent.js

@@ -138,11 +138,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+)$/);
@@ -451,7 +452,7 @@ function deepMapStrings(value, fn) {
 
 // ../../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";
@@ -1395,8 +1396,8 @@ function getMcpServersForQuery(opts) {
 }
 
 // ../../packages/core/src/storage/vault.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync3 } from "fs";
-import { join as join2 } from "path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync4 } from "fs";
+import { join as join3 } from "path";
 
 // ../../packages/core/src/storage/sqlite.ts
 var isBun = typeof process.versions.bun === "string";
@@ -1449,6 +1450,134 @@ if (isBun) {
   Database = NodeDatabase;
 }
 
+// ../../packages/core/src/storage/storage-host.ts
+import { mkdirSync as mkdirSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, join as join2, 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", join2(homedir2(), ".negotium"));
+}
+function defaultDataDir() {
+  return envPath("NEGOTIUM_DATA_DIR", join2(defaultStateDir(), "data"));
+}
+function defaultSessionsDatabasePath() {
+  return envPath("SESSIONS_DB_PATH", join2(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();
+  mkdirSync3(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:";
@@ -1538,17 +1667,18 @@ function initializeVaultDatabase(database) {
   }
 }
 function openVaultDatabase(dataDir) {
-  const vaultDir = join2(dataDir, "vault");
-  const path = join2(vaultDir, "vault.db");
-  mkdirSync3(vaultDir, { recursive: true, mode: 448 });
+  const vaultDir = join3(dataDir, "vault");
+  const path = join3(vaultDir, "vault.db");
+  mkdirSync4(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;
@@ -1704,7 +1834,7 @@ function hostedCodexAuthFilePath() {
   return activeHost().codexAuthFilePath();
 }
 function hostedCodexHomePath() {
-  return dirname3(hostedCodexAuthFilePath());
+  return dirname4(hostedCodexAuthFilePath());
 }
 
 // ../../packages/core/src/media/file-events.ts
@@ -2214,8 +2344,8 @@ async function* claudeProvider(opts) {
 // ../../packages/core/src/agents/codex-provider.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync6, realpathSync as realpathSync3, statSync as statSync3 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname6, isAbsolute, join as join5, relative, resolve as resolve5 } from "path";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname7, isAbsolute, join as join6, relative, resolve as resolve6 } from "path";
 import { Codex } from "@openai/codex-sdk";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
@@ -2234,10 +2364,10 @@ import {
 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { tmpdir } from "os";
-import { dirname as dirname4, join as join3 } from "path";
+import { dirname as dirname5, join as join4 } from "path";
 
 // ../../packages/core/src/version.ts
-var NEGOTIUM_VERSION = "0.2.19";
+var NEGOTIUM_VERSION = "0.2.20";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
 var moduleRequire = createRequire2(import.meta.url);
@@ -2256,7 +2386,7 @@ var SAFE_BUNDLED_CODEX_VERSION = BUNDLED_CODEX_VERSION.replace(/[^a-zA-Z0-9._-]/
 var NEGOTIUM_MODEL_CACHE = `negotium-models-cache-${SAFE_BUNDLED_CODEX_VERSION}.json`;
 var NEGOTIUM_MODEL_CATALOG = `negotium-model-catalog-${SAFE_BUNDLED_CODEX_VERSION}.json`;
 function codexCliScriptPath() {
-  return join3(dirname4(bundledCodexPackagePath), "bin", "codex.js");
+  return join4(dirname5(bundledCodexPackagePath), "bin", "codex.js");
 }
 function parseCodexModelCache(contents, sourcePath) {
   let parsed;
@@ -2297,14 +2427,14 @@ function writePrivateFileAtomic(path, contents) {
   }
 }
 function bundledCodexModelCachePath(authFilePath) {
-  return join3(dirname4(authFilePath), NEGOTIUM_MODEL_CACHE);
+  return join4(dirname5(authFilePath), NEGOTIUM_MODEL_CACHE);
 }
 async function bootstrapCodexModelCache(codexHome, cachePath) {
   const child = spawn3(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
     env: { ...process.env, CODEX_HOME: codexHome },
     stdio: ["pipe", "pipe", "pipe"]
   });
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     let settled = false;
     let stdoutBuffer = "";
     let stderr = "";
@@ -2323,7 +2453,7 @@ async function bootstrapCodexModelCache(codexHome, cachePath) {
       else if (!existsSync3(cachePath))
         reject(new Error("Codex did not create its model cache"));
       else
-        resolve4();
+        resolve5();
     };
     const send = (message) => {
       child.stdin.write(`${JSON.stringify(message)}
@@ -2382,16 +2512,16 @@ async function bootstrapCodexModelCache(codexHome, cachePath) {
   });
 }
 async function bootstrapIsolatedCodexModelCache(authFilePath, bootstrap) {
-  const sourceHome = dirname4(authFilePath);
-  const isolatedHome = mkdtempSync(join3(tmpdir(), "negotium-codex-models-"));
-  const isolatedCachePath = join3(isolatedHome, "models_cache.json");
+  const sourceHome = dirname5(authFilePath);
+  const isolatedHome = mkdtempSync(join4(tmpdir(), "negotium-codex-models-"));
+  const isolatedCachePath = join4(isolatedHome, "models_cache.json");
   try {
-    const isolatedAuthPath = join3(isolatedHome, "auth.json");
+    const isolatedAuthPath = join4(isolatedHome, "auth.json");
     copyFileSync(authFilePath, isolatedAuthPath);
     chmodSync3(isolatedAuthPath, 384);
-    const sourceConfigPath = join3(sourceHome, "config.toml");
+    const sourceConfigPath = join4(sourceHome, "config.toml");
     if (existsSync3(sourceConfigPath)) {
-      const isolatedConfigPath = join3(isolatedHome, "config.toml");
+      const isolatedConfigPath = join4(isolatedHome, "config.toml");
       copyFileSync(sourceConfigPath, isolatedConfigPath);
       chmodSync3(isolatedConfigPath, 384);
     }
@@ -2402,7 +2532,7 @@ async function bootstrapIsolatedCodexModelCache(authFilePath, bootstrap) {
   }
 }
 async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexModelCache) {
-  const codexHome = dirname4(authFilePath);
+  const codexHome = dirname5(authFilePath);
   const configuredCachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE;
   if (configuredCachePath) {
     if (!existsSync3(configuredCachePath)) {
@@ -2412,7 +2542,7 @@ async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexMod
     return configuredCachePath;
   }
   const bundledCachePath = bundledCodexModelCachePath(authFilePath);
-  const sharedCachePath = join3(codexHome, "models_cache.json");
+  const sharedCachePath = join4(codexHome, "models_cache.json");
   if (existsSync3(sharedCachePath)) {
     try {
       const shared = readCompatibleCodexModelCache(sharedCachePath);
@@ -2431,8 +2561,8 @@ async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexMod
   return bundledCachePath;
 }
 function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath, sourcePath) {
-  const codexHome = dirname4(authFilePath);
-  const outputPath = join3(codexHome, NEGOTIUM_MODEL_CATALOG);
+  const codexHome = dirname5(authFilePath);
+  const outputPath = join4(codexHome, NEGOTIUM_MODEL_CATALOG);
   const parsed = readCodexModelCache(sourcePath).parsed;
   const models = parsed.models.map((model, index) => {
     if (!model || typeof model !== "object" || Array.isArray(model)) {
@@ -2502,12 +2632,12 @@ function createCodexTreeManager(host, options = {}) {
     const previous = spawnChain;
     let release;
     let released = false;
-    spawnChain = new Promise((resolve4) => {
+    spawnChain = new Promise((resolve5) => {
       release = () => {
         if (released)
           return;
         released = true;
-        resolve4();
+        resolve5();
       };
     });
     await previous;
@@ -2614,7 +2744,7 @@ function createCodexTreeManager(host, options = {}) {
       return;
     const deadline = Date.now() + Math.max(0, graceMs);
     while (Date.now() < deadline && hasSurvivors(plan.targets)) {
-      await new Promise((resolve4) => setTimeout(resolve4, Math.min(100, Math.max(1, deadline - Date.now()))));
+      await new Promise((resolve5) => setTimeout(resolve5, Math.min(100, Math.max(1, deadline - Date.now()))));
     }
     killStragglers(plan);
   }
@@ -2667,17 +2797,17 @@ var killOwnedCodexTreesForShutdown = manager.killOwnedTreesForShutdown;
 
 // ../../packages/core/src/agents/rollout/codex.ts
 import { existsSync as existsSync4, readFileSync as readFileSync5, realpathSync as realpathSync2, statSync as statSync2, unlinkSync as unlinkSync4 } from "fs";
-import { basename, dirname as dirname5, join as join4, resolve as resolve4 } from "path";
+import { basename, dirname as dirname6, join as join5, resolve as resolve5 } from "path";
 function codexSessionsDir() {
-  return join4(hostedCodexHomePath(), "sessions");
+  return join5(hostedCodexHomePath(), "sessions");
 }
 function canonicalFilePath(path) {
-  const absolute = resolve4(path);
+  const absolute = resolve5(path);
   try {
     return realpathSync2(absolute);
   } catch {
     try {
-      return join4(realpathSync2(dirname5(absolute)), basename(absolute));
+      return join5(realpathSync2(dirname6(absolute)), basename(absolute));
     } catch {
       return absolute;
     }
@@ -2907,19 +3037,19 @@ function latestCodexRolloutPath(threadId) {
   try {
     if (buckets) {
       for (const bucket of buckets) {
-        const dir = join4(sessionsDir, bucket);
+        const dir = join5(sessionsDir, bucket);
         if (!existsSync4(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];
@@ -3071,7 +3201,7 @@ function codexMcpServerName(name) {
   return CODEX_MCP_SERVER_NAME_OVERRIDES[name] ?? name;
 }
 function globalCodexMcpServerNames(authFilePath) {
-  const configPath = join5(dirname6(authFilePath), "config.toml");
+  const configPath = join6(dirname7(authFilePath), "config.toml");
   if (!existsSync5(configPath))
     return [];
   try {
@@ -3170,9 +3300,9 @@ var CODEX_DIFF_BASELINE_FILE_LIMIT = 200;
 var CODEX_DIFF_BASELINE_BYTE_LIMIT = 16 * 1024 * 1024;
 function canonicalPath(path) {
   try {
-    return realpathSync3(resolve5(path));
+    return realpathSync3(resolve6(path));
   } catch {
-    return resolve5(path);
+    return resolve6(path);
   }
 }
 function textFile(path, maxBytes = CODEX_DIFF_FILE_LIMIT) {
@@ -3216,7 +3346,7 @@ class CodexFilePreviewTracker {
       const code = record.slice(0, 2);
       const path = record.slice(3);
       const remainingBytes = CODEX_DIFF_BASELINE_BYTE_LIMIT - loadedBytes;
-      const content = loadedFiles < CODEX_DIFF_BASELINE_FILE_LIMIT && remainingBytes > 0 ? textFile(resolve5(this.#root, path), remainingBytes) : undefined;
+      const content = loadedFiles < CODEX_DIFF_BASELINE_FILE_LIMIT && remainingBytes > 0 ? textFile(resolve6(this.#root, path), remainingBytes) : undefined;
       this.#baseline.set(path, content);
       if (typeof content === "string") {
         loadedFiles += 1;
@@ -3229,7 +3359,7 @@ class CodexFilePreviewTracker {
   preview(path, succeeded) {
     if (!this.#root || !this.#baselineAvailable || !succeeded)
       return {};
-    const absolute = canonicalPath(isAbsolute(path) ? path : resolve5(this.#cwd, path));
+    const absolute = canonicalPath(isAbsolute(path) ? path : resolve6(this.#cwd, path));
     const relativePath = relative(this.#root, absolute);
     if (!relativePath || relativePath.startsWith("..") || isAbsolute(relativePath))
       return {};
@@ -3264,7 +3394,7 @@ class CodexFilePreviewTracker {
   }
 }
 async function fileChangeEvents(item, previews, cwd, threadId, consumedPatchCallIds) {
-  const expectedPaths = item.changes.map((change) => isAbsolute(change.path) ? change.path : resolve5(cwd, change.path));
+  const expectedPaths = item.changes.map((change) => isAbsolute(change.path) ? change.path : resolve6(cwd, change.path));
   let nativePreview;
   if (threadId && item.status === "completed") {
     await new Promise((resolveDelay) => setTimeout(resolveDelay, 20));
@@ -3433,8 +3563,8 @@ async function* codexProvider(opts) {
     mcpServerCount: Object.keys(codexMcpServers).length
   }, "codexProvider: starting turn");
   const hostedCodexHome = hostedCodexHomePath();
-  const inheritedCodexHome = process.env.CODEX_HOME || join5(homedir2(), ".codex");
-  const codexEnvironment = scopedBrowserCapability || resolve5(hostedCodexHome) !== resolve5(inheritedCodexHome) ? {
+  const inheritedCodexHome = process.env.CODEX_HOME || join6(homedir3(), ".codex");
+  const codexEnvironment = scopedBrowserCapability || resolve6(hostedCodexHome) !== resolve6(inheritedCodexHome) ? {
     ...Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string")),
     CODEX_HOME: hostedCodexHome,
     ...scopedBrowserCapability ? { [CODEX_BROWSER_CAPABILITY_ENV]: scopedBrowserCapability } : {}
@@ -3712,7 +3842,7 @@ async function* codexProvider(opts) {
 process.env.MAESTRO_SDK_SILENT_BOOTSTRAP ??= "1";
 
 // ../../packages/core/src/agents/maestro-provider.ts
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 import { maestroProvider as sdkMaestroProvider, setMcpResolver } from "maestro-agent-sdk";
 var MAESTRO_DEFAULT_MAX_TOKENS = 32768;
 var PROVIDER_ASK_USER_TOOL = "AskUserQuestion";
@@ -3811,7 +3941,7 @@ function buildProviderOwnedToolBlockHook() {
     }
   };
 }
-var MAESTRO_TOOL_OUTPUT_DIR = resolve6(RUN_DIR, "maestro-tool-outputs");
+var MAESTRO_TOOL_OUTPUT_DIR = resolve7(RUN_DIR, "maestro-tool-outputs");
 function buildMaestroToolResultTruncation(opts) {
   if (opts.toolResultTruncation)
     return opts.toolResultTruncation;
@@ -3846,16 +3976,16 @@ function maestroProvider(opts) {
 // ../../packages/core/src/agents/claude-runtime-inspection.ts
 import { readFileSync as readFileSync7 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import { dirname as dirname7, join as join6 } from "path";
+import { dirname as dirname8, join as join7 } from "path";
 var cached;
 function inspectBundledClaudeRuntime() {
   if (cached)
     return cached;
   try {
     const require2 = createRequire3(import.meta.url);
-    const sdkDir = dirname7(require2.resolve("@anthropic-ai/claude-agent-sdk"));
-    const sdkPackage = JSON.parse(readFileSync7(join6(sdkDir, "package.json"), "utf8"));
-    const manifest = JSON.parse(readFileSync7(join6(sdkDir, "manifest.json"), "utf8"));
+    const sdkDir = dirname8(require2.resolve("@anthropic-ai/claude-agent-sdk"));
+    const sdkPackage = JSON.parse(readFileSync7(join7(sdkDir, "package.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync7(join7(sdkDir, "manifest.json"), "utf8"));
     const sdkVersion = typeof sdkPackage.version === "string" ? sdkPackage.version : "";
     const claudeCodeVersion = typeof manifest.version === "string" ? manifest.version : "";
     if (!sdkVersion || !claudeCodeVersion) {
@@ -3928,4 +4058,4 @@ export {
   buildClaudeDisallowedTools
 };
 
-//# debugId=AAFB3B393DF7264D64756E2164756E21
+//# debugId=A4049493D1A9D50864756E2164756E21