clay-server 2.7.2 → 2.8.2

package/lib/scheduler.js

@@ -0,0 +1,402 @@
+/**
+ * Loop Registry — unified storage for all Ralph Loops (one-off + scheduled).
+ *
+ * Stores loop records in ~/.clay/loops/{encodedCwd}.jsonl
+ * Each record represents a job defined via clay-ralph (PROMPT.md + JUDGE.md).
+ * Records with a `cron` field are checked every 30s and auto-triggered.
+ * Records without cron are one-off (standard Ralph Loop behavior).
+ */
+
+var fs = require("fs");
+var path = require("path");
+var { CONFIG_DIR } = require("./config");
+var { encodeCwd } = require("./utils");
+
+// --- Cron parser (5-field: minute hour day-of-month month day-of-week) ---
+
+function parseCronField(field, min, max) {
+  var values = [];
+  var parts = field.split(",");
+  for (var i = 0; i < parts.length; i++) {
+    var part = parts[i].trim();
+
+    // wildcard with step: */N
+    if (part.indexOf("/") !== -1) {
+      var slashParts = part.split("/");
+      var step = parseInt(slashParts[1], 10);
+      var rangeStr = slashParts[0];
+      var rangeMin = min;
+      var rangeMax = max;
+      if (rangeStr !== "*") {
+        var rp = rangeStr.split("-");
+        rangeMin = parseInt(rp[0], 10);
+        rangeMax = rp.length > 1 ? parseInt(rp[1], 10) : rangeMin;
+      }
+      for (var v = rangeMin; v <= rangeMax; v += step) {
+        values.push(v);
+      }
+      continue;
+    }
+
+    // wildcard
+    if (part === "*") {
+      for (var v = min; v <= max; v++) {
+        values.push(v);
+      }
+      continue;
+    }
+
+    // range: N-M
+    if (part.indexOf("-") !== -1) {
+      var rangeParts = part.split("-");
+      var from = parseInt(rangeParts[0], 10);
+      var to = parseInt(rangeParts[1], 10);
+      for (var v = from; v <= to; v++) {
+        values.push(v);
+      }
+      continue;
+    }
+
+    // single value
+    values.push(parseInt(part, 10));
+  }
+  return values;
+}
+
+function parseCron(expr) {
+  var fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5) return null;
+  return {
+    minutes: parseCronField(fields[0], 0, 59),
+    hours: parseCronField(fields[1], 0, 23),
+    daysOfMonth: parseCronField(fields[2], 1, 31),
+    months: parseCronField(fields[3], 1, 12),
+    daysOfWeek: parseCronField(fields[4], 0, 6),
+  };
+}
+
+function cronMatches(parsed, date) {
+  var minute = date.getMinutes();
+  var hour = date.getHours();
+  var dayOfMonth = date.getDate();
+  var month = date.getMonth() + 1;
+  var dayOfWeek = date.getDay();
+
+  return (
+    parsed.minutes.indexOf(minute) !== -1 &&
+    parsed.hours.indexOf(hour) !== -1 &&
+    parsed.daysOfMonth.indexOf(dayOfMonth) !== -1 &&
+    parsed.months.indexOf(month) !== -1 &&
+    parsed.daysOfWeek.indexOf(dayOfWeek) !== -1
+  );
+}
+
+/**
+ * Calculate next run time from a cron expression after a given date.
+ * Brute-force: check each minute for up to 366 days.
+ */
+function nextRunTime(cronExpr, after) {
+  var parsed = parseCron(cronExpr);
+  if (!parsed) return null;
+
+  var d = new Date(after || Date.now());
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+
+  var limit = 366 * 24 * 60;
+  for (var i = 0; i < limit; i++) {
+    if (cronMatches(parsed, d)) {
+      return d.getTime();
+    }
+    d.setMinutes(d.getMinutes() + 1);
+  }
+  return null;
+}
+
+// --- Loop Registry factory ---
+
+function createLoopRegistry(opts) {
+  var cwd = opts.cwd;
+  var onTrigger = opts.onTrigger;
+  var onChange = opts.onChange;
+
+  var encoded = encodeCwd(cwd);
+  var registryDir = path.join(CONFIG_DIR, "loops");
+  var registryPath = path.join(registryDir, encoded + ".jsonl");
+
+  var records = [];
+  var timerId = null;
+  var CHECK_INTERVAL = 30 * 1000;
+  var lastTriggeredMinute = {};
+
+  // --- Persistence (JSONL) ---
+
+  function load() {
+    try {
+      var raw = fs.readFileSync(registryPath, "utf8");
+      var lines = raw.trim().split("\n");
+      records = [];
+      for (var i = 0; i < lines.length; i++) {
+        if (!lines[i].trim()) continue;
+        try {
+          var rec = JSON.parse(lines[i]);
+          // Recalculate nextRunAt for scheduled records
+          if (rec.cron && rec.enabled) {
+            rec.nextRunAt = nextRunTime(rec.cron);
+          } else if (!rec.cron && rec.enabled && rec.date && rec.time && rec.source === "schedule") {
+            // One-off: recalculate from date+time
+            var dtP = rec.date.split("-");
+            var tmP = rec.time.split(":");
+            var runD = new Date(parseInt(dtP[0], 10), parseInt(dtP[1], 10) - 1, parseInt(dtP[2], 10), parseInt(tmP[0], 10), parseInt(tmP[1], 10), 0);
+            rec.nextRunAt = runD.getTime();
+          }
+          records.push(rec);
+        } catch (e) {
+          // skip malformed line
+        }
+      }
+    } catch (e) {
+      records = [];
+    }
+  }
+
+  function save() {
+    try {
+      fs.mkdirSync(registryDir, { recursive: true });
+      var lines = [];
+      for (var i = 0; i < records.length; i++) {
+        lines.push(JSON.stringify(records[i]));
+      }
+      var tmpPath = registryPath + ".tmp";
+      fs.writeFileSync(tmpPath, lines.join("\n") + "\n");
+      fs.renameSync(tmpPath, registryPath);
+    } catch (e) {
+      console.error("[loop-registry] Failed to save:", e.message);
+    }
+  }
+
+  // --- Timer (scheduled loops only) ---
+
+  function startTimer() {
+    if (timerId) return;
+    timerId = setInterval(function () {
+      tick();
+    }, CHECK_INTERVAL);
+    tick();
+  }
+
+  function stopTimer() {
+    if (timerId) {
+      clearInterval(timerId);
+      timerId = null;
+    }
+  }
+
+  function tick() {
+    var now = Date.now();
+    var nowMinuteKey = Math.floor(now / 60000);
+
+    for (var i = 0; i < records.length; i++) {
+      var rec = records[i];
+      if (!rec.enabled) continue;
+      if (!rec.nextRunAt) continue;
+      if (rec.nextRunAt > now) continue;
+
+      // Avoid double-trigger within same minute
+      var triggerKey = rec.id + "_" + nowMinuteKey;
+      if (lastTriggeredMinute[triggerKey]) continue;
+      lastTriggeredMinute[triggerKey] = true;
+
+      // Clean old trigger keys
+      var keys = Object.keys(lastTriggeredMinute);
+      for (var k = 0; k < keys.length; k++) {
+        var keyParts = keys[k].split("_");
+        var keyMinute = parseInt(keyParts[keyParts.length - 1], 10);
+        if (keyMinute < nowMinuteKey - 1) {
+          delete lastTriggeredMinute[keys[k]];
+        }
+      }
+
+      // Update nextRunAt
+      rec.lastRunAt = now;
+      if (rec.cron) {
+        rec.nextRunAt = nextRunTime(rec.cron, now);
+      } else {
+        // One-off schedule: disable after firing
+        rec.nextRunAt = null;
+        rec.enabled = false;
+      }
+      save();
+      if (onChange) onChange(records);
+
+      console.log("[loop-registry] Triggering scheduled loop: " + rec.name + " (" + rec.id + ")");
+      if (onTrigger) {
+        try { onTrigger(rec); } catch (e) {
+          console.error("[loop-registry] Trigger error:", e.message);
+        }
+      }
+    }
+  }
+
+  // --- CRUD ---
+
+  function register(data) {
+    var rec = {
+      id: data.id || ("loop_" + Date.now() + "_" + require("crypto").randomBytes(3).toString("hex")),
+      name: data.name || "Untitled",
+      task: data.task || "",
+      cron: data.cron || null,
+      enabled: data.cron ? (data.enabled !== false) : false,
+      maxIterations: data.maxIterations || 20,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      lastRunAt: null,
+      lastRunResult: null,
+      nextRunAt: null,
+      description: data.description || "",
+      date: data.date || null,
+      time: data.time || null,
+      allDay: data.allDay !== undefined ? data.allDay : true,
+      linkedTaskId: data.linkedTaskId || null,
+      craftingSessionId: data.craftingSessionId || null,
+      source: data.source || null,
+      color: data.color || null,
+      recurrenceEnd: data.recurrenceEnd || null,
+      runs: [],
+    };
+    if (rec.cron && rec.enabled) {
+      rec.nextRunAt = nextRunTime(rec.cron);
+    } else if (!rec.cron && rec.date && rec.time && rec.source === "schedule") {
+      // One-off schedule: compute nextRunAt from date + time
+      var dtParts = rec.date.split("-");
+      var tmParts = rec.time.split(":");
+      var runDate = new Date(parseInt(dtParts[0], 10), parseInt(dtParts[1], 10) - 1, parseInt(dtParts[2], 10), parseInt(tmParts[0], 10), parseInt(tmParts[1], 10), 0);
+      rec.nextRunAt = runDate.getTime();
+      rec.enabled = true;
+    }
+    records.push(rec);
+    save();
+    if (onChange) onChange(records);
+    return rec;
+  }
+
+  function update(id, data) {
+    var rec = getById(id);
+    if (!rec) return null;
+
+    if (data.name !== undefined) rec.name = data.name;
+    if (data.cron !== undefined) rec.cron = data.cron;
+    if (data.enabled !== undefined) rec.enabled = data.enabled;
+    if (data.maxIterations !== undefined) rec.maxIterations = data.maxIterations;
+    if (data.date !== undefined) rec.date = data.date;
+    if (data.recurrenceEnd !== undefined) rec.recurrenceEnd = data.recurrenceEnd;
+    rec.updatedAt = Date.now();
+    if (rec.cron && rec.enabled) {
+      rec.nextRunAt = nextRunTime(rec.cron);
+    } else if (!rec.cron && rec.date && rec.time && rec.source === "schedule") {
+      var dtP2 = rec.date.split("-");
+      var tmP2 = rec.time.split(":");
+      var runD2 = new Date(parseInt(dtP2[0], 10), parseInt(dtP2[1], 10) - 1, parseInt(dtP2[2], 10), parseInt(tmP2[0], 10), parseInt(tmP2[1], 10), 0);
+      rec.nextRunAt = runD2.getTime();
+      rec.enabled = true;
+    } else {
+      rec.nextRunAt = null;
+    }
+
+    save();
+    if (onChange) onChange(records);
+    return rec;
+  }
+
+  function updateRecord(id, data) {
+    var rec = getById(id);
+    if (!rec) return null;
+    var keys = Object.keys(data);
+    for (var i = 0; i < keys.length; i++) {
+      rec[keys[i]] = data[keys[i]];
+    }
+    save();
+    if (onChange) onChange(records);
+    return rec;
+  }
+
+  function remove(id) {
+    var idx = -1;
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].id === id) { idx = i; break; }
+    }
+    if (idx === -1) return false;
+    records.splice(idx, 1);
+    save();
+    if (onChange) onChange(records);
+    return true;
+  }
+
+  function toggleEnabled(id) {
+    var rec = getById(id);
+    if (!rec || !rec.cron) return null; // only toggle scheduled loops
+    rec.enabled = !rec.enabled;
+    rec.updatedAt = Date.now();
+    rec.nextRunAt = rec.enabled ? nextRunTime(rec.cron) : null;
+    save();
+    if (onChange) onChange(records);
+    return rec;
+  }
+
+  function recordRun(id, result) {
+    var rec = getById(id);
+    if (!rec) return;
+    rec.lastRunAt = result.startedAt || Date.now();
+    rec.lastRunResult = result.reason || null;
+    rec.runs.push({
+      startedAt: result.startedAt || rec.lastRunAt,
+      finishedAt: Date.now(),
+      result: result.reason || "unknown",
+      iterations: result.iterations || 0,
+    });
+    // Keep only last 20 run entries
+    if (rec.runs.length > 20) {
+      rec.runs = rec.runs.slice(-20);
+    }
+    save();
+    if (onChange) onChange(records);
+  }
+
+  function getAll() {
+    return records;
+  }
+
+  function getById(id) {
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].id === id) return records[i];
+    }
+    return null;
+  }
+
+  function getScheduled() {
+    var result = [];
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].cron) result.push(records[i]);
+    }
+    return result;
+  }
+
+  return {
+    load: load,
+    save: save,
+    startTimer: startTimer,
+    stopTimer: stopTimer,
+    register: register,
+    update: update,
+    updateRecord: updateRecord,
+    remove: remove,
+    toggleEnabled: toggleEnabled,
+    recordRun: recordRun,
+    getAll: getAll,
+    getById: getById,
+    getScheduled: getScheduled,
+    nextRunTime: nextRunTime,
+  };
+}
+
+module.exports = { createLoopRegistry: createLoopRegistry };

