negotium 0.2.2 → 0.2.4

package/dist/registry.js

@@ -11,10 +11,12 @@ import {
   encodeClaudeCwd,
   ensureCwdExists,
   extractChatPairs,
+  hostedCodexHomePath,
+  latestCodexRolloutPath,
   logger,
   writeClaudeRollout,
   writeCodexRollout
-} from "./chunk-kc5kmr95.js";
+} from "./chunk-1s9ryz8g.js";
 
 // ../../packages/core/src/agents/claude-registry.ts
 import { existsSync, mkdirSync, readdirSync, renameSync, unlinkSync } from "fs";
@@ -98,209 +100,155 @@ var claudeRegistryOperations = {
 
 // ../../packages/core/src/agents/codex-registry.ts
 import { existsSync as existsSync3, unlinkSync as unlinkSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 
-// ../../packages/core/src/storage/conversations.ts
+// ../../packages/core/src/agents/codex-app-server.ts
+import { spawn } from "child_process";
+
+// ../../packages/core/src/agents/codex-native-multi-agent.ts
 import {
+  chmodSync,
+  copyFileSync,
   existsSync as existsSync2,
-  mkdirSync as mkdirSync3,
+  mkdtempSync,
   readFileSync,
   renameSync as renameSync2,
+  rmSync,
   unlinkSync as unlinkSync2,
   writeFileSync
 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-
-// ../../packages/core/src/security/sanitize.ts
-function sanitizeTopicName(name, lowercase = false) {
-  const safe = name.replace(/[^a-zA-Z0-9\uAC00-\uD7A3_-]/g, "_") || "_";
-  return lowercase ? safe.toLowerCase() : safe;
-}
-
-// ../../packages/core/src/storage/storage-host.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname, join as join2, resolve } from "path";
+import { createRequire } from "module";
+import { dirname, join as join2 } from "path";
 
-// ../../packages/core/src/storage/sqlite.ts
-var isBun = typeof process.versions.bun === "string";
-var Database;
-if (isBun) {
-  ({ Database } = await import("bun:sqlite"));
-} else {
-  const nodeSqliteSpecifier = ["node", "sqlite"].join(":");
-  const { DatabaseSync } = await import(nodeSqliteSpecifier);
+// ../../packages/core/src/version.ts
+var NEGOTIUM_VERSION = "0.2.4";
 
-  class NodeDatabase {
-    #db;
-    constructor(path, options = {}) {
-      this.#db = options.readonly ? new DatabaseSync(path, { readOnly: true }) : new DatabaseSync(path);
-    }
-    query(sql) {
-      return this.#db.prepare(sql);
-    }
-    prepare(sql) {
-      return this.#db.prepare(sql);
-    }
-    exec(sql) {
-      this.#db.exec(sql);
-    }
-    run(sql, ...params) {
-      return this.#db.prepare(sql).run(...params);
-    }
-    transaction(fn) {
-      const run = (begin) => (...args) => {
-        this.#db.exec(begin);
-        try {
-          const result = fn(...args);
-          this.#db.exec("COMMIT");
-          return result;
-        } catch (err) {
-          this.#db.exec("ROLLBACK");
-          throw err;
-        }
-      };
-      const tx = run("BEGIN");
-      tx.deferred = run("BEGIN DEFERRED");
-      tx.immediate = run("BEGIN IMMEDIATE");
-      tx.exclusive = run("BEGIN EXCLUSIVE");
-      return tx;
-    }
-    close() {
-      this.#db.close();
-    }
+// ../../packages/core/src/agents/codex-native-multi-agent.ts
+var moduleRequire = createRequire(import.meta.url);
+var codexSdkPackagePath = moduleRequire.resolve("@openai/codex-sdk/package.json");
+var codexSdkRequire = createRequire(codexSdkPackagePath);
+var bundledCodexPackagePath = codexSdkRequire.resolve("@openai/codex/package.json");
+function readPackageVersion(packageJsonPath) {
+  const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  if (typeof parsed.version !== "string" || !parsed.version.trim()) {
+    throw new Error(`Codex package has no valid version: ${packageJsonPath}`);
   }
-  Database = NodeDatabase;
-}
-
-// ../../packages/core/src/storage/storage-host.ts
-var configuredHost = {};
-var fallbackDatabase = null;
-var fallbackDatabasePath = null;
-var schemaInitializers = [];
-var initializedSchemas = new WeakMap;
-var initializingDatabases = new WeakSet;
-function envPath(name, fallback) {
-  const value = process.env[name]?.trim();
-  return resolve(value || fallback);
+  return parsed.version;
 }
-function defaultStateDir() {
-  return envPath("NEGOTIUM_STATE_DIR", join2(homedir2(), ".negotium"));
+var BUNDLED_CODEX_VERSION = readPackageVersion(bundledCodexPackagePath);
+var SAFE_BUNDLED_CODEX_VERSION = BUNDLED_CODEX_VERSION.replace(/[^a-zA-Z0-9._-]/g, "_");
+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 join2(dirname(bundledCodexPackagePath), "bin", "codex.js");
 }
-function defaultDataDir() {
-  return envPath("NEGOTIUM_DATA_DIR", join2(defaultStateDir(), "data"));
-}
-function defaultSessionsDatabasePath() {
-  return envPath("SESSIONS_DB_PATH", join2(resolveStorageDataDir(), "sessions.db"));
-}
-function initializeDatabase(database) {
-  database.exec("PRAGMA busy_timeout = 5000");
-  database.exec("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();
-  if (fallbackDatabase && fallbackDatabasePath === path)
-    return fallbackDatabase;
-  if (fallbackDatabase)
-    fallbackDatabase.close();
-  mkdirSync2(dirname(path), { recursive: true });
-  fallbackDatabase = new Database(path, { create: true });
-  fallbackDatabasePath = path;
-  initializeDatabase(fallbackDatabase);
-  return fallbackDatabase;
-}
-function resolveStorageDatabase() {
-  return configuredHost.database ?? defaultDatabase();
-}
-function resolveStorageDataDir() {
-  return configuredHost.dataDir ?? defaultDataDir();
-}
-function ensureStorageSchemas(database = resolveStorageDatabase()) {
-  if (initializingDatabases.has(database))
-    return;
-  let initialized = initializedSchemas.get(database);
-  if (!initialized) {
-    initialized = new Set;
-    initializedSchemas.set(database, initialized);
-  }
-  initializingDatabases.add(database);
-  try {
-    for (const entry of schemaInitializers) {
-      if (initialized.has(entry.initialize))
-        continue;
-      initialized.add(entry.initialize);
-      try {
-        entry.initialize(database);
-      } catch (error) {
-        initialized.delete(entry.initialize);
-        throw error;
-      }
-    }
-  } finally {
-    initializingDatabases.delete(database);
-  }
+
+// ../../packages/core/src/agents/codex-app-server.ts
+function createCodexAppServerForker(host) {
+  return async (parentThreadId) => {
+    const child = host.spawnServer();
+    return await new Promise((resolve, reject) => {
+      let settled = false;
+      let stdoutBuffer = "";
+      let stderr = "";
+      const timer = setTimeout(() => finish(new Error("Codex thread fork timed out")), host.timeoutMs);
+      const finish = (error, result) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        try {
+          child.stdin.end();
+          child.kill();
+        } catch {}
+        if (error)
+          reject(error);
+        else if (result)
+          resolve(result);
+        else
+          reject(new Error("Codex thread fork returned no result"));
+      };
+      const send = (message) => {
+        child.stdin.write(`${JSON.stringify(message)}
+`);
+      };
+      child.stderr.on("data", (chunk) => {
+        if (stderr.length < 8192)
+          stderr += String(chunk);
+      });
+      child.on("error", (error) => finish(error));
+      child.on("exit", (code, signal) => {
+        if (settled)
+          return;
+        const detail = signal ? `signal ${signal}` : `code ${code ?? 1}`;
+        finish(new Error(`Codex app server exited with ${detail}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+      });
+      child.stdout.on("data", (chunk) => {
+        stdoutBuffer += String(chunk);
+        for (;; ) {
+          const newline = stdoutBuffer.indexOf(`
+`);
+          if (newline < 0)
+            break;
+          const line = stdoutBuffer.slice(0, newline);
+          stdoutBuffer = stdoutBuffer.slice(newline + 1);
+          let message;
+          try {
+            message = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (message.id === 1) {
+            if (message.error) {
+              finish(new Error(String(message.error.message || "Codex initialization failed")));
+              return;
+            }
+            send({ method: "initialized" });
+            send({ id: 2, method: "thread/fork", params: { threadId: parentThreadId } });
+            continue;
+          }
+          if (message.id !== 2)
+            continue;
+          if (message.error) {
+            finish(new Error(String(message.error.message || "Codex thread fork failed")));
+            return;
+          }
+          const forkId = message.result?.thread?.id;
+          if (typeof forkId !== "string" || !forkId) {
+            finish(new Error("Codex thread fork returned no thread id"));
+            return;
+          }
+          const rolloutPath = host.findRolloutPath(forkId);
+          if (!rolloutPath) {
+            finish(new Error(`Codex thread fork rollout was not found for ${forkId}`));
+            return;
+          }
+          finish(undefined, { forkId, rolloutPath });
+          return;
+        }
+      });
+      send({
+        id: 1,
+        method: "initialize",
+        params: {
+          clientInfo: { name: "negotium", version: NEGOTIUM_VERSION }
+        }
+      });
+    });
+  };
 }
-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;
+var forkCodexThread = createCodexAppServerForker({
+  spawnServer() {
+    return spawn(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
+      env: { ...process.env, CODEX_HOME: hostedCodexHomePath() },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
   },
-  set(_target, property, value) {
-    const database = resolveStorageDatabase();
-    ensureStorageSchemas(database);
-    return Reflect.set(database, property, value, database);
-  }
+  findRolloutPath: latestCodexRolloutPath,
+  timeoutMs: 15000
 });
-
-// ../../packages/core/src/storage/conversations.ts
-function conversationDir(_userId) {
-  return join3(resolveStorageDataDir(), "conversations");
-}
-function topicFilename(topicName) {
-  const t = sanitizeTopicName(topicName, true);
-  return `${t}.jsonl`;
-}
-function getConversationPath(userId, topicName) {
-  return join3(conversationDir(userId), topicFilename(topicName));
-}
-function getActiveConversationPath(userId, topicName) {
-  const rawPath = getConversationPath(userId, topicName);
-  return rawPath.endsWith(".jsonl") ? `${rawPath.slice(0, -".jsonl".length)}.active.jsonl` : `${rawPath}.active`;
-}
-function readConversationPath(path) {
-  const out = [];
-  if (!existsSync2(path))
-    return out;
-  let raw;
-  try {
-    raw = readFileSync(path, "utf8");
-  } catch (err) {
-    logger.warn({ err, path }, "readConversation: read failed");
-    return out;
-  }
-  for (const line of raw.split(`
-`)) {
-    if (!line.trim())
-      continue;
-    try {
-      out.push(JSON.parse(line));
-    } catch (err) {
-      logger.warn({ err, line: line.slice(0, 200) }, "readConversation: malformed JSONL line skipped");
-    }
-  }
-  return out;
-}
-function readConversation(userId, topicName) {
-  const activePath = getActiveConversationPath(userId, topicName);
-  return readConversationPath(existsSync2(activePath) ? activePath : getConversationPath(userId, topicName));
+async function forkCodexSession(parentThreadId) {
+  return await forkCodexThread(parentThreadId);
 }
 
 // ../../packages/core/src/agents/codex-registry.ts
@@ -333,20 +281,13 @@ var codexRegistryOperations = {
     });
     return { sessionId: threadId, rolloutPath };
   },
-  async forkSession({ cwd, userId, topicName, model, effort }) {
-    const entries = readConversation(userId, topicName);
-    const { threadId, rolloutPath } = writeCodexRollout({
-      cwd,
-      entries,
-      model: model ?? codexRegistry.defaultModel,
-      ...effort ? { effort } : {}
-    });
-    return { forkId: threadId, rolloutPath };
+  async forkSession({ parentSessionId }) {
+    return await forkCodexSession(parentSessionId);
   },
   async cleanupRollouts({ sessionIds }) {
     if (sessionIds.length === 0)
       return;
-    const sessionsDir = join4(process.env.CODEX_HOME || join4(homedir3(), ".codex"), "sessions");
+    const sessionsDir = join3(hostedCodexHomePath(), "sessions");
     if (!existsSync3(sessionsDir))
       return;
     const failures = [];
@@ -354,7 +295,7 @@ var codexRegistryOperations = {
       try {
         const glob = new Bun.Glob(`**/rollout-*-${tid}.jsonl`);
         for await (const rel of glob.scan({ cwd: sessionsDir, onlyFiles: true })) {
-          const path = join4(sessionsDir, rel);
+          const path = join3(sessionsDir, rel);
           try {
             unlinkSync3(path);
           } catch (e) {
@@ -377,9 +318,9 @@ var codexRegistryOperations = {
 
 // ../../packages/core/src/agents/maestro-registry.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5, resolve as resolve2 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4, resolve } from "path";
 var ALIAS_MAP2 = {
   "deepseek-pro": "deepseek-v4-pro",
   kimi: "kimi-k3",
@@ -407,13 +348,13 @@ var maestroRegistry = {
   }
 };
 function maestroSessionsDir() {
-  return join5(process.env.MAESTRO_DATA_DIR ? resolve2(process.env.MAESTRO_DATA_DIR) : join5(homedir4(), ".maestro"), "sessions");
+  return join4(process.env.MAESTRO_DATA_DIR ? resolve(process.env.MAESTRO_DATA_DIR) : join4(homedir2(), ".maestro"), "sessions");
 }
 function maestroSessionPath(sessionId) {
-  return join5(maestroSessionsDir(), `${sessionId}.jsonl`);
+  return join4(maestroSessionsDir(), `${sessionId}.jsonl`);
 }
 function maestroActiveSessionPath(sessionId) {
-  return join5(maestroSessionsDir(), `${sessionId}.active.jsonl`);
+  return join4(maestroSessionsDir(), `${sessionId}.active.jsonl`);
 }
 function existingCreatedAt(path) {
   if (!existsSync4(path))
@@ -432,7 +373,7 @@ function writeRollout(options) {
   assertUuidLike("sessionId", sessionId);
   ensureCwdExists(options.cwd);
   const path = maestroSessionPath(sessionId);
-  mkdirSync4(maestroSessionsDir(), { recursive: true });
+  mkdirSync2(maestroSessionsDir(), { recursive: true });
   const messages = extractChatPairs(options.entries).flatMap((pair) => [
     { role: "user", content: pair.userText },
     { role: "assistant", content: pair.assistantText }
@@ -443,7 +384,7 @@ function writeRollout(options) {
         version: 1,
         cwd: options.cwd,
         createdAt: existingCreatedAt(path) ?? new Date().toISOString(),
-        sdkVersion: "0.1.54"
+        sdkVersion: "0.2.0"
       }
     },
     ...messages
@@ -460,13 +401,28 @@ var maestroRegistryOperations = {
     return writeRollout(options);
   },
   async forkSession(options) {
-    const rollout = writeRollout({
+    const { deleteMaestroSession, forkSessionAt, loadRawMaestroSession } = await import("maestro-agent-sdk");
+    const parentMessages = loadRawMaestroSession(options.parentSessionId);
+    if (!parentMessages) {
+      throw new Error(`Maestro parent session not found: ${options.parentSessionId}`);
+    }
+    const parentHasActiveProjection = existsSync4(maestroActiveSessionPath(options.parentSessionId));
+    const fork = forkSessionAt({
+      parentSessionId: options.parentSessionId,
+      messageIndex: parentMessages.length,
       cwd: options.cwd,
-      entries: readConversation(options.userId, options.topicName),
-      ...options.model ? { model: options.model } : {},
-      ...options.effort ? { effort: options.effort } : {}
+      userId: String(options.userId)
     });
-    return { forkId: rollout.sessionId, rolloutPath: rollout.rolloutPath };
+    if (parentHasActiveProjection && !fork.activeProjectionForked) {
+      deleteMaestroSession(fork.sessionId);
+      throw new Error(`Maestro active projection could not be forked: ${options.parentSessionId}`);
+    }
+    const activePath = maestroActiveSessionPath(fork.sessionId);
+    return {
+      forkId: fork.sessionId,
+      rolloutPath: fork.rolloutPath,
+      ...existsSync4(activePath) ? { cleanupPaths: [activePath] } : {}
+    };
   },
   async cleanupRollouts(options) {
     const { deleteMaestroSession } = await import("maestro-agent-sdk");
@@ -518,4 +474,4 @@ export {
   getRegistry2 as getRegistry
 };
 
-//# debugId=6F48338E5A857EC064756E2164756E21
+//# debugId=2C2992ACF93ADB3E64756E2164756E21