clay-server 2.5.1 → 2.6.0

package/lib/public/modules/terminal.js

@@ -553,6 +553,13 @@ export function resetTerminals() {
   renderTabBar();
 }
 
+export function sendTerminalCommand(command) {
+  if (!activeTabId || !tabs.has(activeTabId)) return;
+  if (ctx.ws && ctx.connected) {
+    ctx.ws.send(JSON.stringify({ type: "term_input", id: activeTabId, data: command }));
+  }
+}
+
 export function setTerminalTheme(xtermTheme) {
   for (var tab of tabs.values()) {
     if (tab.xterm) {

package/lib/public/style.css

@@ -12,4 +12,5 @@
 @import url("css/highlight.css");
 @import url("css/server-settings.css");
 @import url("css/sticky-notes.css");
+@import url("css/skills.css");
 @import url("css/mobile-nav.css");

package/lib/sdk-bridge.js

@@ -53,6 +53,7 @@ function createSDKBridge(opts) {
   var pushModule = opts.pushModule;
   var getSDK = opts.getSDK;
   var dangerouslySkipPermissions = opts.dangerouslySkipPermissions || false;
+  var onProcessingChanged = opts.onProcessingChanged || function () {};
 
   // --- Skill discovery helpers ---
 
@@ -147,8 +148,8 @@ function createSDKBridge(opts) {
         send({ type: "slash_commands", commands: sm.slashCommands });
       }
       if (parsed.model) {
-        sm.currentModel = parsed.model;
-        send({ type: "model_info", model: parsed.model, models: sm.availableModels || [] });
+        sm.currentModel = sm._savedDefaultModel || parsed.model;
+        send({ type: "model_info", model: sm.currentModel, models: sm.availableModels || [] });
       }
       if (parsed.fast_mode_state) {
         sendAndRecord(session, { type: "fast_mode_state", state: parsed.fast_mode_state });
@@ -307,6 +308,7 @@ function createSDKBridge(opts) {
       session.activeTaskToolIds = {};
       session.taskIdMap = {};
       session.isProcessing = false;
+      onProcessingChanged();
       sendAndRecord(session, {
         type: "result",
         cost: parsed.total_cost_usd,
@@ -609,6 +611,7 @@ function createSDKBridge(opts) {
     } catch (err) {
       if (session.isProcessing) {
         session.isProcessing = false;
+        onProcessingChanged();
         if (err.name === "AbortError" || (session.abortController && session.abortController.signal.aborted)) {
           sendAndRecord(session, { type: "info", text: "Interrupted \u00b7 What should Claude do instead?" });
           sendAndRecord(session, { type: "done", code: 0 });
@@ -705,6 +708,7 @@ function createSDKBridge(opts) {
       sdk = await getSDK();
     } catch (e) {
       session.isProcessing = false;
+      onProcessingChanged();
       send({ type: "error", text: "Failed to load Claude SDK: " + (e.message || e) });
       sendAndRecord(session, { type: "done", code: 1 });
       sm.broadcastSessionList();
@@ -794,6 +798,7 @@ function createSDKBridge(opts) {
       console.error("[sdk-bridge] cliSessionId:", session.cliSessionId, "resume:", !!queryOptions.resume);
       console.error("[sdk-bridge] Stack:", e.stack || "(no stack)");
       session.isProcessing = false;
+      onProcessingChanged();
       session.queryInstance = null;
       session.messageQueue = null;
       session.abortController = null;
@@ -803,7 +808,7 @@ function createSDKBridge(opts) {
       return;
     }
 
-    processQueryStream(session).catch(function(err) {
+    session.streamPromise = processQueryStream(session).catch(function(err) {
     });
   }
 
@@ -929,30 +934,36 @@ function createSDKBridge(opts) {
       // No active query — just store the model for next startQuery
       sm.currentModel = model;
       send({ type: "model_info", model: model, models: sm.availableModels || [] });
-      send({ type: "config_state", model: sm.currentModel, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+      send({ type: "config_state", model: sm.currentModel, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
       return;
     }
     try {
       await session.queryInstance.setModel(model);
       sm.currentModel = model;
       send({ type: "model_info", model: model, models: sm.availableModels || [] });
-      send({ type: "config_state", model: sm.currentModel, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+      send({ type: "config_state", model: sm.currentModel, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
     } catch (e) {
       send({ type: "error", text: "Failed to switch model: " + (e.message || e) });
     }
   }
 
   async function setPermissionMode(session, mode) {
+    // When dangerouslySkipPermissions is active, ignore mode changes from UI
+    // to prevent accidentally downgrading from bypassPermissions
+    if (dangerouslySkipPermissions) {
+      send({ type: "config_state", model: sm.currentModel || "", mode: "bypassPermissions", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+      return;
+    }
     if (!session.queryInstance) {
       // No active query — just store the mode for next startQuery
       sm.currentPermissionMode = mode;
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
       return;
     }
     try {
       await session.queryInstance.setPermissionMode(mode);
       sm.currentPermissionMode = mode;
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
     } catch (e) {
       send({ type: "error", text: "Failed to set permission mode: " + (e.message || e) });
     }

package/lib/server.js

@@ -8,10 +8,160 @@ var { createProjectContext } = require("./project");
 
 var { CONFIG_DIR } = require("./config");
 
+var https = require("https");
+
 var publicDir = path.join(__dirname, "public");
 var bundledThemesDir = path.join(__dirname, "themes");
 var userThemesDir = path.join(CONFIG_DIR, "themes");
 
+// --- Skills proxy cache & helpers ---
+var skillsCache = {};
+
+function httpGet(url) {
+  return new Promise(function (resolve, reject) {
+    var mod = url.startsWith("https") ? https : http;
+    mod.get(url, { headers: { "User-Agent": "Clay/1.0" } }, function (resp) {
+      if (resp.statusCode >= 300 && resp.statusCode < 400 && resp.headers.location) {
+        return httpGet(resp.headers.location).then(resolve, reject);
+      }
+      var chunks = [];
+      resp.on("data", function (c) { chunks.push(c); });
+      resp.on("end", function () { resolve(Buffer.concat(chunks).toString("utf8")); });
+      resp.on("error", reject);
+    }).on("error", reject);
+  });
+}
+
+function fetchSkillsPage(url) {
+  return httpGet(url).then(function (html) {
+    // Data is inside self.__next_f.push() with escaped quotes: \"initialSkills\":[{\"source\":...}]
+    var marker = 'initialSkills';
+    var idx = html.indexOf(marker);
+    if (idx < 0) return { skills: [] };
+
+    // Find the start of the array: look for \\\":[
+    var arrStart = html.indexOf(':[', idx);
+    if (arrStart < 0) return { skills: [] };
+    arrStart += 1; // point to '['
+
+    // Find matching ']' — track bracket depth
+    var depth = 0;
+    var arrEnd = -1;
+    for (var i = arrStart; i < html.length; i++) {
+      var ch = html[i];
+      if (ch === '[') depth++;
+      else if (ch === ']') {
+        depth--;
+        if (depth === 0) { arrEnd = i + 1; break; }
+      }
+    }
+    if (arrEnd < 0) return { skills: [] };
+
+    var raw = html.substring(arrStart, arrEnd);
+    // Unescape: \\\" → " and \\\\ → backslash
+    var unescaped = raw.replace(/\\\\"/g, '__BSLASH_QUOTE__').replace(/\\"/g, '"').replace(/__BSLASH_QUOTE__/g, '\\"');
+
+    try {
+      return { skills: JSON.parse(unescaped) };
+    } catch (e) {
+      return { skills: [] };
+    }
+  });
+}
+
+function fetchSkillDetail(url) {
+  return httpGet(url).then(function (html) {
+    var result = {};
+
+    // Title: "skill-name by owner/repo"
+    var titleMatch = html.match(/<title>([^<]+)<\/title>/);
+    if (titleMatch) {
+      var parts = titleMatch[1].split(" by ");
+      result.name = parts[0].trim();
+    }
+
+    // Description from meta
+    var descMatch = html.match(/meta name="description" content="([^"]+)"/);
+    if (descMatch) result.description = descMatch[1];
+
+    // Install command
+    var cmdMatch = html.match(/npx skills add [^ ]+ --skill [^ "<]+/);
+    if (cmdMatch) result.command = cmdMatch[0];
+
+    // Weekly installs: "Weekly Installs</span></div><div ...>VALUE</div>"
+    var wiMatch = html.match(/Weekly Installs<\/span><\/div><div[^>]*>([\d,.]+K?)<\/div>/);
+    if (wiMatch) result.weeklyInstalls = wiMatch[1];
+
+    // GitHub Stars: after SVG icon, inside <span>X.XK</span>
+    var gsIdx = html.indexOf("GitHub Stars");
+    if (gsIdx > 0) {
+      var gsRegion = html.substring(gsIdx, gsIdx + 1000);
+      var gsVal = gsRegion.match(/<span>(\d[\d,.]*K?)<\/span>/);
+      if (gsVal) result.githubStars = gsVal[1];
+    }
+
+    // First Seen
+    var fsMatch = html.match(/First Seen<\/span><\/div><div[^>]*>([^<]+)<\/div>/);
+    if (fsMatch) result.firstSeen = fsMatch[1].trim();
+
+    // Repository: from title "by owner/repo"
+    if (titleMatch) {
+      var byParts = titleMatch[1].split(" by ");
+      if (byParts[1]) result.repository = byParts[1].trim();
+    }
+
+    // Security audits: "text-foreground truncate">NAME</span><span ...>STATUS</span>"
+    var audits = [];
+    var auditRegex = /class="text-sm font-medium text-foreground truncate">([^<]+)<\/span><span class="[^"]*">(\w+)<\/span>/g;
+    var am;
+    while ((am = auditRegex.exec(html)) !== null) {
+      audits.push({ name: am[1], status: am[2].toLowerCase() });
+    }
+    if (audits.length) result.audits = audits;
+
+    // Installed on: "text-foreground">NAME</span><span class="text-muted-foreground font-mono">COUNT</span>
+    var ioIdx = html.indexOf("Installed On");
+    if (ioIdx > 0) {
+      var ioRegion = html.substring(ioIdx, ioIdx + 3000);
+      var platforms = [];
+      var platRegex = /text-foreground">([^<]+)<\/span><span class="text-muted-foreground font-mono">([\d,.]+K?)<\/span>/g;
+      var pm;
+      while ((pm = platRegex.exec(ioRegion)) !== null) {
+        platforms.push({ name: pm[1], installs: pm[2] });
+      }
+      if (platforms.length) result.installedOn = platforms;
+    }
+
+    // SKILL.md content: rendered HTML inside the main content area
+    var skillMdIdx = html.indexOf("SKILL.md");
+    if (skillMdIdx > 0) {
+      // Find the prose content div after SKILL.md marker
+      var proseIdx = html.indexOf("prose", skillMdIdx);
+      if (proseIdx > 0) {
+        var proseStart = html.indexOf(">", proseIdx) + 1;
+        // Find the closing of the prose div (heuristic: next major section boundary)
+        var endMarkers = ["<div class=\"bg-background", "<div class=\"sticky"];
+        var proseEnd = html.length;
+        for (var em = 0; em < endMarkers.length; em++) {
+          var endIdx = html.indexOf(endMarkers[em], proseStart);
+          if (endIdx > 0 && endIdx < proseEnd) proseEnd = endIdx;
+        }
+        var rawMd = html.substring(proseStart, proseEnd);
+        // Rebase relative URLs to absolute (skills.sh base)
+        result.skillMd = rawMd
+          .replace(/src="(?!https?:\/\/|data:)([^"]+)"/g, function (m, p) {
+            return 'src="' + new URL(p, url).href + '"';
+          })
+          .replace(/href="(?!https?:\/\/|mailto:|#)([^"]+)"/g, function (m, p) {
+            return 'href="' + new URL(p, url).href + '"';
+          });
+      }
+    }
+
+    return result;
+  });
+}
+
 var MIME_TYPES = {
   ".html": "text/html",
   ".css": "text/css",
@@ -130,6 +280,21 @@ function createServer(opts) {
   var lanHost = opts.lanHost || null;
   var onAddProject = opts.onAddProject || null;
   var onRemoveProject = opts.onRemoveProject || null;
+  var onReorderProjects = opts.onReorderProjects || null;
+  var onSetProjectTitle = opts.onSetProjectTitle || null;
+  var onSetProjectIcon = opts.onSetProjectIcon || null;
+  var onGetServerDefaultEffort = opts.onGetServerDefaultEffort || null;
+  var onSetServerDefaultEffort = opts.onSetServerDefaultEffort || null;
+  var onGetProjectDefaultEffort = opts.onGetProjectDefaultEffort || null;
+  var onSetProjectDefaultEffort = opts.onSetProjectDefaultEffort || null;
+  var onGetServerDefaultModel = opts.onGetServerDefaultModel || null;
+  var onSetServerDefaultModel = opts.onSetServerDefaultModel || null;
+  var onGetProjectDefaultModel = opts.onGetProjectDefaultModel || null;
+  var onSetProjectDefaultModel = opts.onSetProjectDefaultModel || null;
+  var onGetServerDefaultMode = opts.onGetServerDefaultMode || null;
+  var onSetServerDefaultMode = opts.onSetServerDefaultMode || null;
+  var onGetProjectDefaultMode = opts.onGetProjectDefaultMode || null;
+  var onSetProjectDefaultMode = opts.onSetProjectDefaultMode || null;
   var onGetDaemonConfig = opts.onGetDaemonConfig || null;
   var onSetPin = opts.onSetPin || null;
   var onSetKeepAwake = opts.onSetKeepAwake || null;
@@ -286,6 +451,89 @@ function createServer(opts) {
       return;
     }
 
+    // Skills proxy: leaderboard list
+    if (req.method === "GET" && fullUrl === "/api/skills") {
+      var qs = req.url.indexOf("?") >= 0 ? req.url.substring(req.url.indexOf("?")) : "";
+      var tabParam = new URLSearchParams(qs).get("tab") || "all";
+      var tabPath = tabParam === "trending" ? "/trending" : tabParam === "hot" ? "/hot" : "/";
+      var cacheKey = "skills_" + tabParam;
+      var cached = skillsCache[cacheKey];
+      if (cached && Date.now() - cached.ts < 300000) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(cached.data);
+        return;
+      }
+      fetchSkillsPage("https://skills.sh" + tabPath).then(function (data) {
+        var json = JSON.stringify(data);
+        skillsCache[cacheKey] = { ts: Date.now(), data: json };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(json);
+      }).catch(function (err) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Failed to fetch skills: " + (err.message || err) }));
+      });
+      return;
+    }
+
+    // Skills proxy: search
+    if (req.method === "GET" && fullUrl.startsWith("/api/skills/search")) {
+      var sqsRaw = req.url.indexOf("?") >= 0 ? req.url.substring(req.url.indexOf("?")) : "";
+      var searchQ = new URLSearchParams(sqsRaw).get("q") || "";
+      if (!searchQ) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end('{"error":"missing q param"}');
+        return;
+      }
+      var searchCacheKey = "search_" + searchQ.toLowerCase();
+      var searchCached = skillsCache[searchCacheKey];
+      if (searchCached && Date.now() - searchCached.ts < 300000) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(searchCached.data);
+        return;
+      }
+      fetchSkillsPage("https://skills.sh/?q=" + encodeURIComponent(searchQ)).then(function (data) {
+        var json = JSON.stringify(data);
+        skillsCache[searchCacheKey] = { ts: Date.now(), data: json };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(json);
+      }).catch(function (err) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Failed to search skills: " + (err.message || err) }));
+      });
+      return;
+    }
+
+    // Skills proxy: skill detail
+    if (req.method === "GET" && fullUrl.startsWith("/api/skills/detail")) {
+      var qs2 = req.url.indexOf("?") >= 0 ? req.url.substring(req.url.indexOf("?")) : "";
+      var params2 = new URLSearchParams(qs2);
+      var detailSource = params2.get("source");
+      var detailSkill = params2.get("skill");
+      if (!detailSource || !detailSkill) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end('{"error":"missing source or skill param"}');
+        return;
+      }
+      var detailCacheKey = "detail_" + detailSource + "_" + detailSkill;
+      var detailCached = skillsCache[detailCacheKey];
+      if (detailCached && Date.now() - detailCached.ts < 300000) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(detailCached.data);
+        return;
+      }
+      var detailUrl = "https://skills.sh/" + encodeURIComponent(detailSource).replace(/%2F/g, "/") + "/" + encodeURIComponent(detailSkill);
+      fetchSkillDetail(detailUrl).then(function (data) {
+        var json = JSON.stringify(data);
+        skillsCache[detailCacheKey] = { ts: Date.now(), data: json };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(json);
+      }).catch(function (err) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Failed to fetch skill detail: " + (err.message || err) }));
+      });
+      return;
+    }
+
     // Root path — redirect to first project
     if (fullUrl === "/" && req.method === "GET") {
       if (!isAuthed(req, authToken)) {
@@ -494,13 +742,28 @@ function createServer(opts) {
     });
   });
 
+  // --- Debounced broadcast for processing status changes ---
+  var processingUpdateTimer = null;
+  function broadcastProcessingChange() {
+    if (processingUpdateTimer) clearTimeout(processingUpdateTimer);
+    processingUpdateTimer = setTimeout(function () {
+      processingUpdateTimer = null;
+      broadcastAll({
+        type: "projects_updated",
+        projects: getProjects(),
+        projectCount: projects.size,
+      });
+    }, 200);
+  }
+
   // --- Project management ---
-  function addProject(cwd, slug, title) {
+  function addProject(cwd, slug, title, icon) {
     if (projects.has(slug)) return false;
     var ctx = createProjectContext({
       cwd: cwd,
       slug: slug,
       title: title || null,
+      icon: icon || null,
       pushModule: pushModule,
       debug: debug,
       dangerouslySkipPermissions: dangerouslySkipPermissions,
@@ -512,8 +775,24 @@ function createServer(opts) {
         projects.forEach(function (ctx) { list.push(ctx.getStatus()); });
         return list;
       },
+      onProcessingChanged: broadcastProcessingChange,
       onAddProject: onAddProject,
       onRemoveProject: onRemoveProject,
+      onReorderProjects: onReorderProjects,
+      onSetProjectTitle: onSetProjectTitle,
+      onSetProjectIcon: onSetProjectIcon,
+      onGetServerDefaultEffort: onGetServerDefaultEffort,
+      onSetServerDefaultEffort: onSetServerDefaultEffort,
+      onGetProjectDefaultEffort: onGetProjectDefaultEffort,
+      onSetProjectDefaultEffort: onSetProjectDefaultEffort,
+      onGetServerDefaultModel: onGetServerDefaultModel,
+      onSetServerDefaultModel: onSetServerDefaultModel,
+      onGetProjectDefaultModel: onGetProjectDefaultModel,
+      onSetProjectDefaultModel: onSetProjectDefaultModel,
+      onGetServerDefaultMode: onGetServerDefaultMode,
+      onSetServerDefaultMode: onSetServerDefaultMode,
+      onGetProjectDefaultMode: onGetProjectDefaultMode,
+      onSetProjectDefaultMode: onSetProjectDefaultMode,
       onGetDaemonConfig: onGetDaemonConfig,
       onSetPin: onSetPin,
       onSetKeepAwake: onSetKeepAwake,
@@ -540,6 +819,22 @@ function createServer(opts) {
     return list;
   }
 
+  function reorderProjects(slugs) {
+    var ordered = new Map();
+    for (var i = 0; i < slugs.length; i++) {
+      var ctx = projects.get(slugs[i]);
+      if (ctx) ordered.set(slugs[i], ctx);
+    }
+    // Append any remaining (safety)
+    projects.forEach(function (ctx, slug) {
+      if (!ordered.has(slug)) ordered.set(slug, ctx);
+    });
+    projects.clear();
+    ordered.forEach(function (ctx, slug) {
+      projects.set(slug, ctx);
+    });
+  }
+
   function setProjectTitle(slug, title) {
     var ctx = projects.get(slug);
     if (!ctx) return false;
@@ -547,6 +842,13 @@ function createServer(opts) {
     return true;
   }
 
+  function setProjectIcon(slug, icon) {
+    var ctx = projects.get(slug);
+    if (!ctx) return false;
+    ctx.setIcon(icon);
+    return true;
+  }
+
   function setAuthToken(hash) {
     authToken = hash;
   }
@@ -572,7 +874,9 @@ function createServer(opts) {
     addProject: addProject,
     removeProject: removeProject,
     getProjects: getProjects,
+    reorderProjects: reorderProjects,
     setProjectTitle: setProjectTitle,
+    setProjectIcon: setProjectIcon,
     setAuthToken: setAuthToken,
     broadcastAll: broadcastAll,
     destroyAll: destroyAll,

package/lib/sessions.js

@@ -1,6 +1,7 @@
-const fs = require("fs");
-const path = require("path");
-const config = require("./config");
+var fs = require("fs");
+var path = require("path");
+var config = require("./config");
+var utils = require("./utils");
 
 function createSessionManager(opts) {
   var cwd = opts.cwd;
@@ -15,7 +16,7 @@ function createSessionManager(opts) {
   var skillNames = null;        // Claude-only skills to filter from slash menu
 
   // --- Session persistence (centralized in ~/.clay/sessions/{encoded-cwd}/) ---
-  var encodedCwd = cwd.replace(/\//g, "-");
+  var encodedCwd = utils.encodeCwd(cwd);
   var sessionsDir = path.join(config.CONFIG_DIR, "sessions", encodedCwd);
   fs.mkdirSync(sessionsDir, { recursive: true });
 
@@ -310,6 +311,10 @@ function createSessionManager(opts) {
     appendToSessionFile(session, obj);
     if (session.localId === activeSessionId) {
       send(obj);
+    } else if (session.isProcessing && !session._ioThrottle) {
+      session._ioThrottle = true;
+      send({ type: "session_io", id: session.localId });
+      setTimeout(function () { session._ioThrottle = false; }, 80);
     }
   }
 

package/lib/utils.js

@@ -0,0 +1,18 @@
+/**
+ * Shared utility functions.
+ */
+
+/**
+ * Encode a cwd path into a filesystem-safe directory/file name.
+ * Replaces forward slashes and dots with hyphens so that usernames
+ * like "jon.doe" don't break session/note lookups.
+ *
+ * Example: "/Users/jon.doe/my-project" -> "-Users-jon-doe-my-project"
+ */
+function encodeCwd(cwd) {
+  return cwd.replace(/[\/\.]/g, "-");
+}
+
+module.exports = {
+  encodeCwd: encodeCwd,
+};

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "clay-server",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "description": "Web UI for Claude Code. Any device. Push notifications.",
   "bin": {
-    "clay-server": "./bin/cli.js"
+    "clay-server": "./bin/cli.js",
+    "claude-relay": "./bin/claude-relay.js"
   },
   "scripts": {
     "dev": "node bin/cli.js --dev",