clay-server 2.31.0 → 2.32.0-beta.10

package/lib/yoke/codex-app-server.js

@@ -0,0 +1,307 @@
+// Codex App-Server Protocol Client
+// ---------------------------------
+// Manages a codex app-server child process with bidirectional JSON-RPC
+// communication over stdin/stdout. Replaces the SDK exec mode to enable
+// interactive approval flows.
+
+var { spawn } = require("child_process");
+var readline = require("readline");
+var path = require("path");
+var { createRequire } = require("module");
+
+// --- Find the codex binary path ---
+// Mirrors the logic from @openai/codex-sdk findCodexPath()
+
+var PLATFORM_PACKAGE_BY_TARGET = {
+  "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
+  "x86_64-apple-darwin": "@openai/codex-darwin-x64",
+  "aarch64-unknown-linux-gnu": "@openai/codex-linux-arm64",
+  "x86_64-unknown-linux-gnu": "@openai/codex-linux-x64",
+  "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
+};
+
+function getTargetTriple() {
+  var arch = process.arch;
+  var platform = process.platform;
+  if (platform === "darwin") {
+    return arch === "arm64" ? "aarch64-apple-darwin" : "x86_64-apple-darwin";
+  }
+  if (platform === "linux") {
+    return arch === "arm64" ? "aarch64-unknown-linux-gnu" : "x86_64-unknown-linux-gnu";
+  }
+  if (platform === "win32") {
+    return "x86_64-pc-windows-msvc";
+  }
+  return null;
+}
+
+function findCodexPath() {
+  var triple = getTargetTriple();
+  if (!triple) throw new Error("Unsupported platform: " + process.platform + "/" + process.arch);
+
+  var platformPkg = PLATFORM_PACKAGE_BY_TARGET[triple];
+  if (!platformPkg) throw new Error("No codex binary package for: " + triple);
+
+  try {
+    var codexPkgJson = require.resolve("@openai/codex/package.json");
+    var codexRequire = createRequire(codexPkgJson);
+    var platformPkgJson = codexRequire.resolve(platformPkg + "/package.json");
+    var vendorRoot = path.join(path.dirname(platformPkgJson), "vendor");
+    var binaryName = process.platform === "win32" ? "codex.exe" : "codex";
+    return path.join(vendorRoot, triple, "codex", binaryName);
+  } catch (e) {
+    throw new Error("Could not find codex binary: " + e.message);
+  }
+}
+
+// --- Config serialization ---
+// Flattens a nested config object into --config key=value pairs.
+// Values are serialized as TOML literals (strings quoted, others raw).
+// e.g. { mcp_servers: { "clay-tools": { command: "node", args: ["a.js"] } } }
+// -> ["mcp_servers.clay-tools.command=\"node\"", "mcp_servers.clay-tools.args=[\"a.js\"]"]
+
+function serializeConfig(obj, prefix) {
+  var result = [];
+  var keys = Object.keys(obj);
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var val = obj[key];
+    var fullKey = prefix ? prefix + "." + key : key;
+
+    if (val === null || val === undefined) continue;
+
+    if (typeof val === "object" && !Array.isArray(val)) {
+      // Recurse for nested objects
+      var nested = serializeConfig(val, fullKey);
+      for (var j = 0; j < nested.length; j++) {
+        result.push(nested[j]);
+      }
+    } else {
+      // Leaf value: serialize as TOML
+      result.push(fullKey + "=" + toTomlValue(val));
+    }
+  }
+  return result;
+}
+
+function toTomlValue(val) {
+  if (typeof val === "string") return JSON.stringify(val);
+  if (typeof val === "boolean") return val ? "true" : "false";
+  if (typeof val === "number") return String(val);
+  if (Array.isArray(val)) return "[" + val.map(function(v) { return toTomlValue(v); }).join(", ") + "]";
+  return JSON.stringify(val);
+}
+
+// --- CodexAppServer ---
+
+function CodexAppServer(executablePath, opts) {
+  this.proc = null;
+  this.rl = null;
+  this.nextId = 1;
+  this.pendingRequests = {};  // id -> { resolve, reject, timer }
+  this.eventHandler = null;   // function(notification) for server-initiated events
+  this.executablePath = executablePath || findCodexPath();
+  this.opts = opts || {};
+  this.started = false;
+  this._stderrBuf = "";
+}
+
+CodexAppServer.prototype.start = function() {
+  var self = this;
+
+  return new Promise(function(resolve, reject) {
+    try {
+      var args = ["app-server"];
+      var env = Object.assign({}, process.env, self.opts.env || {});
+
+      // Pass config overrides via --config key=value flags
+      if (self.opts.config) {
+        var configArgs = serializeConfig(self.opts.config, "");
+        for (var ci = 0; ci < configArgs.length; ci++) {
+          args.push("--config", configArgs[ci]);
+        }
+      }
+
+      console.log("[codex-app-server] Spawning:", self.executablePath, args.join(" "));
+
+      self.proc = spawn(self.executablePath, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: env,
+        cwd: self.opts.cwd || process.cwd(),
+      });
+
+      self.proc.on("error", function(err) {
+        console.error("[codex-app-server] Process error:", err.message);
+        if (!self.started) {
+          reject(err);
+        }
+        self._rejectAllPending(err);
+      });
+
+      self.proc.on("exit", function(code, signal) {
+        console.log("[codex-app-server] Process exited: code=" + code + " signal=" + signal);
+        self.started = false;
+        self._rejectAllPending(new Error("Process exited: code=" + code));
+      });
+
+      // Collect stderr for debugging
+      self.proc.stderr.on("data", function(chunk) {
+        var text = chunk.toString();
+        self._stderrBuf += text;
+        // Print stderr lines as they come
+        var lines = self._stderrBuf.split("\n");
+        while (lines.length > 1) {
+          var line = lines.shift();
+          if (line.trim()) console.log("[codex-app-server stderr]", line);
+        }
+        self._stderrBuf = lines[0] || "";
+      });
+
+      // Set up line-based JSON-RPC reading from stdout
+      self.rl = readline.createInterface({
+        input: self.proc.stdout,
+        crlfDelay: Infinity,
+      });
+
+      self.rl.on("line", function(line) {
+        if (!line.trim()) return;
+        try {
+          var msg = JSON.parse(line);
+          self._handleMessage(msg);
+        } catch (e) {
+          console.error("[codex-app-server] Failed to parse line:", line.substring(0, 200));
+        }
+      });
+
+      self.rl.on("close", function() {
+        console.log("[codex-app-server] stdout closed");
+      });
+
+      self.started = true;
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+};
+
+CodexAppServer.prototype._handleMessage = function(msg) {
+  // Response to a request we sent
+  if (msg.id !== undefined && msg.id !== null && (msg.result !== undefined || msg.error !== undefined)) {
+    var pending = this.pendingRequests[msg.id];
+    if (pending) {
+      delete this.pendingRequests[msg.id];
+      if (pending.timer) clearTimeout(pending.timer);
+      if (msg.error) {
+        pending.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+      } else {
+        pending.resolve(msg.result);
+      }
+    }
+    return;
+  }
+
+  // Server-initiated request (has id + method) or notification (has method, no id)
+  if (msg.method) {
+    if (this.eventHandler) {
+      this.eventHandler(msg);
+    } else {
+      console.log("[codex-app-server] Unhandled event:", msg.method);
+    }
+  }
+};
+
+// Send a JSON-RPC request (expects a response)
+CodexAppServer.prototype.send = function(method, params, timeoutMs) {
+  var self = this;
+  var id = this.nextId++;
+  timeoutMs = timeoutMs || 30000;
+
+  return new Promise(function(resolve, reject) {
+    if (!self.proc || !self.started) {
+      return reject(new Error("App-server not started"));
+    }
+
+    var timer = setTimeout(function() {
+      delete self.pendingRequests[id];
+      reject(new Error("Request timeout: " + method + " (id=" + id + ")"));
+    }, timeoutMs);
+
+    self.pendingRequests[id] = { resolve: resolve, reject: reject, timer: timer };
+
+    var msg = { jsonrpc: "2.0", id: id, method: method };
+    if (params !== undefined) msg.params = params;
+
+    self._write(msg);
+  });
+};
+
+// Send a JSON-RPC notification (no response expected)
+CodexAppServer.prototype.notify = function(method, params) {
+  if (!this.proc || !this.started) return;
+
+  var msg = { jsonrpc: "2.0", method: method };
+  if (params !== undefined) msg.params = params;
+
+  this._write(msg);
+};
+
+// Respond to a server-initiated request
+CodexAppServer.prototype.respond = function(id, result) {
+  if (!this.proc || !this.started) return;
+
+  var msg = { jsonrpc: "2.0", id: id, result: result };
+  this._write(msg);
+};
+
+// Respond with an error to a server-initiated request
+CodexAppServer.prototype.respondError = function(id, code, message) {
+  if (!this.proc || !this.started) return;
+
+  var msg = { jsonrpc: "2.0", id: id, error: { code: code || -1, message: message || "Error" } };
+  this._write(msg);
+};
+
+CodexAppServer.prototype._write = function(msg) {
+  if (!this.proc || !this.proc.stdin || this.proc.stdin.destroyed) return;
+  try {
+    this.proc.stdin.write(JSON.stringify(msg) + "\n");
+  } catch (e) {
+    console.error("[codex-app-server] Write error:", e.message);
+  }
+};
+
+CodexAppServer.prototype._rejectAllPending = function(err) {
+  var ids = Object.keys(this.pendingRequests);
+  for (var i = 0; i < ids.length; i++) {
+    var pending = this.pendingRequests[ids[i]];
+    if (pending.timer) clearTimeout(pending.timer);
+    pending.reject(err);
+  }
+  this.pendingRequests = {};
+};
+
+CodexAppServer.prototype.stop = function() {
+  this.started = false;
+  this._rejectAllPending(new Error("Stopped"));
+
+  if (this.rl) {
+    this.rl.close();
+    this.rl = null;
+  }
+
+  if (this.proc) {
+    try {
+      this.proc.stdin.end();
+    } catch (e) {}
+    try {
+      this.proc.kill("SIGTERM");
+    } catch (e) {}
+    this.proc = null;
+  }
+};
+
+module.exports = {
+  CodexAppServer: CodexAppServer,
+  findCodexPath: findCodexPath,
+};

package/lib/yoke/index.js

@@ -0,0 +1,199 @@
+// YOKE - Yoke Overrides Known Engines
+// Public entry point.
+
+var iface = require("./interface");
+var instructions = require("./instructions");
+var createClaudeAdapter = require("./adapters/claude").createClaudeAdapter;
+var createGeminiAdapter = require("./adapters/gemini").createGeminiAdapter;
+var createCodexAdapter = require("./adapters/codex").createCodexAdapter;
+
+/**
+ * Wrap adapter.createQuery to inject cross-vendor project instructions.
+ *
+ * Scans the project directory for instruction files (CLAUDE.md, AGENTS.md,
+ * .cursorrules, etc.) that the current vendor does NOT natively read,
+ * and merges them into queryOpts.systemPrompt before calling the real
+ * createQuery. This way every adapter gets project context regardless
+ * of which vendor wrote the instruction file.
+ */
+function wrapCreateQuery(adapter, defaultCwd) {
+  var originalCreateQuery = adapter.createQuery.bind(adapter);
+
+  adapter.createQuery = function(queryOpts) {
+    var projectDir = (queryOpts && queryOpts.cwd) || defaultCwd;
+    var merged = instructions.scanAndMerge(projectDir, adapter.vendor);
+
+    if (merged) {
+      var parts = [];
+      if (queryOpts.systemPrompt) parts.push(queryOpts.systemPrompt);
+      parts.push(merged);
+      queryOpts.systemPrompt = parts.join("\n\n");
+    }
+
+    return originalCreateQuery(queryOpts);
+  };
+}
+
+/**
+ * Create a YOKE adapter.
+ *
+ * @param {object} opts
+ * @param {string} [opts.vendor="claude"] - Adapter vendor name
+ * @param {string} opts.cwd              - Project working directory
+ * @param {object} [opts.adapterOpts]    - Vendor-specific adapter construction options
+ * @returns {Adapter}
+ */
+function createAdapter(opts) {
+  var vendor = (opts && opts.vendor) || "claude";
+  var adapter;
+  if (vendor === "claude") {
+    adapter = createClaudeAdapter(opts);
+  } else if (vendor === "gemini") {
+    adapter = createGeminiAdapter(opts);
+  } else if (vendor === "codex") {
+    adapter = createCodexAdapter(opts);
+  } else {
+    throw new Error("[YOKE] Unknown adapter vendor: " + vendor);
+  }
+  iface.validateAdapter(adapter);
+  wrapCreateQuery(adapter, opts.cwd);
+  return adapter;
+}
+
+/**
+ * Check which vendors have valid auth credentials.
+ * Result is cached after first call (auth state doesn't change during runtime).
+ * Call invalidateAuthCache() to force re-check (e.g. after login).
+ */
+var _authCache = null;
+
+function checkAuth() {
+  if (_authCache) return _authCache;
+
+  var execSync = require("child_process").execSync;
+
+  function checkClaude() {
+    try {
+      var out = execSync("claude auth status", { timeout: 5000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+      var parsed = JSON.parse(out);
+      return !!(parsed && parsed.loggedIn);
+    } catch (e) {
+      return false;
+    }
+  }
+
+  function checkCodex() {
+    try {
+      var path = require("path");
+      var codexBin = path.join(__dirname, "../../node_modules/@openai/codex-darwin-arm64/vendor/aarch64-apple-darwin/codex/codex");
+      execSync(codexBin + " login status", { timeout: 5000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  _authCache = { claude: checkClaude(), codex: checkCodex(), gemini: false };
+  console.log("[yoke] Auth check: claude=" + _authCache.claude + " codex=" + _authCache.codex);
+  return _authCache;
+}
+
+/**
+ * Check which vendor binaries are installed (regardless of auth status).
+ */
+function checkInstalled() {
+  var fs = require("fs");
+  var path = require("path");
+  var execSync = require("child_process").execSync;
+  var result = { claude: false, codex: false };
+  try {
+    execSync("which claude", { timeout: 3000, stdio: ["pipe", "pipe", "pipe"] });
+    result.claude = true;
+  } catch (e) {}
+  try {
+    var codexBin = path.join(__dirname, "../../node_modules/@openai/codex-darwin-arm64/vendor/aarch64-apple-darwin/codex/codex");
+    if (fs.existsSync(codexBin)) result.codex = true;
+  } catch (e) {}
+  return result;
+}
+
+function invalidateAuthCache() {
+  _authCache = null;
+}
+
+/**
+ * Create adapters for all authenticated vendors.
+ * Adapters are singletons shared across all projects (they are stateless factories).
+ * The cwd is passed per-query, not per-adapter.
+ * Returns { adapters: { vendor: Adapter }, auth: { vendor: boolean } }
+ */
+var _sharedAdapters = null;
+var _sharedAuth = null;
+
+function createAdapters(opts) {
+  if (_sharedAdapters) {
+    return { adapters: _sharedAdapters, auth: _sharedAuth };
+  }
+
+  var auth = checkAuth();
+  var adapters = {};
+  var vendors = Object.keys(auth);
+
+  for (var i = 0; i < vendors.length; i++) {
+    var vendor = vendors[i];
+    if (!auth[vendor]) continue;
+    try {
+      adapters[vendor] = createAdapter({ vendor: vendor, cwd: opts.cwd });
+      console.log("[yoke] Adapter created: " + vendor);
+    } catch (e) {
+      console.error("[yoke] Failed to create adapter for " + vendor + ":", e.message);
+      auth[vendor] = false;
+    }
+  }
+
+  _sharedAdapters = adapters;
+  _sharedAuth = auth;
+  return { adapters: adapters, auth: auth };
+}
+
+/**
+ * Lazy-create an adapter for a vendor that wasn't available at startup.
+ * Re-checks auth, creates adapter if now logged in.
+ * Returns the adapter or null.
+ */
+function lazyCreateAdapter(adapters, vendor, opts) {
+  if (_sharedAdapters && _sharedAdapters[vendor]) {
+    adapters[vendor] = _sharedAdapters[vendor];
+    return adapters[vendor];
+  }
+
+  // Force re-check since user may have logged in after server start
+  invalidateAuthCache();
+  _sharedAdapters = null;
+  _sharedAuth = null;
+  var auth = checkAuth();
+  if (!auth[vendor]) return null;
+
+  try {
+    var ad = createAdapter({ vendor: vendor, cwd: opts.cwd });
+    console.log("[yoke] Lazy adapter created: " + vendor);
+    if (_sharedAdapters) _sharedAdapters[vendor] = ad;
+    adapters[vendor] = ad;
+    return ad;
+  } catch (e) {
+    console.error("[yoke] Failed to lazy-create adapter for " + vendor + ":", e.message);
+    return null;
+  }
+}
+
+module.exports = {
+  createAdapter: createAdapter,
+  createAdapters: createAdapters,
+  lazyCreateAdapter: lazyCreateAdapter,
+  checkAuth: checkAuth,
+  checkInstalled: checkInstalled,
+  invalidateAuthCache: invalidateAuthCache,
+  TOOL_POLICIES: iface.TOOL_POLICIES,
+  validateAdapter: iface.validateAdapter,
+  validateQueryHandle: iface.validateQueryHandle,
+};

package/lib/yoke/instructions.js

@@ -0,0 +1,62 @@
+// YOKE Instruction Scanner
+// ------------------------
+// Scans a project directory for vendor-specific instruction files
+// (CLAUDE.md, AGENTS.md, .cursorrules, etc.) and merges them into
+// a single string that any adapter can inject as context.
+//
+// Each adapter declares which files its vendor reads natively so
+// those are excluded from the merged output (no double-injection).
+
+var fs = require("fs");
+var path = require("path");
+
+// Known instruction files in priority order.
+// { file: relative path, label: human-readable label }
+var KNOWN_FILES = [
+  { file: "CLAUDE.md", label: "CLAUDE.md" },
+  { file: "AGENTS.md", label: "AGENTS.md" },
+  { file: ".cursorrules", label: ".cursorrules" },
+  { file: ".github/copilot-instructions.md", label: ".github/copilot-instructions.md" },
+  { file: "COPILOT.md", label: "COPILOT.md" },
+];
+
+// Files each vendor reads natively (skip these to avoid duplication).
+var NATIVE_FILES = {
+  claude: ["CLAUDE.md"],
+  codex: ["AGENTS.md"],
+  gemini: [],
+};
+
+// Scan projectDir for instruction files and return merged text.
+// Excludes files the given vendor already reads natively.
+//
+// Returns "" if no files found (callers can skip injection).
+function scanAndMerge(projectDir, vendor) {
+  if (!projectDir) return "";
+
+  var exclude = NATIVE_FILES[vendor] || [];
+  var sections = [];
+
+  for (var i = 0; i < KNOWN_FILES.length; i++) {
+    var entry = KNOWN_FILES[i];
+    if (exclude.indexOf(entry.file) !== -1) continue;
+
+    var filePath = path.join(projectDir, entry.file);
+    try {
+      var content = fs.readFileSync(filePath, "utf8").trim();
+      if (content) {
+        sections.push("--- Instructions from " + entry.label + " ---\n" + content);
+      }
+    } catch (e) {
+      // File doesn't exist or unreadable, skip.
+    }
+  }
+
+  return sections.join("\n\n");
+}
+
+module.exports = {
+  scanAndMerge: scanAndMerge,
+  KNOWN_FILES: KNOWN_FILES,
+  NATIVE_FILES: NATIVE_FILES,
+};

package/lib/yoke/interface.js

@@ -0,0 +1,98 @@
+// YOKE Interface Definition
+// -------------------------
+// This file defines the contract that every adapter must implement.
+// It does NOT contain runtime logic; it is the authoritative reference
+// for Phase 3 and beyond.
+//
+// Adapter objects must satisfy two shapes:
+//   1. Adapter (returned by createAdapter)
+//   2. QueryHandle (returned by adapter.createQuery)
+
+var TOOL_POLICIES = ["ask", "allow-all"];
+
+/**
+ * Validate that an adapter object implements all required methods.
+ * Throws if any are missing. Development-time safety net only.
+ *
+ * Adapter shape:
+ *   .vendor           : string          - e.g. "claude", "opencode", "codex"
+ *   .init(opts)       : Promise<InitResult>
+ *   .supportedModels(): Promise<string[]>
+ *   .createToolServer(def): ToolServer (opaque)
+ *   .createQuery(opts): QueryHandle
+ *
+ * Lightweight utilities:
+ *   .generateTitle(messages, opts) : Promise<string> - generate a short session title
+ *     messages: string[] - user messages to derive the title from
+ *     opts: { cwd }
+ *     Returns a short (3-8 word) title string.
+ *
+ * Additional session management (Claude SDK specific, may vary per adapter):
+ *   .getSessionInfo(sessionId, opts): Promise<object|null>
+ *   .listSessions(opts)             : Promise<Array>
+ *   .renameSession(sessionId, title, opts): Promise
+ *   .forkSession(sessionId, opts)   : Promise<object>
+ *
+ * QueryHandle shape:
+ *   [Symbol.asyncIterator]()  - yields SDK events (raw in Phase 3, normalized later)
+ *   .pushMessage(text, images)
+ *   .setModel(model)
+ *   .setEffort(effort)
+ *   .setToolPolicy(policy)    - "ask" | "allow-all"
+ *   .stopTask(taskId)
+ *   .getContextUsage()        - Promise<object|null>
+ *   .abort()
+ *   .close()
+ */
+
+var ADAPTER_METHODS = [
+  "init",
+  "supportedModels",
+  "createToolServer",
+  "createQuery",
+];
+
+var QUERY_HANDLE_METHODS = [
+  "pushMessage",
+  "setModel",
+  "setEffort",
+  "setToolPolicy",
+  "stopTask",
+  "getContextUsage",
+  "abort",
+  "close",
+];
+
+function validateAdapter(adapter) {
+  if (!adapter) throw new Error("[YOKE] Adapter is null or undefined");
+  if (typeof adapter.vendor !== "string" || !adapter.vendor) {
+    throw new Error("[YOKE] Adapter must have a non-empty 'vendor' string property");
+  }
+  for (var i = 0; i < ADAPTER_METHODS.length; i++) {
+    var m = ADAPTER_METHODS[i];
+    if (typeof adapter[m] !== "function") {
+      throw new Error("[YOKE] Adapter '" + adapter.vendor + "' missing required method: " + m);
+    }
+  }
+}
+
+function validateQueryHandle(handle) {
+  if (!handle) throw new Error("[YOKE] QueryHandle is null or undefined");
+  if (typeof handle[Symbol.asyncIterator] !== "function") {
+    throw new Error("[YOKE] QueryHandle must implement Symbol.asyncIterator");
+  }
+  for (var i = 0; i < QUERY_HANDLE_METHODS.length; i++) {
+    var m = QUERY_HANDLE_METHODS[i];
+    if (typeof handle[m] !== "function") {
+      throw new Error("[YOKE] QueryHandle missing required method: " + m);
+    }
+  }
+}
+
+module.exports = {
+  TOOL_POLICIES: TOOL_POLICIES,
+  ADAPTER_METHODS: ADAPTER_METHODS,
+  QUERY_HANDLE_METHODS: QUERY_HANDLE_METHODS,
+  validateAdapter: validateAdapter,
+  validateQueryHandle: validateQueryHandle,
+};