clay-server 5.2.0-beta.5 → 5.2.0-beta.7

package/lib/yoke/claude-jsonl-watcher.js

@@ -0,0 +1,204 @@
+// claude-jsonl-watcher.js
+//
+// Tails the per-session jsonl that Claude Code writes to
+// ~/.claude/projects/<encoded-cwd>/<cliSessionId>.jsonl, parsing new lines
+// for title events:
+//
+//   {"type":"ai-title","aiTitle":"..."}          - auto-generated after the
+//                                                  first exchange
+//   {"type":"custom-title","customTitle":"..."}  - explicit /title or
+//                                                  similar override
+//
+// Used by Clay TUI sessions to mirror claude's session naming into the
+// sidebar so they don't sit as "New Session" forever.
+//
+// Public API:
+//   start(jsonlPath, onTitle) -> stop()
+//     onTitle(title, source) where source is "ai-title" or "custom-title".
+//     stop() detaches the watcher and clears any timer.
+
+var fs = require("fs");
+var path = require("path");
+
+function pickLatestTitle(lines, current) {
+  // Walk lines in order; the final ai-title and custom-title win. Custom
+  // beats ai because users explicitly chose it.
+  var ai = current.aiTitle || null;
+  var custom = current.customTitle || null;
+  for (var i = 0; i < lines.length; i++) {
+    var raw = lines[i].trim();
+    if (!raw || raw[0] !== "{") continue;
+    var obj = null;
+    try { obj = JSON.parse(raw); } catch (e) { continue; }
+    if (!obj || !obj.type) continue;
+    if (obj.type === "ai-title" && typeof obj.aiTitle === "string") {
+      ai = obj.aiTitle;
+    } else if (obj.type === "custom-title" && typeof obj.customTitle === "string") {
+      custom = obj.customTitle;
+    }
+  }
+  current.aiTitle = ai;
+  current.customTitle = custom;
+  return custom || ai;
+}
+
+// Pull the latest visible "text" block from any new assistant entries.
+// Thinking and tool_use blocks are skipped - they're internals, not the
+// response surface. Returns the most recent text seen, or null.
+function extractLatestAssistantText(lines, seenUuids) {
+  var latest = null;
+  for (var i = 0; i < lines.length; i++) {
+    var raw = lines[i].trim();
+    if (!raw || raw[0] !== "{") continue;
+    var obj = null;
+    try { obj = JSON.parse(raw); } catch (e) { continue; }
+    if (!obj || obj.type !== "assistant" || !obj.message) continue;
+    if (obj.uuid && seenUuids[obj.uuid]) continue;
+    if (obj.uuid) seenUuids[obj.uuid] = true;
+    var blocks = obj.message.content || [];
+    if (!Array.isArray(blocks)) continue;
+    for (var j = 0; j < blocks.length; j++) {
+      var b = blocks[j];
+      if (b && b.type === "text" && typeof b.text === "string" && b.text.trim()) {
+        latest = b.text;
+      }
+    }
+  }
+  return latest;
+}
+
+/**
+ * Watch a Claude Code session jsonl for title and response updates.
+ *
+ *   start(jsonlPath, { onTitle, onResponse }) -> stop()
+ *
+ * onTitle(text, source)   fires on ai-title / custom-title updates.
+ * onResponse(text)        fires on new assistant text blocks (debounced so
+ *                         a multi-block turn coalesces to one callback,
+ *                         using only the *final* visible text). Pre-existing
+ *                         entries from before start() are ignored - the
+ *                         initial scan seeds the "seen" set so we don't
+ *                         spam notifications when the watcher boots up.
+ */
+function start(jsonlPath, opts) {
+  if (!jsonlPath) return function () {};
+  var onTitle = (opts && typeof opts.onTitle === "function") ? opts.onTitle : null;
+  var onResponse = (opts && typeof opts.onResponse === "function") ? opts.onResponse : null;
+  if (!onTitle && !onResponse) return function () {};
+
+  var pos = 0;
+  var leftover = "";
+  var current = { aiTitle: null, customTitle: null };
+  var lastTitleEmitted = null;
+  var seenAssistantUuids = {};
+  var didInitialScan = false;
+  var responseDebounceTimer = null;
+  var pendingResponseText = null;
+  var lastResponseEmitted = null;
+  var watcher = null;
+  var pollTimer = null;
+  var stopped = false;
+
+  var RESPONSE_DEBOUNCE_MS = 1500;
+  function maybeFireResponse() {
+    if (responseDebounceTimer) clearTimeout(responseDebounceTimer);
+    responseDebounceTimer = setTimeout(function () {
+      responseDebounceTimer = null;
+      if (!pendingResponseText) return;
+      if (pendingResponseText === lastResponseEmitted) return;
+      var t = pendingResponseText;
+      pendingResponseText = null;
+      lastResponseEmitted = t;
+      try { if (onResponse) onResponse(t); } catch (e) {}
+    }, RESPONSE_DEBOUNCE_MS);
+  }
+
+  function readNew() {
+    if (stopped) return;
+    try {
+      var stat = fs.statSync(jsonlPath);
+      if (stat.size <= pos) return;
+      var fd = fs.openSync(jsonlPath, "r");
+      var len = stat.size - pos;
+      var buf = Buffer.alloc(len);
+      fs.readSync(fd, buf, 0, len, pos);
+      fs.closeSync(fd);
+      pos = stat.size;
+      var chunk = leftover + buf.toString("utf8");
+      var parts = chunk.split("\n");
+      // Last fragment may be a partial line; hold it for next read.
+      leftover = parts.pop();
+
+      // Title side: fire whenever we see a new value.
+      if (onTitle) {
+        var resolved = pickLatestTitle(parts, current);
+        if (resolved && resolved !== lastTitleEmitted) {
+          lastTitleEmitted = resolved;
+          try { onTitle(resolved, current.customTitle === resolved ? "custom-title" : "ai-title"); } catch (e) {}
+        }
+      }
+
+      // Response side: collect new assistant text blocks. Initial scan
+      // seeds the "seen" set silently so old history doesn't fire.
+      var latest = extractLatestAssistantText(parts, seenAssistantUuids);
+      if (onResponse && didInitialScan && latest) {
+        pendingResponseText = latest;
+        maybeFireResponse();
+      }
+    } catch (e) {
+      // File may not exist yet; readNew is called again on the next event.
+    }
+  }
+
+  function arm() {
+    if (stopped) return;
+    if (watcher) return;
+    try {
+      watcher = fs.watch(jsonlPath, { persistent: false }, function () {
+        readNew();
+      });
+      watcher.on("error", function () {
+        try { watcher.close(); } catch (e) {}
+        watcher = null;
+        // Fall back to polling; some filesystems (network mounts) don't
+        // deliver fs.watch events reliably.
+      });
+    } catch (e) {
+      // Path doesn't exist yet; rely on the poll loop to retry once it appears.
+    }
+  }
+
+  // Initial pass to capture anything already written before we attached.
+  // didInitialScan stays false during this pass so onResponse doesn't fire
+  // for old history; subsequent reads (live updates) will emit.
+  readNew();
+  didInitialScan = true;
+  arm();
+
+  // Poll every 2s as a safety net for fs.watch misses and for the
+  // "file doesn't exist yet" boot case.
+  pollTimer = setInterval(function () {
+    if (!watcher) arm();
+    readNew();
+  }, 2000);
+
+  return function stop() {
+    stopped = true;
+    if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }
+    if (responseDebounceTimer) { clearTimeout(responseDebounceTimer); responseDebounceTimer = null; }
+    if (watcher) { try { watcher.close(); } catch (e) {} watcher = null; }
+  };
+}
+
+// Resolve the jsonl path for a (cwd, cliSessionId) without depending on
+// utils.js so this module stays self-contained.
+function jsonlPathFor(home, cwd, cliSessionId) {
+  if (!home || !cwd || !cliSessionId) return null;
+  var encoded = cwd.replace(/[^a-zA-Z0-9]/g, "-");
+  return path.join(home, ".claude", "projects", encoded, cliSessionId + ".jsonl");
+}
+
+module.exports = {
+  start: start,
+  jsonlPathFor: jsonlPathFor,
+};

