clay-server 4.0.0-beta.1 → 4.0.0-beta.11

package/lib/background-task-timing.js

@@ -0,0 +1,105 @@
+// Background task list shaping shared by the server-side consumers:
+// start-time tracking, plus the ambient/user split every activity indicator
+// needs.
+//
+// Vendors report background tasks as a full replacement list on every change
+// and none of them carries a reliable start time today (see
+// normalizeBackgroundTasks in yoke/adapters/claude.js and mapTerminals in
+// yoke/codex-background-tasks.js). The session's previous list is the only
+// place that knows when a task was first seen, so the merge belongs here,
+// where that list is maintained, rather than in an adapter that rebuilds the
+// array from scratch each time.
+//
+// A vendor-supplied timestamp always wins when present; otherwise a task is
+// stamped the first time it appears and keeps that stamp for its whole life.
+
+// Accepts epoch milliseconds, epoch seconds, or an ISO date string, since
+// vendors are not consistent. Returns null for anything unusable so the
+// caller falls back to first-seen stamping instead of rendering 1970.
+function normalizeTimestamp(value) {
+  if (typeof value === "number" && isFinite(value) && value > 0) {
+    // Values this small are epoch seconds, not milliseconds.
+    return value < 1e12 ? Math.round(value * 1000) : Math.round(value);
+  }
+  if (typeof value === "string" && value) {
+    var parsed = Date.parse(value);
+    if (!isNaN(parsed)) return parsed;
+  }
+  return null;
+}
+
+function vendorStartedAt(task) {
+  if (!task) return null;
+  return normalizeTimestamp(task.started_at)
+    || normalizeTimestamp(task.startedAt)
+    || normalizeTimestamp(task.createdAt)
+    || normalizeTimestamp(task.created_at);
+}
+
+/**
+ * Return `nextTasks` with a `started_at` (epoch ms) on every entry.
+ * Tasks already present in `previousTasks` keep their original stamp so the
+ * elapsed time does not reset every time the list is re-emitted.
+ */
+function mergeStartTimes(previousTasks, nextTasks, now) {
+  if (!Array.isArray(nextTasks)) return [];
+  var stampedAt = typeof now === "number" ? now : Date.now();
+  // Stamps we wrote on a previous pass are already epoch milliseconds, so they
+  // are read as-is. Only vendor-supplied values go through normalizeTimestamp,
+  // whose seconds-vs-milliseconds heuristic would otherwise be re-applied to
+  // our own output.
+  var known = {};
+  var previous = Array.isArray(previousTasks) ? previousTasks : [];
+  for (var p = 0; p < previous.length; p++) {
+    var seen = previous[p];
+    if (!seen || !seen.task_id) continue;
+    if (typeof seen.started_at === "number" && isFinite(seen.started_at) && seen.started_at > 0) {
+      known[seen.task_id] = seen.started_at;
+    }
+  }
+
+  var merged = [];
+  for (var i = 0; i < nextTasks.length; i++) {
+    var task = nextTasks[i];
+    if (!task) continue;
+    var startedAt = vendorStartedAt(task) || known[task.task_id] || stampedAt;
+    merged.push(Object.assign({}, task, { started_at: startedAt }));
+  }
+  return merged;
+}
+
+// Ambient tasks are the CLI's own housekeeping (every skip_transcript task
+// plus auto-started live-update watchers). The SDK asks hosts to keep them out
+// of activity indicators, so every count that drives a badge, a summary, or a
+// change notification must go through here rather than reading `.length`.
+// Absent means false: vendors without an ambient concept (Codex terminals)
+// and older CLI builds report only real user work.
+function isAmbientTask(task) {
+  return !!(task && task.ambient === true);
+}
+
+function userTasks(tasks) {
+  if (!Array.isArray(tasks)) return [];
+  return tasks.filter(function (task) {
+    return task && !isAmbientTask(task);
+  });
+}
+
+function ambientTasks(tasks) {
+  if (!Array.isArray(tasks)) return [];
+  return tasks.filter(isAmbientTask);
+}
+
+// The count that represents "user-visible background work is running".
+function countUserTasks(tasks) {
+  return userTasks(tasks).length;
+}
+
+module.exports = {
+  mergeStartTimes: mergeStartTimes,
+  normalizeTimestamp: normalizeTimestamp,
+  isAmbientTask: isAmbientTask,
+  userTasks: userTasks,
+  ambientTasks: ambientTasks,
+  countUserTasks: countUserTasks,
+};

package/lib/config.js

@@ -148,12 +148,36 @@ function saveConfig(config) {
   chmodSafe(configPath(), 0o600);
 }
 
