clay-server 2.32.0-beta.7 → 2.32.0-beta.8

package/lib/yoke/adapters/codex.js

@@ -3,8 +3,59 @@
 // Implements the YOKE interface using codex app-server protocol.
 // Bidirectional JSON-RPC over stdin/stdout enables interactive approval flows.
 
+var path = require("path");
+var fs = require("fs");
 var { CodexAppServer } = require("../codex-app-server");
 
+// --- Claude skill discovery ---
+// Finds Claude skills in ~/.claude/skills/ and <cwd>/.claude/skills/
+// so Codex can recognize $<skill-name> in user input.
+function discoverClaudeSkills(cwd) {
+  var skills = {};
+  var REAL_HOME;
+  try { REAL_HOME = require("../../config").REAL_HOME; } catch (e) { REAL_HOME = require("os").homedir(); }
+  var dirs = [
+    path.join(REAL_HOME, ".claude", "skills"),
+    path.join(cwd || "", ".claude", "skills"),
+  ];
+  for (var d = 0; d < dirs.length; d++) {
+    var base = dirs[d];
+    if (!base) continue;
+    var entries;
+    try { entries = fs.readdirSync(base, { withFileTypes: true }); } catch (e) { continue; }
+    for (var i = 0; i < entries.length; i++) {
+      var entry = entries[i];
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+      var skillMd = path.join(base, entry.name, "SKILL.md");
+      try {
+        fs.accessSync(skillMd, fs.constants.R_OK);
+        // project skills override global skills
+        skills[entry.name] = skillMd;
+      } catch (e) {}
+    }
+  }
+  return skills;
+}
+
+// Parse user text for $<skill-name> references.
+// Returns { text, skills: [{ name, path }] }
+function parseSkillRefs(text, availableSkills) {
+  if (typeof text !== "string") return { text: text, skills: [] };
+  var skills = [];
+  var seen = {};
+  var re = /\$([a-zA-Z0-9_-]+)/g;
+  var match;
+  while ((match = re.exec(text)) !== null) {
+    var name = match[1];
+    if (seen[name]) continue;
+    if (availableSkills[name]) {
+      seen[name] = true;
+      skills.push({ name: name, path: availableSkills[name] });
+    }
+  }
+  return { text: text, skills: skills };
+}
+
 // --- Event flattening ---
 // Converts app-server JSON-RPC notifications into flat objects with a yokeType field.
 //
@@ -463,13 +514,15 @@ function createCodexQueryHandle(appServer, queryOpts) {
       var cmdParams = msg.params || {};
       if (canUseTool) {
         canUseTool("Bash", { command: cmdParams.command }, {}).then(function(decision) {
-          appServer.respond(msg.id, isApproved(decision) ? "accept" : "decline");
+          var approved = isApproved(decision);
+          // Response must be wrapped in { decision: ... } object per app-server protocol
+          appServer.respond(msg.id, { decision: approved ? "accept" : "decline" });
         }).catch(function(err) {
           console.error("[yoke/codex] canUseTool error:", err.message);
-          appServer.respond(msg.id, "decline");
+          appServer.respond(msg.id, { decision: "decline" });
         });
       } else {
-        appServer.respond(msg.id, "accept");
+        appServer.respond(msg.id, { decision: "accept" });
       }
       return;
     }
@@ -480,13 +533,13 @@ function createCodexQueryHandle(appServer, queryOpts) {
       if (canUseTool) {
         var changeInfo = (fcParams.changes || []).map(function(c) { return c.kind + " " + c.path; }).join(", ");
         canUseTool("Edit", { changes: changeInfo, path: fcParams.path }, {}).then(function(decision) {
-          appServer.respond(msg.id, isApproved(decision) ? "accept" : "decline");
+          appServer.respond(msg.id, { decision: isApproved(decision) ? "accept" : "decline" });
         }).catch(function(err) {
           console.error("[yoke/codex] canUseTool error:", err.message);
-          appServer.respond(msg.id, "decline");
+          appServer.respond(msg.id, { decision: "decline" });
         });
       } else {
-        appServer.respond(msg.id, "accept");
+        appServer.respond(msg.id, { decision: "accept" });
       }
       return;
     }