package/lib/yoke/claude-maintenance.js

@@ -0,0 +1,55 @@
+var fs = require("fs"), path = require("path");
+function cleanupSdkWarmupSessions(REAL_HOME) {
+  var sessionHygiene = require("./claude-transcript-hygiene");
+  var projectsRoot = path.join(REAL_HOME, ".claude", "projects");
+  var projectDirs;
+  try { projectDirs = fs.readdirSync(projectsRoot, { withFileTypes: true }); }
+  catch (e) { return; }
+
+  var deleted = 0;
+  var nowMs = Date.now();
+  var MAX_BYTES = 64 * 1024;
+  var MIN_AGE_MS = 60 * 1000;
+
+  for (var di = 0; di < projectDirs.length; di++) {
+    if (!projectDirs[di].isDirectory()) continue;
+    var projDir = path.join(projectsRoot, projectDirs[di].name);
+    var files;
+    try { files = fs.readdirSync(projDir); } catch (e) { continue; }
+
+    for (var fi = 0; fi < files.length; fi++) {
+      var f = files[fi];
+      if (!f.endsWith(".jsonl")) continue;
+      var fp = path.join(projDir, f);
+
+      var st;
+      try { st = fs.statSync(fp); } catch (e) { continue; }
+      if (st.size >= MAX_BYTES) continue;
+      if (nowMs - st.mtimeMs < MIN_AGE_MS) continue;
+
+      var raw;
+      try { raw = fs.readFileSync(fp, "utf8"); } catch (e) { continue; }
+      var lines = raw.split("\n");
+      var events = [];
+      var parseOk = true;
+      for (var li = 0; li < lines.length; li++) {
+        var line = lines[li];
+        if (!line) continue;
+        var ev;
+        try { ev = JSON.parse(line); } catch (e) { parseOk = false; break; }
+        if (!ev || typeof ev !== "object") continue;
+        events.push(ev);
+      }
+      if (!parseOk) continue;
+      if (!sessionHygiene.isClaudeWarmupTranscript(events)) continue;
+
+      try { fs.unlinkSync(fp); deleted++; } catch (e) {}
+    }
+  }
+
+  if (deleted > 0) {
+    console.log("[daemon] Removed " + deleted + " stale SDK warmup session file(s)");
+  }
+}
+
+module.exports = { cleanup: cleanupSdkWarmupSessions };

