clay-server 2.47.0-beta.6 → 3.0.0-beta.2

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

@@ -110,7 +110,10 @@ function CodexAppServer(executablePath, opts) {
   this.rl = null;
   this.nextId = 1;
   this.pendingRequests = {};  // id -> { resolve, reject, timer }
-  this.eventHandler = null;   // function(notification) for server-initiated events
+  // One app-server process is shared by every Codex session in a project.
+  // Route server-initiated events by threadId so a temporary query (such as
+  // title generation) cannot replace the handler for a long-lived session.
+  this.handlers = [];         // [{ threadId, fn }]
   this.executablePath = executablePath || findCodexPath();
   this.opts = opts || {};
   this.started = false;
@@ -215,20 +218,67 @@ CodexAppServer.prototype._handleMessage = function(msg) {
 
   // Server-initiated request (has id + method) or notification (has method, no id)
   if (msg.method) {
-    if (this.eventHandler) {
-      this.eventHandler(msg);
+    var params = msg.params || {};
+    var threadId = params.threadId
+      || (params.thread && params.thread.id)
+      || (params.turn && params.turn.threadId)
+      || null;
+    var targets;
+    if (threadId) {
+      targets = this.handlers.filter(function(handler) {
+        return handler.threadId === threadId;
+      });
     } else {
-      console.log("[codex-app-server] Unhandled event:", msg.method);
+      // Process-wide events such as auth failures belong to every live query.
+      targets = this.handlers.slice();
     }
+
+    if (!targets.length) {
+      if (msg.id !== undefined && msg.id !== null) {
+        console.warn("[codex-app-server] No handler for request " + msg.method + " (thread=" + (threadId || "none") + "), rejecting");
+        this.respondError(msg.id, -32001, "No active handler for thread " + (threadId || "none"));
+      } else {
+        console.log("[codex-app-server] Unhandled event:", msg.method);
+      }
+      return;
+    }
+
+    // A JSON-RPC request must be answered exactly once. Notifications may fan
+    // out when they are process-wide and intentionally have no thread id.
+    if (msg.id !== undefined && msg.id !== null) {
+      try {
+        targets[0].fn(msg);
+      } catch (e) {
+        console.error("[codex-app-server] Handler threw for " + msg.method + ":", e && e.message ? e.message : e);
+        this.respondError(msg.id, -32000, "Handler error");
+      }
+      return;
+    }
+    targets.forEach(function(handler) {
+      try { handler.fn(msg); } catch (e) {
+        console.error("[codex-app-server] Handler threw for " + msg.method + ":", e && e.message ? e.message : e);
+      }
+    });
   }
 };
 
+CodexAppServer.prototype.addHandler = function(fn) {
+  var entry = { threadId: null, fn: fn };
+  this.handlers.push(entry);
+  return entry;
+};
+
+CodexAppServer.prototype.removeHandler = function(entry) {
+  var index = this.handlers.indexOf(entry);
+  if (index !== -1) this.handlers.splice(index, 1);
+};
+
 // The definitive "not logged in" signal from Codex is a 401 on its own
 // responses endpoint, which only appears on stderr (not as a JSON-RPC error).
 // When we see it, synthesize an error event so the adapter maps it to the
 // neutral auth_required yokeType. Deduped so a burst of 401 retries collapses.
 CodexAppServer.prototype._maybeSignalAuthError = function(line) {
-  if (!this.eventHandler || !line || this._authSignalSent) return;
+  if (!this.handlers.length || !line || this._authSignalSent) return;
   var isAuth = /missing bearer|token[_ ]?revoked|invalidated oauth|please sign in again/i.test(line)
     || (/\b401\b/.test(line) && /unauthorized|responses|openai\.com|chatgpt\.com/i.test(line));
   if (!isAuth) return;
@@ -236,7 +286,7 @@ CodexAppServer.prototype._maybeSignalAuthError = function(line) {
   var self = this;
   setTimeout(function () { self._authSignalSent = false; }, 15000);
   try {
-    this.eventHandler({ method: "error", params: { error: { codexErrorInfo: "unauthorized", message: line } } });
+    this._handleMessage({ method: "error", params: { error: { codexErrorInfo: "unauthorized", message: line } } });
   } catch (e) {}
 };
 

package/lib/yoke/index.js

@@ -377,6 +377,7 @@ module.exports = {
   invalidateAuthCache: invalidateAuthCache,
   VENDOR_REGISTRY: vendorRegistry.VENDOR_REGISTRY,
   getVendorInfo: vendorRegistry.getVendorInfo,
+  clampEffort: vendorRegistry.clampEffort,
   TOOL_POLICIES: iface.TOOL_POLICIES,
   validateAdapter: iface.validateAdapter,
   validateQueryHandle: iface.validateQueryHandle,

package/lib/yoke/skill-discovery.js

@@ -0,0 +1,196 @@
+// Cross-vendor skill discovery
+// ----------------------------
+// Skills remain in their vendor-owned directories. This module only builds a
+// merged view so every YOKE adapter can expose the same installed skills.
+
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+
+function defaultHomeDir() {
+  try { return require("../config").REAL_HOME; } catch (e) { return os.homedir(); }
+}
+
+function unquote(value) {
+  var text = String(value || "").trim();
+  if ((text[0] === '"' && text[text.length - 1] === '"') ||
+      (text[0] === "'" && text[text.length - 1] === "'")) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function readMetadata(skillPath, fallbackName) {
+  var content;
+  try { content = fs.readFileSync(skillPath, "utf8"); } catch (e) { return null; }
+  var name = fallbackName;
+  var description = "";
+  var frontmatter = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---(?:\s*\r?\n|$)/);
+  if (frontmatter) {
+    var nameMatch = frontmatter[1].match(/^name:\s*(.+)$/m);
+    var descriptionMatch = frontmatter[1].match(/^description:\s*(.+)$/m);
+    if (nameMatch) name = unquote(nameMatch[1]) || fallbackName;
+    if (descriptionMatch) description = unquote(descriptionMatch[1]);
+  }
+  if (!description) {
+    var heading = content.match(/^#\s+(.+)$/m);
+    if (heading) description = heading[1].trim();
+  }
+  return { name: name, description: description };
+}
+
+function scanRoot(root, source, merged) {
+  var entries;
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch (e) { return; }
+  entries.sort(function(a, b) { return a.name.localeCompare(b.name); });
+  for (var i = 0; i < entries.length; i++) {
+    var entry = entries[i];
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    var skillPath = path.join(root, entry.name, "SKILL.md");
+    var metadata = readMetadata(skillPath, entry.name);
+    if (!metadata) continue;
+    merged[metadata.name] = {
+      name: metadata.name,
+      path: skillPath,
+      description: metadata.description,
+      source: source,
+    };
+  }
+}
+
+function getSkillRoots(cwd, opts) {
+  var homeDir = (opts && opts.homeDir) || defaultHomeDir();
+  var roots = [
+    { path: path.join(homeDir, ".codex", "skills"), source: "codex-user" },
+    { path: path.join(homeDir, ".claude", "skills"), source: "claude-user" },
+  ];
+  if (cwd) {
+    roots.push({ path: path.join(cwd, "skills"), source: "project" });
+    roots.push({ path: path.join(cwd, ".claude", "skills"), source: "claude-project" });
+  }
+  return roots;
+}
+
+function discoverSkills(cwd, opts) {
+  var merged = {};
+  var roots = getSkillRoots(cwd, opts);
+  for (var i = 0; i < roots.length; i++) scanRoot(roots[i].path, roots[i].source, merged);
+  return Object.keys(merged).sort().map(function(name) { return merged[name]; });
+}
+
+function indexSkills(skills) {
+  var indexed = {};
+  for (var i = 0; i < skills.length; i++) indexed[skills[i].name] = skills[i];
+  return indexed;
+}
+
+function findSkillReferences(text, skills) {
+  if (typeof text !== "string") return [];
+  var indexed = Array.isArray(skills) ? indexSkills(skills) : skills;
+  var found = [];
+  var seen = {};
+  var match;
+  var pattern = /\$([a-zA-Z0-9_-]+)/g;
+  while ((match = pattern.exec(text)) !== null) {
+    var skill = indexed[match[1]];
+    if (!skill || seen[skill.name]) continue;
+    seen[skill.name] = true;
+    found.push(skill);
+  }
+  return found;
+}
+
+function buildSkillIndex(skills) {
+  if (!skills.length) return "";
+  var lines = [
+    "Available shared skills. When a task matches a description, read that SKILL.md with your file tools before proceeding. A user may also invoke one with $skill-name:",
+  ];
+  for (var i = 0; i < skills.length; i++) {
+    var suffix = skills[i].description ? " — " + skills[i].description.replace(/\s+/g, " ") : "";
+    lines.push("- $" + skills[i].name + suffix + " — " + skills[i].path);
+  }
+  return lines.join("\n");
+}
+
+function readReferencedSkills(text, skills, maxChars) {
+  var references = findSkillReferences(text, skills);
+  var remaining = maxChars || 32768;
+  var blocks = [];
+  for (var i = 0; i < references.length && remaining > 0; i++) {
+    var content;
+    try { content = fs.readFileSync(references[i].path, "utf8"); } catch (e) { continue; }
+    var header = "<shared-skill name=\"" + references[i].name + "\" source=\"" + references[i].source + "\">\n";
+    var footer = "\n</shared-skill>";
+    var available = Math.max(0, remaining - header.length - footer.length);
+    if (!available) break;
+    if (content.length > available) {
+      var marker = "\n[Skill truncated by Clay]";
+      content = content.slice(0, Math.max(0, available - marker.length)) + marker.slice(0, available);
+    }
+    var block = header + content + footer;
+    blocks.push(block);
+    remaining -= block.length;
+  }
+  return blocks.join("\n\n");
+}
+
+function lstatOrNull(target) {
+  try { return fs.lstatSync(target); } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
+}
+
+function ensureClaudeCodexPlugin(opts) {
+  var homeDir = (opts && opts.homeDir) || defaultHomeDir();
+  var source = path.join(homeDir, ".codex", "skills");
+  try {
+    if (!fs.statSync(source).isDirectory()) return null;
+  } catch (e) { return null; }
+
+  var pluginDir = path.join(homeDir, ".clay", "skill-bridge", "codex");
+  var bridgeRoot = path.dirname(pluginDir);
+  var manifestDir = path.join(pluginDir, ".claude-plugin");
+  var manifestPath = path.join(manifestDir, "plugin.json");
+  var skillsLink = path.join(pluginDir, "skills");
+  var manifest = JSON.stringify({ name: "codex", version: "1.0.0", description: "Codex skills shared by Clay" }, null, 2) + "\n";
+
+  try {
+    fs.mkdirSync(path.join(homeDir, ".clay"), { recursive: true });
+    var bridgeStat = lstatOrNull(bridgeRoot);
+    if (bridgeStat && (!bridgeStat.isDirectory() || bridgeStat.isSymbolicLink())) return null;
+    if (!bridgeStat) fs.mkdirSync(bridgeRoot);
+    var pluginStat = lstatOrNull(pluginDir);
+    if (pluginStat && (!pluginStat.isDirectory() || pluginStat.isSymbolicLink())) return null;
+    if (!pluginStat) fs.mkdirSync(pluginDir);
+    var manifestDirStat = lstatOrNull(manifestDir);
+    if (manifestDirStat && (!manifestDirStat.isDirectory() || manifestDirStat.isSymbolicLink())) return null;
+    if (!manifestDirStat) fs.mkdirSync(manifestDir);
+    var manifestStat = lstatOrNull(manifestPath);
+    if (manifestStat) {
+      if (!manifestStat.isFile() || fs.readFileSync(manifestPath, "utf8") !== manifest) return null;
+    } else {
+      fs.writeFileSync(manifestPath, manifest, { mode: 0o600, flag: "wx" });
+    }
+    var stat = lstatOrNull(skillsLink);
+    if (stat) {
+      if (!stat.isSymbolicLink() || path.resolve(pluginDir, fs.readlinkSync(skillsLink)) !== path.resolve(source)) return null;
+    } else {
+      fs.symlinkSync(source, skillsLink, "dir");
+    }
+  } catch (e) {
+    if (e.code !== "ENOENT") console.error("[yoke/skills] Failed to create Claude Codex skill bridge:", e.message);
+    return null;
+  }
+  return pluginDir;
+}
+
+module.exports = {
+  buildSkillIndex: buildSkillIndex,
+  discoverSkills: discoverSkills,
+  ensureClaudeCodexPlugin: ensureClaudeCodexPlugin,
+  findSkillReferences: findSkillReferences,
+  getSkillRoots: getSkillRoots,
+  indexSkills: indexSkills,
+  readReferencedSkills: readReferencedSkills,
+};

package/lib/yoke/vendor-registry.js

@@ -2,6 +2,11 @@
 // needs metadata before adapter initialization should read it from here.
 // Do not import adapters into this module.
 
+// Canonical effort ordering used to clamp a level onto a vendor that does
+// not support it (e.g. codex "minimal" -> claude "low", claude "max" ->
+// codex "xhigh").
+var EFFORT_ORDER = ["minimal", "low", "medium", "high", "xhigh", "max"];
+
 var VENDOR_REGISTRY = {
   claude: {
     displayName: "Claude Code",
@@ -9,6 +14,7 @@ var VENDOR_REGISTRY = {
     binaryName: "claude",
     avatar: "/claude-code-avatar.png",
     sessionModes: ["gui", "tui"],
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
     osUserIsolation: true,
     usageDashboard: {
       icon: "/claude-code-avatar.png",
@@ -24,6 +30,7 @@ var VENDOR_REGISTRY = {
     binaryName: "codex",
     avatar: "/codex-avatar.png",
     sessionModes: ["gui"],
+    effortLevels: ["minimal", "low", "medium", "high", "xhigh"],
     osUserIsolation: true,
     usageDashboard: {
       icon: "/codex-avatar.png",
@@ -39,6 +46,7 @@ var VENDOR_REGISTRY = {
     binaryName: "kiro-cli",
     avatar: "/kiro-avatar.svg",
     sessionModes: ["gui"],
+    effortLevels: [],
     osUserIsolation: false,
     usageDashboard: null,
     rateLimitTracking: false,
@@ -49,7 +57,33 @@ function getVendorInfo(vendor) {
   return VENDOR_REGISTRY[vendor] || null;
 }
 
+// Clamp an effort level onto what the vendor supports. Returns the level
+// itself when supported, the nearest supported level by the canonical order
+// otherwise, and undefined when the vendor has no effort concept (or the
+// input is not a known level -- never forward junk to an adapter).
+function clampEffort(vendor, effort) {
+  if (!effort) return undefined;
+  var info = VENDOR_REGISTRY[vendor];
+  var levels = (info && info.effortLevels) || [];
+  if (levels.length === 0) return undefined;
+  if (levels.indexOf(effort) !== -1) return effort;
+  var position = EFFORT_ORDER.indexOf(effort);
+  if (position === -1) return undefined;
+  var nearest = levels[0];
+  var nearestDistance = Infinity;
+  for (var i = 0; i < levels.length; i++) {
+    var distance = Math.abs(EFFORT_ORDER.indexOf(levels[i]) - position);
+    if (distance < nearestDistance) {
+      nearestDistance = distance;
+      nearest = levels[i];
+    }
+  }
+  return nearest;
+}
+
 module.exports = {
   VENDOR_REGISTRY: VENDOR_REGISTRY,
   getVendorInfo: getVendorInfo,
+  clampEffort: clampEffort,
+  EFFORT_ORDER: EFFORT_ORDER,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "2.47.0-beta.6",
+  "version": "3.0.0-beta.2",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js",
@@ -53,7 +53,7 @@
     "@lydell/node-pty": "^1.2.0-beta.3",
     "@openai/codex": "^0.147.0",
     "imapflow": "^1.3.1",
-    "nodemailer": "^6.10.1",
+    "nodemailer": "^9.0.5",
     "qrcode-terminal": "^0.12.0",
     "web-push": "^3.6.7",
     "ws": "^8.18.0"