negotium 0.1.6 → 0.1.8

package/dist/runtime/src/agents/claude-registry.ts

@@ -0,0 +1,115 @@
+import { existsSync, mkdirSync, readdirSync, renameSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AgentRegistry } from "#agents/contracts";
+import { encodeClaudeCwd, writeClaudeRollout } from "#agents/rollout/claude";
+import { MODEL_FABLE, MODEL_OPUS, MODEL_SONNET } from "#platform/config";
+import { logger } from "#platform/logger";
+import { CLAUDE_EFFORT_VALUES, type EffortLevel } from "#types";
+
+const ALIAS_MAP: Record<string, string> = {
+  sonnet: MODEL_SONNET,
+  opus: MODEL_OPUS,
+  fable: MODEL_FABLE,
+};
+
+const VALID_ALIASES = new Set(Object.keys(ALIAS_MAP));
+const VALID_EFFORTS = new Set<EffortLevel>(CLAUDE_EFFORT_VALUES);
+
+export const claudeRegistry: AgentRegistry = {
+  kind: "claude",
+  defaultModel: "sonnet",
+  defaultEffort: "high",
+
+  expandModelAlias(s) {
+    return ALIAS_MAP[s] ?? s;
+  },
+
+  validateModel(s) {
+    return VALID_ALIASES.has(s);
+  },
+
+  validEfforts: CLAUDE_EFFORT_VALUES,
+  validateEffort(s) {
+    return VALID_EFFORTS.has(s);
+  },
+
+  footerLabel(model, effort) {
+    return effort ? `${model} · ${effort}` : model;
+  },
+
+  writeRollout(opts) {
+    // `reuseSessionId` (if any) becomes the SDK resume key + path component,
+    // so claude→codex→claude lands at the original `~/.claude/projects/<dir>/<id>.jsonl`
+    // instead of orphaning a fresh UUID every switch.
+    const { sessionId, rolloutPath } = writeClaudeRollout({
+      cwd: opts.cwd,
+      entries: opts.entries,
+      model: claudeRegistry.expandModelAlias(opts.model ?? claudeRegistry.defaultModel),
+      ...(opts.reuseSessionId ? { sessionId: opts.reuseSessionId } : {}),
+    });
+    return { sessionId, rolloutPath };
+  },
+
+  // Claude has a native fork API in @anthropic-ai/claude-agent-sdk that produces
+  // a byte-equivalent copy of the parent rollout. Preserves tool history
+  // structurally, so the fork is indistinguishable from the parent on resume.
+  //
+  // SDK ≥0.3.19x semantics: `dir` is where to FIND the parent session (lookup
+  // scope), NOT the destination — passing the derived topic's cwd made lookup
+  // fail ("Session … not found in project directory"). The fork file is always
+  // written NEXT TO the parent rollout, so after forking we move it into the
+  // derived cwd's project dir where a resume from that cwd expects it.
+  async forkSession({ parentSessionId, cwd, title }) {
+    const { forkSession } = await import("@anthropic-ai/claude-agent-sdk");
+    // Omit `dir`: the parent session lives under the SOURCE topic's project
+    // dir, which this registry never receives — global search finds it.
+    const result = await forkSession(parentSessionId, {
+      ...(title ? { title } : {}),
+    });
+    const projectsRoot = join(homedir(), ".claude", "projects");
+    const destDir = join(projectsRoot, encodeClaudeCwd(cwd));
+    const destPath = join(destDir, `${result.sessionId}.jsonl`);
+    if (!existsSync(destPath)) {
+      const sourcePath = readdirSync(projectsRoot)
+        .map((d) => join(projectsRoot, d, `${result.sessionId}.jsonl`))
+        .find((p) => existsSync(p));
+      if (!sourcePath) {
+        throw new Error(
+          `claude forkSession: fork rollout ${result.sessionId}.jsonl not found under ${projectsRoot}`,
+        );
+      }
+      mkdirSync(destDir, { recursive: true });
+      renameSync(sourcePath, destPath);
+    }
+    return {
+      forkId: result.sessionId,
+      // Same project-dir layout as cleanupRollouts below — NOT under
+      // `cwd/.claude/sessions/`. A wrong path here makes cleanupAgentFork's
+      // existsSync always false, so silent-fork rollouts accumulate forever.
+      rolloutPath: destPath,
+    };
+  },
+
+  // Each Claude rollout lives at `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl`.
+  // The encoded-cwd is deterministic so we can compute the path directly
+  // without globbing — fast and robust against the SDK changing date layout.
+  async cleanupRollouts({ cwd, sessionIds }) {
+    const projectsDir = join(homedir(), ".claude", "projects", encodeClaudeCwd(cwd));
+    const failures: unknown[] = [];
+    for (const sid of sessionIds) {
+      const path = join(projectsDir, `${sid}.jsonl`);
+      try {
+        unlinkSync(path);
+      } catch (e) {
+        if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") {
+          logger.warn({ err: e, path }, "claude cleanupRollouts: unlink failed");
+          failures.push(e);
+        }
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, "claude cleanupRollouts failed");
+    }
+  },
+};

package/dist/runtime/src/agents/codex-native-multi-agent.ts