package/lib/yoke/claude-permission-patterns.js

@@ -0,0 +1,53 @@
+function attachPatterns(policy) {
+  var STANDALONE = policy.STANDALONE, SUBCOMMAND = policy.SUBCOMMAND, EXACT = policy.EXACT;
+  var STANDALONE_SET = {};
+  STANDALONE.forEach(function(command) { STANDALONE_SET[command] = true; });
+function buildClayBashAllowPatterns() {
+  var patterns = [];
+  for (var i = 0; i < STANDALONE.length; i++) {
+    patterns.push("Bash(" + STANDALONE[i] + ")");
+    patterns.push("Bash(" + STANDALONE[i] + " *)");
+  }
+  var bins = Object.keys(SUBCOMMAND);
+  for (var b = 0; b < bins.length; b++) {
+    var subs = SUBCOMMAND[bins[b]];
+    for (var s = 0; s < subs.length; s++) {
+      var base = bins[b] + " " + subs[s];
+      patterns.push("Bash(" + base + ")");
+      patterns.push("Bash(" + base + " *)");
+    }
+  }
+  for (var e = 0; e < EXACT.length; e++) {
+    patterns.push("Bash(" + EXACT[e] + ")");
+    patterns.push("Bash(" + EXACT[e] + " *)");
+  }
+  return patterns;
+}
+
+var GENERATED_SET = {};
+(function () {
+  var p = buildClayBashAllowPatterns();
+  for (var i = 0; i < p.length; i++) GENERATED_SET[p[i]] = true;
+})();
+
+// Recognize a `permissions.allow` entry that Clay owns, so the installer can
+// strip stale variants on upgrade (including shapes a previous version wrote)
+// WITHOUT clobbering user-authored patterns. Rules:
+//   - Standalone commands: own every shape of `Bash(ls ...)` (any args), since
+//     a user pattern for a command we manage is redundant with our broad one.
+//   - Subcommand binaries (git, npm, ...) and exact commands: only strip the
+//     precise patterns we generate, so a user's `Bash(git push)` survives.
+// Legacy colon shapes are handled separately by the installer.
+function isClayManagedBashPattern(p) {
+  if (typeof p !== "string") return false;
+  if (p.indexOf("Bash(") !== 0 || p.charAt(p.length - 1) !== ")") return false;
+  if (GENERATED_SET[p]) return true;
+  var inner = p.slice(5, -1).trim();
+  if (!inner) return false;
+  var word = inner.split(/[\s:]/)[0];
+  return STANDALONE_SET[word] === true;
+}
+
+return { build: buildClayBashAllowPatterns, isManaged: isClayManagedBashPattern };
+}
+module.exports = { attachPatterns: attachPatterns };