+// Does a process with this pid exist? Existence only — never ownership.
+//
+// `process.kill(pid, 0)` sends no signal; it just asks the kernel. Three
+// answers matter, and conflating them has caused real damage:
+//
+//   success -> the process exists and we may signal it
+//   EPERM   -> the process EXISTS but belongs to another user. This is alive.
+//              Reading it as dead is how a daemon started by another OS user
+//              (or under OS-user isolation) got its config cleared and its
+//              socket unlinked by a second daemon, which then started
+//              alongside it.
+//   ESRCH   -> no such process. This is the only "dead".
+//
+// Any other error is a question we could not answer, so we answer "alive":
+// every caller uses this to gate a destructive or duplicating action
+// (clearStaleConfig unlinks the live socket; the migration lock would be
+// stolen), and doing nothing is always the recoverable choice.
+//
+// The pid is validated first, so a malformed value never reaches the kernel
+// call. That matters beyond hygiene: process.kill accepts 0 and negative pids
+// as process-GROUP selectors and returns success for them, so an unvalidated
+// 0 or -1 in a config file used to report a live daemon that does not exist.
 function isPidAlive(pid) {
+  if (typeof pid !== "number" || !isFinite(pid) || Math.floor(pid) !== pid || pid <= 0) return false;
   try {
     process.kill(pid, 0);
     return true;
   } catch (e) {
-    return false;
+    if (e && e.code === "ESRCH") return false;
+    return true;
   }
 }
 

package/lib/daemon.js