package/lib/sdk-bridge.js

@@ -487,8 +487,9 @@ function createSDKBridge(opts) {
   // --- SDK query lifecycle ---
 
   function handleCanUseTool(session, toolName, input, opts) {
-    // Ralph Loop: auto-approve all tools, deny interactive ones
-    if (session.loop && session.loop.active) {
+    // Ralph Loop execution: auto-approve all tools, deny interactive ones.
+    // Crafting sessions are interactive — user and Claude collaborate to build PROMPT.md / JUDGE.md.
+    if (session.loop && session.loop.active && session.loop.role !== "crafting") {
       if (toolName === "AskUserQuestion") {
         return Promise.resolve({ behavior: "deny", message: "Autonomous mode. Make your own decision." });
       }

package/lib/server.js

@@ -240,7 +240,10 @@ function serveStatic(urlPath, res) {
     var content = fs.readFileSync(filePath);
     var ext = path.extname(filePath);
     var mime = MIME_TYPES[ext] || "application/octet-stream";
-    res.writeHead(200, { "Content-Type": mime + "; charset=utf-8", "Cache-Control": "no-cache" });
+    res.writeHead(200, {
+      "Content-Type": mime + "; charset=utf-8",
+      "Cache-Control": "no-cache",
+    });
     res.end(content);
     return true;
   } catch (e) {
@@ -451,6 +454,50 @@ function createServer(opts) {
       return;
     }
 
+    // User profile
+    var profilePath = path.join(CONFIG_DIR, "profile.json");
+
+    if (req.method === "GET" && fullUrl === "/api/profile") {
+      var profile = { name: "", lang: "en-US", avatarColor: "#7c3aed", avatarStyle: "thumbs", avatarSeed: "" };
+      try {
+        var raw = fs.readFileSync(profilePath, "utf8");
+        var saved = JSON.parse(raw);
+        if (saved.name !== undefined) profile.name = saved.name;
+        if (saved.lang) profile.lang = saved.lang;
+        if (saved.avatarColor) profile.avatarColor = saved.avatarColor;
+        if (saved.avatarStyle) profile.avatarStyle = saved.avatarStyle;
+        if (saved.avatarSeed) profile.avatarSeed = saved.avatarSeed;
+      } catch (e) { /* file doesn't exist yet */ }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(profile));
+      return;
+    }
+
+    if (req.method === "PUT" && fullUrl === "/api/profile") {
+      var body = "";
+      req.on("data", function (chunk) { body += chunk; });
+      req.on("end", function () {
+        try {
+          var data = JSON.parse(body);
+          var profile = {};
+          if (typeof data.name === "string") profile.name = data.name.substring(0, 50);
+          if (typeof data.lang === "string") profile.lang = data.lang.substring(0, 10);
+          if (typeof data.avatarColor === "string" && /^#[0-9a-fA-F]{6}$/.test(data.avatarColor)) {
+            profile.avatarColor = data.avatarColor;
+          }
+          if (typeof data.avatarStyle === "string") profile.avatarStyle = data.avatarStyle.substring(0, 30);
+          if (typeof data.avatarSeed === "string") profile.avatarSeed = data.avatarSeed.substring(0, 30);
+          fs.writeFileSync(profilePath, JSON.stringify(profile, null, 2), "utf8");
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(profile));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid request" }));
+        }
+      });
+      return;
+    }
+
     // Skills proxy: leaderboard list
     if (req.method === "GET" && fullUrl === "/api/skills") {
       var qs = req.url.indexOf("?") >= 0 ? req.url.substring(req.url.indexOf("?")) : "";
@@ -491,8 +538,20 @@ function createServer(opts) {
         res.end(searchCached.data);
         return;
       }
-      fetchSkillsPage("https://skills.sh/?q=" + encodeURIComponent(searchQ)).then(function (data) {
-        var json = JSON.stringify(data);
+      // Reuse cached "all" tab data if available, otherwise fetch
+      var allCached = skillsCache["skills_all"];
+      var allPromise = (allCached && Date.now() - allCached.ts < 300000)
+        ? Promise.resolve(JSON.parse(allCached.data))
+        : fetchSkillsPage("https://skills.sh/");
+      allPromise.then(function (data) {
+        var q = searchQ.toLowerCase();
+        var filtered = (data.skills || []).filter(function (s) {
+          var name = (s.name || "").toLowerCase();
+          var source = (s.source || "").toLowerCase();
+          var skillId = (s.skillId || "").toLowerCase();
+          return name.indexOf(q) >= 0 || source.indexOf(q) >= 0 || skillId.indexOf(q) >= 0;
+        });
+        var json = JSON.stringify({ skills: filtered });
         skillsCache[searchCacheKey] = { ts: Date.now(), data: json };
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(json);
@@ -775,6 +834,68 @@ function createServer(opts) {
         projects.forEach(function (ctx) { list.push(ctx.getStatus()); });
         return list;
       },
+      getHubSchedules: function () {
+        var allSchedules = [];
+        projects.forEach(function (ctx, s) {
+          var status = ctx.getStatus();
+          var recs = ctx.getSchedules();
+          for (var i = 0; i < recs.length; i++) {
+            // Shallow-copy full record and augment with project metadata
+            var copy = {};
+            var keys = Object.keys(recs[i]);
+            for (var k = 0; k < keys.length; k++) copy[keys[k]] = recs[i][keys[k]];
+            copy.projectSlug = s;
+            copy.projectTitle = status.title || status.project;
+            allSchedules.push(copy);
+          }
+        });
+        return allSchedules;
+      },
+      // Move a schedule record from one project to another
+      moveScheduleToProject: function (recordId, fromSlug, toSlug) {
+        var fromCtx = projects.get(fromSlug);
+        var toCtx = projects.get(toSlug);
+        if (!fromCtx || !toCtx) return { ok: false, error: "Project not found" };
+        var recs = fromCtx.getSchedules();
+        var rec = null;
+        for (var i = 0; i < recs.length; i++) {
+          if (recs[i].id === recordId) { rec = recs[i]; break; }
+        }
+        if (!rec) return { ok: false, error: "Record not found" };
+        // Copy full record data
+        var data = {};
+        var keys = Object.keys(rec);
+        for (var k = 0; k < keys.length; k++) data[keys[k]] = rec[keys[k]];
+        // Import into target, remove from source
+        toCtx.importSchedule(data);
+        fromCtx.removeSchedule(recordId);
+        return { ok: true };
+      },
+      // Bulk move all schedules from one project to another
+      moveAllSchedulesToProject: function (fromSlug, toSlug) {
+        var fromCtx = projects.get(fromSlug);
+        var toCtx = projects.get(toSlug);
+        if (!fromCtx || !toCtx) return { ok: false, error: "Project not found" };
+        var recs = fromCtx.getSchedules();
+        for (var i = 0; i < recs.length; i++) {
+          var data = {};
+          var keys = Object.keys(recs[i]);
+          for (var k = 0; k < keys.length; k++) data[keys[k]] = recs[i][keys[k]];
+          toCtx.importSchedule(data);
+        }
+        // Remove all from source
+        var ids = recs.map(function (r) { return r.id; });
+        for (var j = 0; j < ids.length; j++) {
+          fromCtx.removeSchedule(ids[j]);
+        }
+        return { ok: true };
+      },
+      // Get schedule count for a project slug
+      getScheduleCount: function (slug) {
+        var ctx = projects.get(slug);
+        if (!ctx) return 0;
+        return ctx.getSchedules().length;
+      },
       onProcessingChanged: broadcastProcessingChange,
       onAddProject: onAddProject,
       onRemoveProject: onRemoveProject,

package/lib/sessions.js

@@ -81,6 +81,7 @@ function createSessionManager(opts) {
         createdAt: session.createdAt,
       };
       if (session.lastRewindUuid) metaObj.lastRewindUuid = session.lastRewindUuid;
+      if (session.loop) metaObj.loop = session.loop;
       var meta = JSON.stringify(metaObj);
       var lines = [meta];
       for (var i = 0; i < session.history.length; i++) {
@@ -157,6 +158,7 @@ function createSessionManager(opts) {
         messageUUIDs: messageUUIDs,
         lastRewindUuid: m.lastRewindUuid || null,
       };
+      if (m.loop) session.loop = m.loop;
       sessions.set(localId, session);
     }
   }
@@ -168,10 +170,24 @@ function createSessionManager(opts) {
     return sessions.get(activeSessionId) || null;
   }
 
+  var resolveLoopInfo = null; // optional callback: (loopId) => { name, source } or null
+
+  function setResolveLoopInfo(fn) {
+    resolveLoopInfo = fn;
+  }
+
   function broadcastSessionList() {
     send({
       type: "session_list",
-      sessions: [...sessions.values()].map(function(s) {
+      sessions: [...sessions.values()].filter(function(s) { return !s.hidden; }).map(function(s) {
+        var loop = s.loop ? Object.assign({}, s.loop) : null;
+        if (loop && loop.loopId && resolveLoopInfo) {
+          var info = resolveLoopInfo(loop.loopId);
+          if (info) {
+            if (info.name) loop.name = info.name;
+            if (info.source) loop.source = info.source;
+          }
+        }
         return {
           id: s.localId,
           cliSessionId: s.cliSessionId || null,
@@ -179,7 +195,7 @@ function createSessionManager(opts) {
           active: s.localId === activeSessionId,
           isProcessing: s.isProcessing,
           lastActivity: s.lastActivity || s.createdAt || 0,
-          loop: s.loop || null,
+          loop: loop,
         };
       }),
     });
@@ -310,6 +326,21 @@ function createSessionManager(opts) {
     }
   }
 
+  function deleteSessionQuiet(localId) {
+    var session = sessions.get(localId);
+    if (!session) return;
+    if (session.abortController) {
+      try { session.abortController.abort(); } catch(e) {}
+    }
+    if (session.messageQueue) {
+      try { session.messageQueue.end(); } catch(e) {}
+    }
+    if (session.cliSessionId) {
+      try { fs.unlinkSync(sessionFilePath(session.cliSessionId)); } catch(e) {}
+    }
+    sessions.delete(localId);
+  }
+
   function doSendAndRecord(session, obj) {
     session.history.push(obj);
     appendToSessionFile(session, obj);
@@ -419,6 +450,7 @@ function createSessionManager(opts) {
     createSession: createSession,
     switchSession: switchSession,
     deleteSession: deleteSession,
+    deleteSessionQuiet: deleteSessionQuiet,
     resumeSession: resumeSession,
     broadcastSessionList: broadcastSessionList,
     saveSessionFile: saveSessionFile,
@@ -427,6 +459,7 @@ function createSessionManager(opts) {
     findTurnBoundary: findTurnBoundary,
     replayHistory: replayHistory,
     searchSessions: searchSessions,
+    setResolveLoopInfo: setResolveLoopInfo,
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "2.7.2",
+  "version": "2.8.2",
   "description": "Web UI for Claude Code. Any device. Push notifications.",
   "bin": {
     "clay-server": "./bin/cli.js",