package/lib/yoke/claude-response-recovery.js

@@ -0,0 +1,155 @@
+// Claude delivery watchdog. Only an unanswered foreground turn is replayable.
+function attachResponseRecovery(ctx) {
+  var states = new Map();
+  var schedule = ctx.setTimeout || setTimeout;
+  var unschedule = ctx.clearTimeout || clearTimeout;
+  var waitMs = ctx.waitMs || 180000;
+  var stopMs = ctx.stopMs || 10000;
+
+  function live(session, state) {
+    return (!ctx.isCurrentProvider || ctx.isCurrentProvider(session)) && states.get(session) === state && !session.destroying && !session.taskStopRequested
+      && state.ownerId === session.ownerId && state.vendor === session.vendor
+      && (!ctx.sessions || ctx.sessions.get(session.localId) === session);
+  }
+  function clearTimer(state) {
+    if (state.timer) unschedule(state.timer);
+    state.timer = null;
+  }
+  function cancel(session, expected) {
+    var state = states.get(session);
+    if (expected && state !== expected) return;
+    if (state) clearTimer(state);
+    states.delete(session);
+  }
+  function protectedWait(session) {
+    return [session.pendingPermissions, session.pendingAskUser, session.pendingElicitations,
+      session.pendingUserDialogs, session.activeTaskToolIds].some(function(map) {
+      return map && Object.keys(map).length > 0;
+    }) || (session.activeBackgroundTasks && session.activeBackgroundTasks.length > 0);
+  }
+  function arm(session, state) {
+    clearTimer(state);
+    if (!state.turns.length || state.turns[0].progress || state.stopping) return;
+    state.timer = schedule(function() { expire(session, state); }, waitMs);
+    if (state.timer && state.timer.unref) state.timer.unref();
+  }
+  function snapshot(payload) {
+    return Object.assign({}, payload, { images: payload.images ? JSON.parse(JSON.stringify(payload.images)) : payload.images });
+  }
+  function begin(session, payload, retryState) {
+    if (retryState) return retryState;
+    cancel(session);
+    var state = { turns: [snapshot(payload)], timer: null, stopping: false, retried: false, ownerId: session.ownerId, vendor: session.vendor };
+    states.set(session, state);
+    arm(session, state);
+    return state;
+  }
+  function enqueue(session, payload) {
+    var state = states.get(session);
+    if (!state) return begin(session, payload);
+    state.turns.push(snapshot(payload));
+    return state;
+  }
+  function progress(session) {
+    var state = states.get(session);
+    if (!state || state.stopping || !state.turns.length) return;
+    state.turns[0].progress = true;
+    clearTimer(state);
+  }
+  function event(session, msg) {
+    var state = states.get(session);
+    if (!state || state.stopping || !msg) return;
+    var type = msg.yokeType;
+    if (type === 'error' || type === 'interrupted') { cancel(session); return; }
+    if (type === 'result') {
+      if (msg.subtype === 'success' && !msg.is_error && msg.numTurns === 0
+          && msg.origin && msg.origin.kind === 'task-notification'
+          && !msg.localCommand && msg.resultText === '') return;
+      var remaining = require('../sdk-turn-queue').pendingSends(session, msg);
+      state.turns = remaining ? state.turns.slice(-remaining) : [];
+      state.retried = false;
+      arm(session, state);
+      if (!state.turns.length) cancel(session);
+    } else if ((type === 'text_delta' || type === 'thinking_delta') && (msg.text || msg.delta)
+        || type === 'tool_start' || type === 'tool_input_delta' || type === 'tool_progress'
+        || type === 'task_started' || type === 'task_progress' || type === 'subagent_message'
+        || type === 'message' && msg.messageRole === 'assistant' && msg.content && msg.content.length) {
+      progress(session);
+    }
+  }
+  function finish(session, state, text) {
+    if (!live(session, state)) { cancel(session, state); return; }
+    cancel(session);
+    // Fence late output when a transport cannot confirm termination.
+    session._sdkQueryGeneration = Number(session._sdkQueryGeneration || 0) + 1;
+    session.isProcessing = false;
+    session._awaitingTurnResult = false;
+    session._queuedTurnCount = 0;
+    ctx.changed();
+    ctx.record(session, { type: 'thinking_stop' });
+    ctx.record(session, { type: 'error', text: text });
+    ctx.record(session, { type: 'done', code: 1 });
+    ctx.broadcast();
+  }
+  async function expire(session, state) {
+    clearTimer(state);
+    if (!live(session, state)) { cancel(session, state); return; }
+    // Never stop a known tool or a human decision because prose is absent.
+    if (protectedWait(session)) { progress(session); return; }
+    state.stopping = true;
+    ctx.record(session, { type: 'info', text: 'Claude has not responded for three minutes. Stopping this attempt safely before retrying.' });
+    var timeout;
+    var stopped = false;
+    try {
+      var stopAttempt = (async function() {
+        var handle = session.queryInstance || state.handle;
+        if (!handle && session.abortController) session.abortController.abort();
+        if (!handle && state.starting) await state.starting;
+        handle = handle || session.queryInstance || state.handle;
+        if (handle) {
+          if (typeof handle.stopAndWait !== 'function') return false;
+          await handle.stopAndWait();
+          if (session.streamPromise) await session.streamPromise;
+        }
+        return true;
+      })();
+      session._responseRecoveryStopPending = stopAttempt;
+      stopAttempt.then(function(confirmed) {
+        if (confirmed && session._responseRecoveryStopPending === stopAttempt) session._responseRecoveryStopPending = null;
+      }, function() {});
+      stopped = await Promise.race([
+        stopAttempt,
+        new Promise(function(resolve) { timeout = schedule(function() { resolve(false); }, stopMs); }),
+      ]);
+    } catch (e) { stopped = false; }
+    if (timeout) unschedule(timeout);
+    if (!live(session, state)) { cancel(session, state); return; }
+    if (!stopped) {
+      finish(session, state, 'Claude could not be confirmed stopped. Automatic retry was cancelled to avoid running your request twice. Check your Claude connection before trying again.');
+      return;
+    }
+    if (state.retried || state.turns.length !== 1) {
+      finish(session, state, state.retried
+        ? 'Claude still has not responded after one automatic retry. Please send your message again or check your Claude connection.'
+        : 'Claude did not respond. Several messages were queued, so automatic replay was cancelled to avoid duplicating work. Please send the unanswered messages again.');
+      return;
+    }
+    state.retried = true;
+    state.stopping = false;
+    session.isProcessing = true;
+    ctx.changed();
+    ctx.record(session, { type: 'info', text: 'The previous attempt has stopped. Retrying your original message once.' });
+    ctx.send(session, { type: 'status', status: 'processing' });
+    arm(session, state);
+    var payload = state.turns[0];
+    await ctx.restart(session, payload, state);
+  }
+  return {
+    begin: begin, enqueue: enqueue, event: event, progress: progress, cancel: cancel,
+    current: function(session) { return states.get(session); },
+    valid: live,
+    stopping: function(session) { var state = states.get(session); return !!(state && state.stopping); },
+    dispose: function() { states.forEach(function(state) { clearTimer(state); }); states.clear(); },
+  };
+}
+module.exports = { attachResponseRecovery: attachResponseRecovery };

