clay-server 2.7.0 → 2.7.1

package/lib/public/style.css

@@ -15,3 +15,5 @@
 @import url("css/skills.css");
 @import url("css/mobile-nav.css");
 @import url("css/loop.css");
+@import url("css/scheduler.css");
+@import url("css/scheduler-modal.css");

package/lib/scheduler.js

@@ -0,0 +1,362 @@
+/**
+ * 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);
+          }
+          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.cron) continue; // skip one-off
+      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;
+      rec.nextRunAt = nextRunTime(rec.cron, now);
+      save();
+
+      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,
+      craftingSessionId: data.craftingSessionId || null,
+      runs: [],
+    };
+    if (rec.cron && rec.enabled) {
+      rec.nextRunAt = nextRunTime(rec.cron);
+    }
+    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;
+    rec.updatedAt = Date.now();
+    rec.nextRunAt = (rec.cron && rec.enabled) ? nextRunTime(rec.cron) : 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();
+    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

@@ -159,6 +159,11 @@ function createSDKBridge(opts) {
     if (parsed.type === "stream_event" && parsed.event) {
       var evt = parsed.event;
 
+      if (evt.type === "message_start" && evt.message && evt.message.usage) {
+        var u = evt.message.usage;
+        session.lastStreamInputTokens = (u.input_tokens || 0) + (u.cache_read_input_tokens || 0);
+      }
+
       if (evt.type === "content_block_start") {
         var block = evt.content_block;
         var idx = evt.index;
@@ -309,6 +314,8 @@ function createSDKBridge(opts) {
       session.taskIdMap = {};
       session.isProcessing = false;
       onProcessingChanged();
+      var lastStreamInput = session.lastStreamInputTokens || null;
+      session.lastStreamInputTokens = null;
       sendAndRecord(session, {
         type: "result",
         cost: parsed.total_cost_usd,
@@ -316,6 +323,7 @@ function createSDKBridge(opts) {
         usage: parsed.usage || null,
         modelUsage: parsed.modelUsage || null,
         sessionId: parsed.session_id,
+        lastStreamInputTokens: lastStreamInput,
       });
       if (parsed.fast_mode_state) {
         sendAndRecord(session, { type: "fast_mode_state", state: parsed.fast_mode_state });

package/lib/sessions.js

@@ -16,8 +16,9 @@ function createSessionManager(opts) {
   var skillNames = null;        // Claude-only skills to filter from slash menu
 
   // --- Session persistence (centralized in ~/.clay/sessions/{encoded-cwd}/) ---
-  var encodedCwd = utils.encodeCwd(cwd);
-  var sessionsDir = path.join(config.CONFIG_DIR, "sessions", encodedCwd);
+  var sessionsBase = path.join(config.CONFIG_DIR, "sessions");
+  var encodedCwd = utils.resolveEncodedDir(sessionsBase, cwd);
+  var sessionsDir = path.join(sessionsBase, encodedCwd);
   fs.mkdirSync(sessionsDir, { recursive: true });
 
   // Auto-migrate sessions from legacy locations:
@@ -170,7 +171,7 @@ function createSessionManager(opts) {
   function broadcastSessionList() {
     send({
       type: "session_list",
-      sessions: [...sessions.values()].map(function(s) {
+      sessions: [...sessions.values()].filter(function(s) { return !s.hidden; }).map(function(s) {
         return {
           id: s.localId,
           cliSessionId: s.cliSessionId || null,
@@ -237,17 +238,19 @@ function createSessionManager(opts) {
     var lastUsage = null;
     var lastModelUsage = null;
     var lastCost = null;
+    var lastStreamInputTokens = null;
     for (var j = total - 1; j >= 0; j--) {
       if (session.history[j].type === "result") {
         var r = session.history[j];
         lastUsage = r.usage || null;
         lastModelUsage = r.modelUsage || null;
         lastCost = r.cost != null ? r.cost : null;
+        lastStreamInputTokens = r.lastStreamInputTokens || null;
         break;
       }
     }
 
-    send({ type: "history_done", lastUsage: lastUsage, lastModelUsage: lastModelUsage, lastCost: lastCost });
+    send({ type: "history_done", lastUsage: lastUsage, lastModelUsage: lastModelUsage, lastCost: lastCost, lastStreamInputTokens: lastStreamInputTokens });
   }
 
   function switchSession(localId) {

package/lib/utils.js

@@ -2,17 +2,63 @@
  * Shared utility functions.
  */
 
+var fs = require("fs");
+
 /**
  * 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.
+ * Replaces all non-alphanumeric characters with hyphens, matching
+ * Claude Code CLI's encoding logic exactly (/[^a-zA-Z0-9]/g -> "-").
  *
- * Example: "/Users/jon.doe/my-project" -> "-Users-jon-doe-my-project"
+ * Example: "/Users/jon.doe_42/my project" -> "-Users-jon-doe-42-my-project"
  */
 function encodeCwd(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+
+/**
+ * Legacy encoding (pre-#182 fix). Only slashes and dots were replaced.
+ * Used for fallback resolution of on-disk data written before the fix.
+ */
+function legacyEncodeCwd(cwd) {
   return cwd.replace(/[\/\.]/g, "-");
 }
 
+/**
+ * Try candidate encoded names against a base directory.
+ * Returns the first match that exists on disk, or the first candidate
+ * (newest encoding) if none exist yet.
+ */
+function resolveEncoded(baseDir, cwd, ext, checkFn) {
+  var newEncoded = encodeCwd(cwd);
+  var legacyEncoded = legacyEncodeCwd(cwd);
+  if (newEncoded === legacyEncoded) return newEncoded;
+  var full = baseDir + "/" + newEncoded + (ext || "");
+  try { if (checkFn(full)) return newEncoded; } catch (e) {}
+  var legacyFull = baseDir + "/" + legacyEncoded + (ext || "");
+  try { if (checkFn(legacyFull)) return legacyEncoded; } catch (e) {}
+  return newEncoded;
+}
+
+/**
+ * Resolve an encoded directory path with legacy fallback.
+ */
+function resolveEncodedDir(baseDir, cwd) {
+  return resolveEncoded(baseDir, cwd, "", function(p) {
+    return fs.statSync(p).isDirectory();
+  });
+}
+
+/**
+ * Resolve an encoded file path with legacy fallback.
+ */
+function resolveEncodedFile(baseDir, cwd, ext) {
+  return resolveEncoded(baseDir, cwd, ext, function(p) {
+    return fs.statSync(p).isFile();
+  });
+}
+
 module.exports = {
   encodeCwd: encodeCwd,
+  resolveEncodedDir: resolveEncodedDir,
+  resolveEncodedFile: resolveEncodedFile,
 };

package/package.json

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