@@ -584,6 +637,26 @@ function createCodexQueryHandle(appServer, queryOpts) {
           input = currentMessage;
         }
 
+        // Detect $<skill-name> references (Claude skills) and inject skill input items
+        var availableSkills = discoverClaudeSkills(queryOpts.cwd);
+        var skillItemsToInject = [];
+        var injected = {};
+        for (var ii = 0; ii < input.length; ii++) {
+          if (input[ii].type === "text" && input[ii].text) {
+            var parsed = parseSkillRefs(input[ii].text, availableSkills);
+            for (var si = 0; si < parsed.skills.length; si++) {
+              if (!injected[parsed.skills[si].name]) {
+                injected[parsed.skills[si].name] = true;
+                skillItemsToInject.push({ type: "skill", name: parsed.skills[si].name, path: parsed.skills[si].path });
+              }
+            }
+          }
+        }
+        if (skillItemsToInject.length > 0) {
+          console.log("[yoke/codex] injecting Claude skills:", skillItemsToInject.map(function(s) { return s.name; }).join(", "));
+          input = input.concat(skillItemsToInject);
+        }
+
         await appServer.send("turn/start", {
           threadId: state.threadId,
           input: input,
@@ -850,13 +923,51 @@ function createCodexAdapter(opts) {
           "gpt-5.2",
         ];
 
+        // Discover skills: built-in Codex skills + Claude skills
+        var skillNames = [];
+        try {
+          var REAL_HOME;
+          try { REAL_HOME = require("../../config").REAL_HOME; } catch (e) { REAL_HOME = require("os").homedir(); }
+          var claudeSkillsDir = require("path").join(REAL_HOME, ".claude", "skills");
+          var extraRoots = _cwd ? [{ cwd: _cwd, extraUserRoots: [claudeSkillsDir] }] : [];
+          var skillsResult = await _appServer.send("skills/list", {
+            cwds: _cwd ? [_cwd] : [],
+            forceReload: true,
+            perCwdExtraUserRoots: extraRoots,
+          }, 10000).catch(function(e) {
+            console.error("[codex] skills/list failed:", e.message);
+            return null;
+          });
+          // Response shape: { data: [{ cwd, skills: [{ name, ... }] }] }
+          if (skillsResult && skillsResult.data) {
+            for (var di = 0; di < skillsResult.data.length; di++) {
+              var entry = skillsResult.data[di];
+              if (!entry.skills) continue;
+              for (var sk = 0; sk < entry.skills.length; sk++) {
+                if (entry.skills[sk].name && skillNames.indexOf(entry.skills[sk].name) === -1) {
+                  skillNames.push(entry.skills[sk].name);
+                }
+              }
+            }
+          }
+          // Also discover Claude skills directly as fallback
+          var claudeSkills = discoverClaudeSkills(_cwd);
+          var claudeSkillNames = Object.keys(claudeSkills);
+          for (var csn = 0; csn < claudeSkillNames.length; csn++) {
+            if (skillNames.indexOf(claudeSkillNames[csn]) === -1) skillNames.push(claudeSkillNames[csn]);
+          }
+          console.log("[codex] Discovered skills:", skillNames.length, "(" + skillNames.slice(0, 5).join(", ") + (skillNames.length > 5 ? "..." : "") + ")");
+        } catch (e) {
+          console.error("[codex] Failed to discover skills:", e.message);
+        }
+
         _initPromise = null;
 
         return {
           models: _cachedModels,
           defaultModel: "gpt-5.4",
-          skills: [],
-          slashCommands: [],
+          skills: skillNames,
+          slashCommands: skillNames,
           fastModeState: null,
           capabilities: {
             thinking: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "2.32.0-beta.7",
+  "version": "2.32.0-beta.8",
   "description": "Self-hosted Claude Code in your browser. Multi-session, multi-user, push notifications.",
   "bin": {
     "clay-server": "./bin/cli.js",