package/lib/yoke/claude-transcript-hygiene.js

@@ -0,0 +1,34 @@
+var CLAUDE_INTERRUPTED_TEXT = "[Request interrupted by user]";
+function extractClaudeUserText(event) {
+  var content = event && event.message && event.message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  var parts = [];
+  for (var i = 0; i < content.length; i++) {
+    if (content[i] && content[i].type === "text" && typeof content[i].text === "string") {
+      parts.push(content[i].text);
+    }
+  }
+  return parts.join("");
+}
+
+// SDK capability probes create a real Claude transcript with a single "hi"
+// prompt. Newer Claude Code versions append an interruption record when Clay
+// aborts the probe, so that bookkeeping record must not make the transcript
+// look like a real two-turn conversation.
+function isClaudeWarmupTranscript(events) {
+  var promptCount = 0;
+  for (var i = 0; i < events.length; i++) {
+    var event = events[i];
+    if (!event || typeof event !== "object") continue;
+    if (event.type === "assistant") return false;
+    if (event.type !== "user" || !event.message || event.message.role !== "user") continue;
+    var text = extractClaudeUserText(event);
+    if (text === CLAUDE_INTERRUPTED_TEXT) continue;
+    if (text !== "hi") return false;
+    promptCount++;
+  }
+  return promptCount === 1;
+}
+
+module.exports = { extractClaudeUserText: extractClaudeUserText, isClaudeWarmupTranscript: isClaudeWarmupTranscript };

