clay-server 5.2.0-beta.5 → 5.2.0-beta.7

package/lib/yoke/cli-sessions.js

@@ -0,0 +1,300 @@
+var fs = require("fs");
+var path = require("path");
+var readline = require("readline");
+var utils = require("../utils");
+var { REAL_HOME } = require("../config");
+
+var encodeCwd = utils.encodeCwd;
+
+/**
+ * Parse the first ~20 lines of a CLI session JSONL file to extract metadata.
+ * Returns null if the file can't be parsed or has no user messages.
+ */
+function parseSessionFile(filePath, maxLines) {
+  if (maxLines == null) maxLines = 20;
+  return new Promise(function (resolve) {
+    var sessionId = path.basename(filePath, ".jsonl");
+    var result = {
+      sessionId: sessionId,
+      firstPrompt: "",
+      model: null,
+      gitBranch: null,
+      startTime: null,
+      lastActivity: null,
+    };
+
+    var lineCount = 0;
+    var foundUser = false;
+    var stream;
+    try {
+      stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    } catch (e) {
+      return resolve(null);
+    }
+
+    var rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+    rl.on("line", function (line) {
+      lineCount++;
+      if (lineCount > maxLines) {
+        rl.close();
+        stream.destroy();
+        return;
+      }
+
+      var obj;
+      try { obj = JSON.parse(line); } catch (e) { return; }
+
+      // Skip file-history-snapshot, queue-operation, and other non-message records
+      if (obj.type === "user" && obj.message && obj.message.role === "user") {
+        if (!foundUser) {
+          foundUser = true;
+          result.sessionId = obj.sessionId || sessionId;
+          result.gitBranch = obj.gitBranch || null;
+          if (obj.timestamp) result.startTime = obj.timestamp;
+          var content = obj.message.content || "";
+          if (typeof content === "string") {
+            result.firstPrompt = content.substring(0, 100);
+          } else if (Array.isArray(content)) {
+            for (var i = 0; i < content.length; i++) {
+              if (content[i].type === "text" && content[i].text) {
+                result.firstPrompt = content[i].text.substring(0, 100);
+                break;
+              }
+            }
+          }
+        }
+        // Track latest user timestamp for lastActivity
+        if (obj.timestamp) result.lastActivity = obj.timestamp;
+      }
+
+      // Extract model from first assistant message
+      if (!result.model && obj.message && obj.message.role === "assistant" && obj.message.model) {
+        result.model = obj.message.model;
+      }
+    });
+
+    rl.on("close", function () {
+      if (!foundUser) return resolve(null);
+
+      // Use file mtime as fallback for lastActivity, or as a better proxy
+      // since we only read the first ~20 lines
+      try {
+        var stat = fs.statSync(filePath);
+        var mtime = stat.mtime.toISOString();
+        // File mtime is always more accurate for "last activity" since we
+        // don't read the entire file
+        result.lastActivity = mtime;
+      } catch (e) {}
+
+      resolve(result);
+    });
+
+    rl.on("error", function () {
+      resolve(null);
+    });
+
+    stream.on("error", function () {
+      rl.close();
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * List CLI sessions for a given project directory.
+ * Reads ~/.claude/projects/{encoded-cwd}/ and parses JSONL metadata.
+ * Returns array sorted by lastActivity descending (most recent first).
+ */
+function listCliSessions(cwd) {
+  var encoded = encodeCwd(cwd);
+  var projectDir = path.join(REAL_HOME, ".claude", "projects", encoded);
+
+  return new Promise(function (resolve) {
+    fs.readdir(projectDir, { withFileTypes: true }, function (err, entries) {
+      if (err) return resolve([]);
+
+      var jsonlFiles = [];
+      for (var i = 0; i < entries.length; i++) {
+        if (entries[i].isFile() && entries[i].name.endsWith(".jsonl")) {
+          jsonlFiles.push(path.join(projectDir, entries[i].name));
+        }
+      }
+
+      if (jsonlFiles.length === 0) return resolve([]);
+
+      var pending = jsonlFiles.length;
+      var results = [];
+
+      for (var j = 0; j < jsonlFiles.length; j++) {
+        parseSessionFile(jsonlFiles[j]).then(function (session) {
+          if (session) results.push(session);
+          pending--;
+          if (pending === 0) {
+            results.sort(function (a, b) {
+              var ta = a.lastActivity || "";
+              var tb = b.lastActivity || "";
+              return ta < tb ? 1 : ta > tb ? -1 : 0;
+            });
+            resolve(results);
+          }
+        });
+      }
+    });
+  });
+}
+
+/**
+ * Get the most recent CLI session for a given project directory.
+ * Returns the session object or null if none found.
+ */
+function getMostRecentCliSession(cwd) {
+  return listCliSessions(cwd).then(function (sessions) {
+    return sessions.length > 0 ? sessions[0] : null;
+  });
+}
+
+/**
+ * Extract user message text from a CLI JSONL content field.
+ * Content can be a string or an array of content blocks.
+ */
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  var parts = [];
+  for (var i = 0; i < content.length; i++) {
+    if (content[i].type === "text" && content[i].text) {
+      parts.push(content[i].text);
+    }
+  }
+  return parts.join("");
+}
+
+/**
+ * Read a full CLI session JSONL file and convert it to relay-compatible
+ * history entries (user_message, delta, tool_start, tool_executing, tool_result).
+ * Returns a Promise that resolves to an array of history entries.
+ */
+// Convert one parsed CLI jsonl record into client history entries. Shared by
+// the streaming (async) and synchronous readers so the format stays in lockstep.
+// `state.toolCounter` carries across lines to mint unique tool ids.
+function appendCliRecord(obj, state, history) {
+  if (!obj || !obj.message) return;
+
+  // User prompt
+  if (obj.type === "user" && obj.message.role === "user") {
+    // Skip tool_result records (they have type "user" but content is tool results)
+    var content = obj.message.content;
+    if (Array.isArray(content) && content.length > 0 && content[0].type === "tool_result") {
+      return;
+    }
+    var text = extractText(content);
+    if (text) history.push({ type: "user_message", text: text });
+    return;
+  }
+
+  // Assistant message
+  if (obj.message.role === "assistant" && Array.isArray(obj.message.content)) {
+    for (var i = 0; i < obj.message.content.length; i++) {
+      var block = obj.message.content[i];
+
+      if (block.type === "text" && block.text) {
+        history.push({ type: "delta", text: block.text });
+      }
+
+      if (block.type === "tool_use") {
+        var toolId = "cli-tool-" + (++state.toolCounter);
+        var toolName = block.name || "Tool";
+        history.push({ type: "tool_start", id: toolId, name: toolName });
+        history.push({
+          type: "tool_executing",
+          id: toolId,
+          name: toolName,
+          input: block.input || {},
+        });
+        // Emit ask_user_answered so the client re-enables input after replaying AskUserQuestion
+        if (toolName === "AskUserQuestion") {
+          history.push({ type: "ask_user_answered", toolId: toolId });
+        }
+        history.push({ type: "tool_result", id: toolId, content: "" });
+      }
+    }
+  }
+}
+
+function readCliSessionHistory(home, cwd, sessionId) {
+  var encoded = encodeCwd(cwd);
+  var filePath = path.join(home || REAL_HOME, ".claude", "projects", encoded, sessionId + ".jsonl");
+
+  return new Promise(function (resolve) {
+    var history = [];
+    var stream;
+    try {
+      stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    } catch (e) {
+      return resolve([]);
+    }
+
+    var rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    var state = { toolCounter: 0 };
+
+    rl.on("line", function (line) {
+      var obj;
+      try { obj = JSON.parse(line); } catch (e) { return; }
+      appendCliRecord(obj, state, history);
+    });
+
+    rl.on("close", function () {
+      resolve(history);
+    });
+
+    rl.on("error", function () {
+      resolve([]);
+    });
+
+    stream.on("error", function () {
+      rl.close();
+      resolve([]);
+    });
+  });
+}
+
+// Synchronous variant for callers that run inside a synchronous request
+// handler (e.g. switch_session, which must populate session.history before
+// the session_switched broadcast). Reads the whole jsonl - these transcripts
+// are small enough that blocking on a local read is fine.
+// Modified-time (ms) of a CLI session's jsonl, or 0 if missing. Lets callers
+// cheaply detect that the transcript grew (e.g. after a TUI turn) and re-read.
+function cliSessionFileMtime(home, cwd, sessionId) {
+  var encoded = encodeCwd(cwd);
+  var filePath = path.join(home || REAL_HOME, ".claude", "projects", encoded, sessionId + ".jsonl");
+  try { return fs.statSync(filePath).mtimeMs; } catch (e) { return 0; }
+}
+
+function readCliSessionHistorySync(home, cwd, sessionId) {
+  var encoded = encodeCwd(cwd);
+  var filePath = path.join(home || REAL_HOME, ".claude", "projects", encoded, sessionId + ".jsonl");
+  var raw;
+  try { raw = fs.readFileSync(filePath, "utf8"); } catch (e) { return []; }
+  var history = [];
+  var state = { toolCounter: 0 };
+  var lines = raw.split("\n");
+  for (var i = 0; i < lines.length; i++) {
+    if (!lines[i]) continue;
+    var obj;
+    try { obj = JSON.parse(lines[i]); } catch (e) { continue; }
+    appendCliRecord(obj, state, history);
+  }
+  return history;
+}
+
+module.exports = {
+  listCliSessions: listCliSessions,
+  getMostRecentCliSession: getMostRecentCliSession,
+  readCliSessionHistory: readCliSessionHistory,
+  readCliSessionHistorySync: readCliSessionHistorySync,
+  cliSessionFileMtime: cliSessionFileMtime,
+  parseSessionFile: parseSessionFile,
+  encodeCwd: encodeCwd,
+  extractText: extractText,
+};

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

@@ -17,9 +17,9 @@ var { wrapSpawnAsUser } = require("../os-users");
 //
 // The bundled @openai/codex platform package is the default. Set the
 // CLAY_CODEX_PATH env var to an existing executable to run a different codex
-// build (local dev build, system install, pinned older release); the chosen
-// binary is logged on every resolution. An unset or non-existent
-// CLAY_CODEX_PATH silently falls back to the bundled resolution.
+// build (local dev build, system install, pinned older release). An unset
+// override uses bundled resolution; an explicitly invalid override fails
+// closed without selecting a different installation.
 
 var PLATFORM_PACKAGE_BY_TARGET = {
   "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
@@ -45,14 +45,9 @@ function getTargetTriple() {
 }
 
 function findCodexPath() {
-  var override = process.env.CLAY_CODEX_PATH;
-  if (override) {
-    if (fs.existsSync(override)) {
-      console.log("[codex-app-server] Using CLAY_CODEX_PATH binary:", override);
-      return override;
-    }
-    console.warn("[codex-app-server] CLAY_CODEX_PATH does not exist, falling back to bundled codex:", override);
-  }
+  var discovery = require("./discovery");
+  var override = discovery.explicitEntry(process.env, "CLAY_CODEX_PATH", false);
+  if (override !== undefined) return override;
 
   var triple = getTargetTriple();
   if (!triple) throw new Error("Unsupported platform: " + process.platform + "/" + process.arch);
@@ -74,7 +69,7 @@ function findCodexPath() {
       path.join(vendorRoot, triple, "codex", binaryName),
     ];
     for (var i = 0; i < candidates.length; i++) {
-      if (fs.existsSync(candidates[i])) {
+      if (discovery.validEntry(candidates[i], false)) {
         console.log("[codex-app-server] Using bundled codex binary:", candidates[i]);
         return candidates[i];
       }

package/lib/yoke/configuration.js

@@ -0,0 +1,13 @@
+// Serializable descriptions of implemented provider controls. Legacy setting
+// keys and message names describe persistence compatibility, never authority.
+var claude = {
+  auto: true,
+  permissionModes: [{ value: 'default', label: 'Ask' }, { value: 'plan', label: 'Plan' }, { value: 'acceptEdits', label: 'Auto-accept edits' }],
+  thinking: { options: ['disabled', 'adaptive', 'budget'], budget: true },
+};
+var codex = {
+  approval: { options: [{ value: 'never', label: 'Auto' }, { value: 'untrusted', label: 'Untrusted' }, { value: 'on-request', label: 'Ask' }], state: 'codexApproval', message: 'set_codex_approval', key: 'approval' },
+  sandbox: { options: [{ value: 'read-only', label: 'Read Only' }, { value: 'workspace-write', label: 'Workspace' }, { value: 'danger-full-access', label: 'Full Access' }], state: 'codexSandbox', message: 'set_codex_sandbox', key: 'sandbox' },
+  webSearch: { options: [{ value: 'disabled', label: 'Off' }, { value: 'cached', label: 'Cached' }, { value: 'live', label: 'Live' }], state: 'codexWebSearch', message: 'set_codex_websearch', key: 'webSearch' },
+};
+module.exports = { claude: claude, codex: codex };

package/lib/yoke/discovery.js

@@ -0,0 +1,70 @@
+// Installation resolution shared by adapter creation, startup and product UI.
+// This never starts a provider; callers may replace resolvers for isolated tests.
+var fs = require('fs');
+var cp = require('child_process');
+function onPath(binary, user) {
+  try {
+    if (user && !/^[a-z_][a-z0-9_-]*\$?$/i.test(user)) return null;
+    var command = user ? 'su' : process.platform === 'win32' ? 'where' : 'which';
+    var args = user ? ['-', user, '-c', 'which ' + binary] : [binary];
+    if (!/^[a-zA-Z0-9_.-]+$/.test(binary)) return null;
+    var result = cp.execFileSync(command, args, { encoding: 'utf8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] });
+    return String(result || '').trim().split(/\r?\n/)[0] || null;
+  } catch (error) { return null; }
+}
+// Native commands require an executable regular file. SDK-owned JavaScript
+// entries are readable files launched through Node, not native executables.
+function validEntry(file, script) {
+  try {
+    if (typeof file !== 'string' || !file || !fs.statSync(file).isFile()) return false;
+    fs.accessSync(file, script && /\.(?:c|m)?js$/i.test(file) ? fs.constants.R_OK : fs.constants.X_OK);
+    return true;
+  } catch (error) { return false; }
+}
+function explicitEntry(env, name, script) {
+  if (!Object.prototype.hasOwnProperty.call(env, name)) return undefined;
+  if (!validEntry(env[name], script)) throw new Error('Invalid explicit provider executable: ' + name);
+  return env[name];
+}
+function pathResolver(binary, override) {
+  return function(options) {
+    options = options || {};
+    var env = options.env || process.env;
+    if (!options.user && override) {
+      var explicit = explicitEntry(env, override, false);
+      if (explicit !== undefined) return explicit;
+    }
+    var resolved = onPath(binary, options.user);
+    return options.user || validEntry(resolved, false) ? resolved : null;
+  };
+}
+function bundledResolver(find, binary) {
+  return function(options) {
+    options = options || {};
+    // The mapped account cannot inherit the daemon account's installation.
+    if (options.user) return onPath(binary, options.user);
+    // The runtime resolver owns all fallback policy. Adding a discovery-only
+    // PATH fallback would advertise a runtime that its adapter cannot start.
+    return find();
+  };
+}
+function acpResolver(vendor) {
+  return function(options) {
+    if (options && options.user) return null;
+    var profiles = require('./acp-agent-profiles');
+    return profiles.findAcpAgentPath(profiles.getAcpAgentProfile(vendor));
+  };
+}
+function installed(options) {
+  var registry = options && options.registry || require('./vendor-registry').VENDOR_REGISTRY;
+  var result = {};
+  Object.keys(registry).forEach(function(vendor) {
+    var info = registry[vendor];
+    result[vendor] = false;
+    if (options && options.user && info.osUserIsolation !== true) return;
+    if (typeof info.resolveExecutable !== 'function') return;
+    try { result[vendor] = !!info.resolveExecutable(options || {}); } catch (error) {}
+  });
+  return result;
+}
+module.exports = { installed: installed, pathResolver: pathResolver, bundledResolver: bundledResolver, acpResolver: acpResolver, validEntry: validEntry, explicitEntry: explicitEntry };

package/lib/yoke/errors.js

@@ -0,0 +1,8 @@
+function classify(provider, text) {
+  var service = require('./provider-contract').resolve(provider).classifyError;
+  return typeof service === 'function' ? service(text) : null;
+}
+function contextOverflow(error) {
+  return /prompt is too long|context_length|maximum context length/i.test(String(error || ""));
+}
+module.exports = { contextOverflow: contextOverflow, classify: classify };

package/lib/yoke/host-environment.js

@@ -0,0 +1,7 @@
+// Provider compatibility at the host boundary. No effects occur on import.
+function prepare(env) { delete env.CLAUDECODE; }
+function reaper(env) {
+  return { idleMs: Number(env.CLAY_ADAPTER_IDLE_MS) || Number(env.CLAY_CODEX_IDLE_MS) || 5 * 60 * 1000,
+    reapMs: Number(env.CLAY_ADAPTER_REAPER_MS) || Number(env.CLAY_CODEX_REAPER_MS) || 60 * 1000 };
+}
+module.exports = { prepare: prepare, reaper: reaper };

package/lib/yoke/index.js

@@ -16,11 +16,12 @@ var createGrokAdapter = require("./adapters/grok").createGrokAdapter;
 var createCopilotAdapter = require("./adapters/copilot").createCopilotAdapter;
 var createQwenAdapter = require("./adapters/qwen").createQwenAdapter;
 var createJunieAdapter = require("./adapters/junie").createJunieAdapter;
+var createMuseAdapter = require("./adapters/muse").createMuseAdapter;
 var createKiroAdapter = require("./adapters/kiro").createKiroAdapter;
 
 // Keep the first session in a new project predictable. This order is also
 // used by the UI when a project has no remembered vendor yet.
-var DEFAULT_VENDOR_ORDER = ["claude", "codex", "grok", "kimi", "copilot", "qwen", "junie", "antigravity", "opencode", "kiro"];
+var DEFAULT_VENDOR_ORDER = ["claude", "codex", "muse", "grok", "kimi", "copilot", "qwen", "junie", "antigravity", "opencode", "kiro"];
 
 function resolveDefaultVendor(availableVendors) {
   availableVendors = availableVendors || {};
@@ -97,6 +98,8 @@ function createAdapter(opts) {
     adapter = createJunieAdapter(opts);
   } else if (vendor === "kiro") {
     adapter = createKiroAdapter(opts);
+  } else if (vendor === "muse") {
+    adapter = createMuseAdapter(opts);
   } else {
     throw new Error("[YOKE] Unknown adapter vendor: " + vendor);
   }
@@ -262,6 +265,7 @@ function checkAuth() {
     qwen: !!lookupBinary("qwen"),
     junie: !!lookupBinary("junie"),
     kiro: checkKiro(),
+    muse: null,
   };
   logAuthCheck(_authCache);
   return _authCache;
@@ -280,54 +284,8 @@ function checkAuth() {
 var _installedCache = null;
 
 function checkInstalled() {
-  if (_installedCache) return _installedCache;
-
-  var fs = require("fs");
-  var execFileSync = require("child_process").execFileSync;
-  var result = { claude: false, codex: false, antigravity: false, opencode: false, kimi: false, grok: false, copilot: false, qwen: false, junie: false, kiro: false };
-  try {
-    if (process.platform === "win32") execFileSync("where", ["claude"], { timeout: 3000, stdio: ["pipe", "pipe", "pipe"] });
-    else execFileSync("which", ["claude"], { timeout: 3000, stdio: ["pipe", "pipe", "pipe"] });
-    result.claude = true;
-  } catch (e) {}
-  try {
-    var findKiroPath = require("./kiro-acp-server").findKiroPath;
-    var kiroBin = findKiroPath();
-    if (kiroBin && fs.existsSync(kiroBin)) result.kiro = true;
-  } catch (e) {}
-  try {
-    var codexBin = null;
-    try {
-      var findCodexPath = require("./codex-app-server").findCodexPath;
-      codexBin = findCodexPath();
-      if (codexBin && fs.existsSync(codexBin)) {
-        result.codex = true;
-      }
-    } catch (e) {}
-
-    if (!result.codex) {
-      var whichOut = process.platform === "win32"
-        ? execFileSync("where", ["codex"], { timeout: 3000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] })
-        : execFileSync("which", ["codex"], { timeout: 3000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-      if (whichOut.trim()) result.codex = true;
-    }
-  } catch (e) {}
-  try {
-    var antigravityBinary = process.platform === "win32"
-      ? execFileSync("where", ["agy"], { timeout: 3000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] })
-      : execFileSync("which", ["agy"], { timeout: 3000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-    result.antigravity = !!antigravityBinary.trim();
-  } catch (e) {}
-  var acpVendorKeys = ["opencode", "kimi", "grok", "copilot", "qwen", "junie"];
-  for (var acpIndex = 0; acpIndex < acpVendorKeys.length; acpIndex++) {
-    try {
-      var acpProfiles = require("./acp-agent-profiles");
-      var acpVendor = acpVendorKeys[acpIndex];
-      result[acpVendor] = !!acpProfiles.findAcpAgentPath(acpProfiles.getAcpAgentProfile(acpVendor));
-    } catch (e) {}
-  }
-  _installedCache = result;
-  return result;
+  if (!_installedCache) _installedCache = require("./discovery").installed();
+  return _installedCache;
 }
 
 function invalidateAuthCache() {
@@ -352,7 +310,7 @@ function createAdapters(opts) {
   // Tests can supply a fixed installation snapshot without probing or spawning
   // vendor binaries; production callers always use the cached host scan.
   var installed = opts._installed || checkInstalled();
-  var auth = { claude: false, codex: false, antigravity: false, opencode: false, kimi: false, grok: false, copilot: false, qwen: false, junie: false, kiro: false };
+  var auth = { claude: false, codex: false, antigravity: false, opencode: false, kimi: false, grok: false, copilot: false, qwen: false, junie: false, kiro: false, muse: false };
   var adapters = {};
 
   function supportsConfiguredIsolation(vendor) {
@@ -390,7 +348,7 @@ function createAdapters(opts) {
     }
   }
 
-  var subprocessVendors = ["antigravity", "opencode", "kimi", "grok", "copilot", "qwen", "junie"];
+  var subprocessVendors = ["antigravity", "opencode", "kimi", "grok", "copilot", "qwen", "junie", "muse"];
   for (var subprocessIndex = 0; subprocessIndex < subprocessVendors.length; subprocessIndex++) {
     var subprocessVendor = subprocessVendors[subprocessIndex];
     var subprocessInfo = vendorRegistry.getVendorInfo(subprocessVendor);