@@ -0,0 +1,177 @@
+import { spawn } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { NEGOTIUM_VERSION } from "#version";
+
+type CodexModel = Record<string, unknown>;
+type CodexModelCache = {
+  models?: unknown;
+};
+
+const NEGOTIUM_MODEL_CATALOG = "negotium-model-catalog.json";
+const moduleRequire = createRequire(import.meta.url);
+
+function codexCliScriptPath(): string {
+  const sdkPackagePath = moduleRequire.resolve("@openai/codex-sdk/package.json");
+  const sdkRequire = createRequire(sdkPackagePath);
+  return join(dirname(sdkRequire.resolve("@openai/codex/package.json")), "bin", "codex.js");
+}
+
+async function bootstrapCodexModelCache(codexHome: string, cachePath: string): Promise<void> {
+  const child = spawn(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
+    env: { ...process.env, CODEX_HOME: codexHome },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    let settled = false;
+    let stdoutBuffer = "";
+    let stderr = "";
+    const timer = setTimeout(
+      () => finish(new Error("timed out while refreshing the Codex model catalog")),
+      15_000,
+    );
+
+    const finish = (error?: Error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        child.stdin.end();
+        child.kill();
+      } catch {
+        // The app server may already have exited after stdin closed.
+      }
+      if (error) reject(error);
+      else if (!existsSync(cachePath)) reject(new Error("Codex did not create its model cache"));
+      else resolve();
+    };
+
+    const send = (message: Record<string, unknown>) => {
+      child.stdin.write(`${JSON.stringify(message)}\n`);
+    };
+
+    child.stderr.on("data", (chunk) => {
+      if (stderr.length < 4_096) stderr += String(chunk);
+    });
+    child.on("error", (error) => finish(error));
+    child.on("exit", (code, signal) => {
+      if (!settled) {
+        finish(
+          new Error(
+            `Codex model catalog refresh exited with ${signal ? `signal ${signal}` : `code ${code ?? 1}`}${stderr.trim() ? `: ${stderr.trim()}` : ""}`,
+          ),
+        );
+      }
+    });
+    child.stdout.on("data", (chunk) => {
+      stdoutBuffer += String(chunk);
+      for (;;) {
+        const newline = stdoutBuffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = stdoutBuffer.slice(0, newline);
+        stdoutBuffer = stdoutBuffer.slice(newline + 1);
+        let message: { id?: number; error?: { message?: string } };
+        try {
+          message = JSON.parse(line) as typeof message;
+        } catch {
+          continue;
+        }
+        if (message.id === 1) {
+          if (message.error) {
+            finish(new Error(message.error.message || "Codex initialization failed"));
+            return;
+          }
+          send({ method: "initialized" });
+          send({ id: 2, method: "model/list", params: { includeHidden: true } });
+        } else if (message.id === 2) {
+          if (message.error) {
+            finish(new Error(message.error.message || "Codex model listing failed"));
+          } else {
+            finish();
+          }
+          return;
+        }
+      }
+    });
+
+    send({
+      id: 1,
+      method: "initialize",
+      params: {
+        clientInfo: { name: "negotium", version: NEGOTIUM_VERSION },
+        capabilities: { experimentalApi: true },
+      },
+    });
+  });
+}
+
+export async function ensureCodexModelCache(
+  authFilePath: string,
+  bootstrap: (codexHome: string, cachePath: string) => Promise<void> = bootstrapCodexModelCache,
+): Promise<void> {
+  const codexHome = dirname(authFilePath);
+  const cachePath =
+    process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE ?? join(codexHome, "models_cache.json");
+  const hardenedCatalogPath = join(codexHome, NEGOTIUM_MODEL_CATALOG);
+  if (existsSync(cachePath) || existsSync(hardenedCatalogPath)) return;
+  if (process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE) {
+    throw new Error(`Configured Codex model cache does not exist: ${cachePath}`);
+  }
+  await bootstrap(codexHome, cachePath);
+}
+
+/**
+ * Codex 0.144 resolves model metadata before `features.multi_agent=false`, so
+ * a model-advertised v1/v2 value still registers native collaboration tools.
+ * Feed Codex an authoritative copy of its own catalog with only that field
+ * disabled. Runtime MCP delegation remains available independently.
+ */
+export function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath: string): string {
+  const codexHome = dirname(authFilePath);
+  const sourcePath =
+    process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE ??
+    (existsSync(join(codexHome, "models_cache.json"))
+      ? join(codexHome, "models_cache.json")
+      : join(codexHome, NEGOTIUM_MODEL_CATALOG));
+  const outputPath = join(codexHome, NEGOTIUM_MODEL_CATALOG);
+
+  const parsed = JSON.parse(readFileSync(sourcePath, "utf8")) as CodexModelCache;
+  if (!Array.isArray(parsed.models) || parsed.models.length === 0) {
+    throw new Error(`Codex model cache has no models: ${sourcePath}`);
+  }
+
+  const models = parsed.models.map((model, index): CodexModel => {
+    if (!model || typeof model !== "object" || Array.isArray(model)) {
+      throw new Error(`Codex model cache entry ${index} is invalid: ${sourcePath}`);
+    }
+    return { ...(model as CodexModel), multi_agent_version: "disabled" };
+  });
+  const contents = `${JSON.stringify({ models }, null, 2)}\n`;
+
+  if (existsSync(outputPath) && readFileSync(outputPath, "utf8") === contents) {
+    return outputPath;
+  }
+
+  const tempPath = `${outputPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(tempPath, contents, { encoding: "utf8", mode: 0o600 });
+    renameSync(tempPath, outputPath);
+    chmodSync(outputPath, 0o600);
+  } finally {
+    try {
+      unlinkSync(tempPath);
+    } catch {
+      // renameSync normally consumed the temporary file.
+    }
+  }
+  return outputPath;
+}