package/lib/yoke/clay-skill-install.js

@@ -0,0 +1,33 @@
+// Runs under the requesting OS identity. The installer only sees a private staging project.
+var fs = require('fs');
+var path = require('path');
+var spawn = require('child_process').spawn;
+var storage = require('../clay-skill-storage');
+var base = process.argv[2];
+var name = process.argv[3];
+var url = process.argv[4];
+if (!storage.isClaySkill(name) || !/^https:\/\//i.test(url)) throw new Error('Invalid Clay skill install request');
+storage.directory(path.join(base, '.clay'));
+var stage = fs.mkdtempSync(path.join(base, '.clay', 'skill-install-'));
+var child = spawn(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['skills', 'add', url, '--skill', name, '--yes', '--agent', 'claude-code'], { cwd: stage, stdio: 'inherit', env: process.env });
+function cleanup() { fs.rmSync(stage, { recursive: true, force: true }); }
+child.on('error', function (error) { console.error(error.message); cleanup(); process.exitCode = 1; });
+process.on('SIGTERM', function () { child.kill('SIGTERM'); });
+child.on('close', function (code) {
+  try {
+    if (code !== 0) throw new Error('Skill installer exited with code ' + code);
+    var candidates = ['.agents', '.claude'].map(function (vendor) { return path.join(stage, vendor, 'skills', name); });
+    var source = candidates.find(function (dir) { return fs.existsSync(path.join(dir, 'SKILL.md')); });
+    if (!source) throw new Error('Installer did not create the requested skill in the private staging project');
+    var root = storage.privateRoot(base); storage.directory(root);
+    var destination = path.join(root, name);
+    var pending = path.join(root, '.' + name + '-' + process.pid);
+    fs.cpSync(source, pending, { recursive: true, dereference: true });
+    if (fs.existsSync(destination)) {
+      var backups = path.join(base, '.clay', 'skill-backups'); storage.directory(backups);
+      fs.renameSync(destination, path.join(backups, name + '-' + Date.now()));
+    }
+    fs.renameSync(pending, destination);
+  } catch (error) { console.error(error.message); process.exitCode = 1; }
+  finally { cleanup(); }
+});