@@ -34,6 +34,7 @@ var { checkAclSupport, grantProjectAccess, revokeProjectAccess, provisionAllUser
 var usersModule = require("./users");
 var { createWorktree, removeWorktree, isWorktree } = require("./worktree");
 var mates = require("./mates");
+var mateKnowledgeMigration = require("./mate-knowledge-migration");
 var { isWorktreeSlug, scanAndRegisterWorktrees, rescanWorktrees, cleanupWorktreesForParent, getFilteredRemovedProjects, registerWorktreeSlug, unregisterWorktreeSlug } = require("./daemon-projects");
 
 var daemonVersion = require("../package.json").version;
@@ -1294,6 +1295,27 @@ for (var i = 0; i < projects.length; i++) {
 // Migrate legacy mates storage before registration
 mates.migrateLegacyMates();
 
+// Import durable Mate knowledge into the Clay-wide Knowledge backend. Runs on
+// every start, imports nothing when there is nothing new, and never touches
+// the legacy files that remain the live source for existing read paths.
+mateKnowledgeMigration.runAtStartup({
+  extraRoots: (function () {
+    var roots = [];
+    try {
+      if (!usersModule.isMultiUser()) return roots;
+      var all = usersModule.getAllUsers() || [];
+      for (var mi = 0; mi < all.length; mi++) {
+        if (!all[mi] || !all[mi].linuxUser) continue;
+        roots.push({
+          userId: all[mi].id,
+          matesRoot: mates.resolveMatesRoot({ userId: all[mi].id, multiUser: true, linuxUser: all[mi].linuxUser }),
+        });
+      }
+    } catch (e) {}
+    return roots;
+  })(),
+});
+
 // Register existing mates as projects
 if (usersModule.isMultiUser()) {
   // Multi-user mode: iterate over all users and load each user's mates

package/lib/git-cli.js

@@ -6,6 +6,7 @@ var { execFile, execFileSync } = require("child_process");
 var { wrapSpawnAsUser } = require("./os-users");
 
 var MAX_DIFF_BYTES = 2 * 1024 * 1024;
+var MAX_REMOTE_LABEL = 64;
 
 function gitEnvironment(osUserInfo) {
   var overrides = { GIT_TERMINAL_PROMPT: "0" };
@@ -157,6 +158,24 @@ function normalizeGitPath(cwd, value) {
   return path.normalize(path.isAbsolute(value) ? value : path.resolve(cwd, value));
 }
 
+// Whether this checkout is a linked worktree. The two directories have to be
+// compared through realpath: git answers --absolute-git-dir already resolved
+// but --git-common-dir relative to cwd, so on any platform where the working
+// directory sits behind a symlink (macOS /var -> /private/var, for one) a
+// plain string compare reports every ordinary repository as a worktree.
+function isLinkedWorktree(gitDir, commonDir) {
+  if (!gitDir || !commonDir) return false;
+  return realGitPath(gitDir) !== realGitPath(commonDir);
+}
+
+function realGitPath(value) {
+  try {
+    return fs.realpathSync(value);
+  } catch (e) {
+    return value;
+  }
+}
+
 function parseWorktrees(raw) {
   var blocks = String(raw || "").trim().split(/\n\n+/);
   var result = [];
@@ -219,7 +238,7 @@ function getStatus(cwd, osUserInfo) {
     origin: origin,
     gitDir: gitDir,
     commonDir: commonDir,
-    isWorktree: !!(gitDir && commonDir && gitDir !== commonDir),
+    isWorktree: isLinkedWorktree(gitDir, commonDir),
     mainWorktree: worktrees.length > 0 ? worktrees[0].path : root,
     worktrees: worktrees,
     files: parsed.files,
@@ -227,6 +246,78 @@ function getStatus(cwd, osUserInfo) {
   };
 }
 
+// A bounded, credential-free remote label. The raw remote URL can carry an
+// embedded token, so the userinfo segment is dropped before the label is
+// built rather than after.
+function shortRemoteLabel(origin) {
+  if (!origin) return null;
+  var label = String(origin).trim()
+    .replace(/^git@([^:]+):/, "$1/")
+    .replace(/^[a-z][a-z0-9+.-]*:\/\//i, "")
+    .replace(/^[^@/]*@/, "")
+    .replace(/\.git$/, "")
+    .replace(/\/+$/, "");
+  if (label.length > MAX_REMOTE_LABEL) label = label.slice(0, MAX_REMOTE_LABEL - 1) + "…";
+  return label || null;
+}
+
+function countChangedFiles(files) {
+  var counts = { changed: files.length, staged: 0, unstaged: 0, untracked: 0, conflicted: 0 };
+  for (var i = 0; i < files.length; i++) {
+    var file = files[i];
+    if (file.conflicted) counts.conflicted++;
+    if (file.untracked) counts.untracked++;
+    if (file.staged) counts.staged++;
+    if (file.unstaged && !file.untracked) counts.unstaged++;
+  }
+  return counts;
+}
+
+// Cheap always-visible repository placard data. Deliberately narrower than
+// getStatus: three git invocations instead of six, no per-file payload, no
+// session attribution, and no filesystem path in the result. Identity is
+// derived here so the client never resolves or renders a repository path.
+function getSummary(cwd, osUserInfo) {
+  var probe;
+  try {
+    probe = runGitSync(cwd, [
+      "rev-parse", "--is-inside-work-tree", "--show-toplevel",
+      "--absolute-git-dir", "--git-common-dir",
+    ], null, osUserInfo);
+  } catch (e) {
+    return { isRepository: false };
+  }
+  var lines = String(probe || "").trim().split("\n");
+  if (String(lines[0] || "").trim() !== "true" || !lines[1]) return { isRepository: false };
+
+  var root = String(lines[1]).trim();
+  var gitDir = lines[2] ? normalizeGitPath(cwd, String(lines[2]).trim()) : null;
+  var commonDir = lines[3] ? normalizeGitPath(cwd, String(lines[3]).trim()) : null;
+  var parsed = parsePorcelainV2(runGitSync(root, ["status", "--porcelain=v2", "--branch", "-z"], null, osUserInfo));
+  var origin = null;
+  try { origin = runGitSync(cwd, ["remote", "get-url", "origin"], null, osUserInfo).trim() || null; } catch (e) {}
+
+  var detached = parsed.branch === "(detached)";
+  var counts = countChangedFiles(parsed.files);
+  return {
+    isRepository: true,
+    name: path.basename(root),
+    branch: detached ? null : parsed.branch,
+    detached: detached,
+    shortOid: parsed.oid && parsed.oid !== "(initial)" ? String(parsed.oid).slice(0, 8) : null,
+    isWorktree: isLinkedWorktree(gitDir, commonDir),
+    hasUpstream: !!parsed.upstream,
+    ahead: parsed.ahead,
+    behind: parsed.behind,
+    changed: counts.changed,
+    staged: counts.staged,
+    unstaged: counts.unstaged,
+    untracked: counts.untracked,
+    conflicted: counts.conflicted,
+    remote: shortRemoteLabel(origin),
+  };
+}
+
 function resolveChangedPaths(status, requestedPaths) {
   if (!Array.isArray(requestedPaths) || requestedPaths.length === 0 || requestedPaths.length > 200) {
     throw new Error("Select at least one changed file");
@@ -363,8 +454,10 @@ module.exports = {
   getFileAtCommit: getFileAtCommit,
   getFileDiff: getFileDiff,
   getStatus: getStatus,
+  getSummary: getSummary,
   parsePorcelainV2: parsePorcelainV2,
   parseWorktrees: parseWorktrees,
   readWorkingTreeFile: readWorkingTreeFile,
   runAction: runAction,
+  shortRemoteLabel: shortRemoteLabel,
 };