clay-server 5.0.0-beta.2 → 5.0.0-beta.3

package/lib/daemon.js

@@ -23,6 +23,7 @@ delete process.env.CLAUDECODE;
 
 var fs = require("fs");
 var path = require("path");
+var newSessionDefault = require("./new-session-default");
 var { loadConfig, saveConfig, socketPath, generateSlug, syncClayrc, removeFromClayrc, writeCrashInfo, readCrashInfo, clearCrashInfo, isPidAlive, clearStaleConfig, REAL_HOME } = require("./config");
 var { createIPCServer } = require("./ipc");
 var { createServer, generateAuthToken } = require("./server");
@@ -719,6 +720,14 @@ var relay = createServer({
     }
     return { vendor: null };
   },
+  // The provider the project's inline New session row preselects. Stored on
+  // the project's own config entry only.
+  onGetProjectNewSessionDefault: function (slug) {
+    return newSessionDefault.getNewSessionDefault(config, slug);
+  },
+  onSetProjectNewSessionDefault: function (slug, preference) {
+    return newSessionDefault.setNewSessionDefault(config, slug, preference, saveConfig);
+  },
   onSetProjectLastVendor: function (slug, vendor) {
     for (var i = 0; i < config.projects.length; i++) {
       if (config.projects[i].slug === slug) {

package/lib/new-session-default.js

@@ -0,0 +1,45 @@
+// The project-scoped New session default (the provider only), kept on the
+// project's own config entry. Worktrees (slug "<parent>--<name>") read their
+// parent project's default and cannot set their own. Pure over a config object
+// and an injected save function so the daemon callbacks are directly testable.
+
+var access = require("./daemon-project-access");
+
+function findProject(config, slug) {
+  var projects = config && Array.isArray(config.projects) ? config.projects : [];
+  for (var i = 0; i < projects.length; i++) if (projects[i].slug === slug) return projects[i];
+  return null;
+}
+
+function clean(preference) {
+  if (!preference || typeof preference.vendor !== "string" || !preference.vendor) return null;
+  return { vendor: preference.vendor };
+}
+
+function getNewSessionDefault(config, slug) {
+  var owner = findProject(config, access.parentSlugFor(slug) || slug);
+  return { preference: owner ? clean(owner.newSessionDefault) : null };
+}
+
+// A failed save leaves the in-memory config exactly as it was, so the daemon
+// never reports as saved something that is not on disk.
+function setNewSessionDefault(config, slug, preference, save) {
+  if (access.parentSlugFor(slug)) return { ok: false, error: "Worktrees inherit the project default from their parent project." };
+  var project = findProject(config, slug);
+  if (!project) return { ok: false, error: "Project not found" };
+  var had = Object.prototype.hasOwnProperty.call(project, "newSessionDefault");
+  var previous = project.newSessionDefault;
+  var next = clean(preference);
+  if (next) project.newSessionDefault = next;
+  else delete project.newSessionDefault;
+  try {
+    save(config);
+  } catch (error) {
+    if (had) project.newSessionDefault = previous;
+    else delete project.newSessionDefault;
+    return { ok: false, error: "The project default could not be saved." };
+  }
+  return { ok: true };
+}
+
+module.exports = { getNewSessionDefault: getNewSessionDefault, setNewSessionDefault: setNewSessionDefault };

package/lib/project-connection.js

@@ -83,6 +83,7 @@ function attachConnection(ctx) {
   var _vendorLogin = ctx._vendorLogin;
   var hydrateImageRefs = ctx.hydrateImageRefs;
   var resolveSessionForView = ctx.resolveSessionForView;
+  var sendSessionFoldersState = ctx.sendSessionFoldersState;
   var broadcastClientCount = ctx.broadcastClientCount;
   var broadcastPresence = ctx.broadcastPresence;
   var getProjectList = ctx.getProjectList;
@@ -233,6 +234,7 @@ function attachConnection(ctx) {
       sessions: sm.mapSessionsForClient(allSessions, undefined, undefined, wsUser ? wsUser.id : null),
     });
     if (_splitGroups) _splitGroups.sendConnectionState(ws);
+    if (sendSessionFoldersState) sendSessionFoldersState(ws);
 
     // Restore active session for this client from server-side presence
     var active = restoredState.active;
@@ -268,8 +270,8 @@ function attachConnection(ctx) {
 
       var total = active.history.length;
       var fromIndex = 0;
-      if (total > sm.HISTORY_PAGE_SIZE) {
-        fromIndex = sm.findTurnBoundary(active.history, Math.max(0, total - sm.HISTORY_PAGE_SIZE));
+      if (total > sm.INITIAL_HISTORY_SIZE) {
+        fromIndex = sm.findTurnBoundary(active.history, Math.max(0, total - sm.INITIAL_HISTORY_SIZE));
       }
       sendTo(ws, { type: "history_meta", total: total, from: fromIndex });
       for (var i = fromIndex; i < total; i++) {

package/lib/project-session-creation.js

@@ -0,0 +1,107 @@
+// Inline session creation for the project sidebar. The draft row's provider
+// dropdown lists every registered provider the server knows, flagging which are
+// installed and authorized for the caller; only those can be created. The model
+// and effort stay whatever the provider's existing defaults produce. This module
+// serves that list together with the project-scoped default provider, and saves
+// that default on request.
+//
+// The default is stored per project (daemon config, see new-session-default.js)
+// and holds a provider id only. It is never a per-user or global preference.
+
+var MAX_REQUEST_ID = 200;
+
+function cleanRequestId(value) {
+  return typeof value === "string" ? value.substring(0, MAX_REQUEST_ID) : null;
+}
+
+function attachSessionCreation(ctx) {
+  var slug = ctx.slug;
+  var usersModule = ctx.usersModule;
+  var opts = ctx.opts || {};
+  var sendTo = ctx.sendTo;
+
+  function actor(ws) {
+    if (!usersModule.isMultiUser()) return { ok: true, user: null };
+    var user = ws && ws._clayUser && usersModule.findUserById(ws._clayUser.id);
+    return user ? { ok: true, user: user } : { ok: false, user: null };
+  }
+
+  // Single-user installs own their projects. Otherwise project settings
+  // permission plus project ownership (or admin) is required, like the other
+  // project-wide defaults. Mate projects never get one; worktrees read their
+  // parent's default and cannot set their own.
+  function defaultPermission(ws) {
+    if (ctx.isMate === true) return { ok: false, error: "Not supported" };
+    var who = actor(ws);
+    if (!who.ok) return { ok: false, error: "Your account is no longer available." };
+    var access = ctx.getProjectAccess ? ctx.getProjectAccess() : null;
+    if (access && access.isWorktree === true) return { ok: false, error: "Worktrees use the default of their parent project." };
+    if (!usersModule.isMultiUser()) return { ok: true };
+    var permissions = usersModule.getEffectivePermissions ? usersModule.getEffectivePermissions(who.user, ctx.osUsers) : {};
+    var isOwner = !!(access && access.ownerId && access.ownerId === who.user.id);
+    var isAdmin = who.user.role === "admin";
+    if (!permissions.projectSettings || (!isOwner && !isAdmin)) return { ok: false, error: "Project settings access is not permitted" };
+    return { ok: true };
+  }
+
+  function readProjectDefault() {
+    if (typeof opts.onGetProjectNewSessionDefault !== "function") return null;
+    var stored = opts.onGetProjectNewSessionDefault(slug);
+    var value = stored && stored.preference;
+    return value && typeof value.vendor === "string" && value.vendor ? value.vendor : null;
+  }
+
+  function installed(ws) {
+    return (ctx.getVendorAvailability(ws) || []).filter(function (item) { return item.installed; });
+  }
+
+  function optionsMessage(ws, requestId) {
+    return {
+      type: "new_session_options", slug: slug, requestId: requestId,
+      vendors: (ctx.getVendorAvailability(ws) || []).map(function (item) { return { id: item.id, displayName: item.displayName, installed: item.installed === true }; }),
+      projectDefault: readProjectDefault(),
+      canSetProjectDefault: defaultPermission(ws).ok,
+    };
+  }
+
+  function wrongProject(ws, msg, type, requestId) {
+    if (msg.slug === undefined || msg.slug === slug) return false;
+    sendTo(ws, { type: type, slug: slug, requestId: requestId, ok: false, error: "This request belongs to a different project." });
+    return true;
+  }
+
+  function setDefault(ws, msg) {
+    var requestId = cleanRequestId(msg.requestId);
+    function reply(extra) { sendTo(ws, Object.assign({ type: "new_session_default_result", slug: slug, requestId: requestId }, extra)); }
+    if (wrongProject(ws, msg, "new_session_default_result", requestId)) return;
+    var permission = defaultPermission(ws);
+    if (!permission.ok) return reply({ ok: false, error: permission.error });
+    if (typeof opts.onSetProjectNewSessionDefault !== "function") return reply({ ok: false, error: "Not supported" });
+    var vendor = typeof msg.vendor === "string" ? msg.vendor : "";
+    if (!vendor || !installed(ws).some(function (item) { return item.id === vendor; })) return reply({ ok: false, error: "That provider is not installed or authorized." });
+    var result = opts.onSetProjectNewSessionDefault(slug, { vendor: vendor });
+    if (!result || result.ok !== true) return reply({ ok: false, error: result && result.error || "The project default could not be saved." });
+    reply({ ok: true, projectDefault: vendor });
+    if (typeof ctx.send === "function") ctx.send({ type: "new_session_project_default", slug: slug, projectDefault: vendor });
+  }
+
+  function handleMessage(ws, msg) {
+    if (msg.type === "new_session_options_get") {
+      var requestId = cleanRequestId(msg.requestId);
+      if (wrongProject(ws, msg, "new_session_options", requestId)) return true;
+      sendTo(ws, optionsMessage(ws, requestId));
+      return true;
+    }
+    if (msg.type === "new_session_default_set") { setDefault(ws, msg); return true; }
+    return false;
+  }
+
+  return { handleMessage: handleMessage, isInstalled: function (ws, vendor) { return isInstalledFor(ctx, ws, vendor); } };
+}
+
+function isInstalledFor(ctx, ws, vendor) {
+  if (typeof ctx.getVendorAvailability !== "function") return true;
+  return (ctx.getVendorAvailability(ws) || []).some(function (item) { return item.id === vendor && item.installed; });
+}
+
+module.exports = { attachSessionCreation: attachSessionCreation };

package/lib/project-session-delete.js

@@ -78,6 +78,25 @@ function attachSessionDelete(ctx) {
     else sm.deleteSessionsBulk(scope.ids, ws);
   }
 
+  // Authorizes a whole deletion before anything is removed: permission, access
+  // to every requested session, and access to every Split Worker a Driver owns
+  // (hidden sessions and previous generations included).
+  function planDeletion(ws, targets, access) {
+    if (!hasDeletePermission(ws)) return { ok: false, error: "You do not have permission to delete sessions" };
+    var canDelete = accessCheck(ws, access);
+    for (var i = 0; i < targets.length; i++) {
+      if (!canDelete(targets[i])) return { ok: false, error: "You cannot delete one of these sessions" };
+    }
+    return resolveDeletionScope(sm.sessions, targets, canDelete);
+  }
+
+  // Removes an authorized plan: runtimes are released first, then the records.
+  function executeDeletion(ws, plan) {
+    if (!plan || !plan.ok || plan.ids.length === 0) return;
+    releaseRuntime(plan.ids);
+    sm.deleteSessionsBulk(plan.ids, ws);
+  }
+
   function bulkDeleteSessions(ws, msg) {
     if (!Array.isArray(msg.sessionIds) || msg.sessionIds.length === 0) return;
     if (!hasDeletePermission(ws)) return refuse(ws, "You do not have permission to delete sessions");
@@ -91,11 +110,10 @@ function attachSessionDelete(ctx) {
     if (requested.length === 0) return;
     var scope = resolveDeletionScope(sm.sessions, requested, canDelete);
     if (!scope.ok) return refuse(ws, scope.error);
-    releaseRuntime(scope.ids);
-    sm.deleteSessionsBulk(scope.ids, ws);
+    executeDeletion(ws, scope);
   }
 
-  return { deleteSession: deleteSession, bulkDeleteSessions: bulkDeleteSessions };
+  return { deleteSession: deleteSession, bulkDeleteSessions: bulkDeleteSessions, planDeletion: planDeletion, executeDeletion: executeDeletion, hasDeletePermission: hasDeletePermission };
 }
 
 module.exports = { attachSessionDelete: attachSessionDelete, resolveDeletionScope: resolveDeletionScope };

package/lib/project-session-folder-delete.js

@@ -0,0 +1,169 @@
+// Folder deletion with a choice for the folder's sessions: move them to
+// Unfiled, move them to another folder, or delete them with the folder.
+//
+// The flow is two requests so a confirmation always describes what will happen:
+//   session_folders_delete_preview  -> the server's authoritative membership
+//                                      count and an opaque snapshot token
+//   session_folders_delete          -> the chosen mode plus that token
+// The token is a keyed digest of the folder, its current members and the full
+// deletion scope. If the contents changed in between (a session was filed into
+// the folder, moved out, or gained a Worker) the request is refused untouched
+// and a fresh preview is sent. Membership always comes from the caller's stored
+// state, never from what a filtered sidebar happens to render, and no origin
+// key ever leaves the server.
+
+var crypto = require("crypto");
+var folders = require("./session-folders");
+
+var SECRET = crypto.randomBytes(32);
+var MODES = ["unfiled", "move", "delete"];
+
+function attachFolderDelete(ctx) {
+  var slug = ctx.slug;
+  var sendTo = ctx.sendTo;
+
+  // The live members of a folder: every existing session the caller filed
+  // there, whatever the sidebar search currently shows. Keys whose session is
+  // gone are skipped (they are pruned when the folder state is saved).
+  function snapshot(userId, env, state, folderId, ws) {
+    var members = [];
+    Object.keys(state.assignments).forEach(function (key) {
+      if (state.assignments[key] === folderId && env.exists(key)) members.push(env.byKey[key]);
+    });
+    members.sort(function (a, b) { return a.localId - b.localId; });
+    var plan = ctx.sessionDelete.planDeletion(ws, members, ctx.getProjectAccess());
+    var scopeIds = plan.ok ? plan.ids.slice().sort(function (a, b) { return a - b; }) : [];
+    var workerIds = plan.ok ? plan.cascadedIds.slice().sort(function (a, b) { return a - b; }) : [];
+    var memberIds = members.map(function (s) { return s.localId; });
+    var digest = crypto.createHmac("sha256", SECRET)
+      .update(JSON.stringify([userId, slug, folderId, memberIds, scopeIds, plan.ok]))
+      .digest("hex").slice(0, 32);
+    return {
+      members: members, plan: plan, memberCount: memberIds.length,
+      workerCount: workerIds.length, totalCount: plan.ok ? scopeIds.length : memberIds.length,
+      token: digest,
+    };
+  }
+
+  function previewMessage(folderId, requestId, snap, hasPermission) {
+    return {
+      type: "session_folders_delete_preview_result", slug: slug, requestId: requestId || null, folderId: folderId,
+      sessionCount: snap.memberCount, workerCount: snap.workerCount, totalCount: snap.totalCount, token: snap.token,
+      canDeleteSessions: hasPermission && snap.plan.ok,
+      deleteBlockedReason: !hasPermission ? "You do not have permission to delete sessions" : (snap.plan.ok ? null : snap.plan.error),
+    };
+  }
+
+  // Persisting can throw (the multi-user store writes a file); that must come
+  // back as a correlated refusal, never as an acknowledgement or an exception.
+  function saveState(userId, nextState) {
+    try {
+      var saved = ctx.usersModule.setSessionFolders(userId, slug, nextState);
+      return saved && saved.error ? { error: saved.error } : { state: saved && saved.state ? saved.state : nextState };
+    } catch (e) {
+      console.error("[folders] saving folder state failed:", e && e.message);
+      return { error: "Could not save the folders" };
+    }
+  }
+
+  function reload(userId, env, fallback) {
+    try { return ctx.loadState(userId, env); } catch (e) { return fallback; }
+  }
+
+  function knownFolder(state, folderId) {
+    if (typeof folderId !== "string" || folderId === folders.FAVORITES_ID || folderId === folders.UNFILED_ID) return false;
+    return state.folders.some(function (f) { return f.id === folderId; });
+  }
+
+  function preview(ws, msg) {
+    var userId = ctx.userIdFor(ws);
+    if (!userId) return;
+    var rid = ctx.cleanRequestId(msg.requestId);
+    if (ctx.wrongProject(ws, msg.slug, rid)) return;
+    var env = ctx.buildEnv(userId);
+    var state = ctx.loadState(userId, env);
+    if (!knownFolder(state, msg.folderId)) {
+      sendTo(ws, ctx.stateMessage(state, env, { error: "Folder not found", requestId: rid }));
+      return;
+    }
+    var snap = snapshot(userId, env, state, msg.folderId, ws);
+    sendTo(ws, previewMessage(msg.folderId, rid, snap, ctx.sessionDelete.hasDeletePermission(ws)));
+  }
+
+  function refuse(ws, userId, env, state, rid, text, snapForRefresh, folderId) {
+    sendTo(ws, ctx.stateMessage(state, env, { error: text, requestId: rid, stale: !!snapForRefresh }));
+    if (snapForRefresh) sendTo(ws, previewMessage(folderId, rid, snapForRefresh, ctx.sessionDelete.hasDeletePermission(ws)));
+  }
+
+  function run(ws, msg) {
+    var userId = ctx.userIdFor(ws);
+    if (!userId) return;
+    var rid = ctx.cleanRequestId(msg.requestId);
+    if (ctx.wrongProject(ws, msg.slug, rid)) return;
+    var env = ctx.buildEnv(userId);
+    var state = ctx.loadState(userId, env);
+    var folderId = msg.folderId;
+    var mode = msg.mode;
+
+    // Everything below is validated before the first mutation.
+    if (!knownFolder(state, folderId)) return refuse(ws, userId, env, state, rid, "Folder not found");
+    if (MODES.indexOf(mode) === -1) return refuse(ws, userId, env, state, rid, "Choose what happens to the sessions");
+    if (mode === "move") {
+      var dest = msg.destinationId;
+      if (typeof dest !== "string" || dest === folderId || dest === folders.UNFILED_ID ||
+          !knownFolder(state, dest)) {
+        return refuse(ws, userId, env, state, rid, "Choose another folder for these sessions");
+      }
+    }
+    var snap = snapshot(userId, env, state, folderId, ws);
+    if (typeof msg.token !== "string" || msg.token !== snap.token) {
+      return refuse(ws, userId, env, state, rid, "This folder changed while you were deciding. Review it and try again.", snap, folderId);
+    }
+    if (mode === "delete" && msg.confirmDelete !== true) {
+      return refuse(ws, userId, env, state, rid, "Confirm that you want to delete these sessions");
+    }
+    if (mode === "delete" && !snap.plan.ok) {
+      return refuse(ws, userId, env, state, rid, snap.plan.error);
+    }
+
+    if (mode === "delete" && snap.members.length) {
+      try {
+        ctx.sessionDelete.executeDeletion(ws, snap.plan);
+      } catch (e) {
+        // The folder is left in place; whatever was already removed is pruned
+        // from it on the next state load.
+        console.error("[folders] session deletion failed:", e && e.message);
+        // Removal is not transactional: some sessions may already be gone.
+        var after = ctx.buildEnv(userId);
+        return refuse(ws, userId, after, reload(userId, after, state), rid,
+          "Deleting stopped part way. Some of these sessions may already have been deleted, and the folder was kept. Review the folder and try again.");
+      }
+      env = ctx.buildEnv(userId);
+    }
+
+    var op = mode === "move"
+      ? { op: "delete_folder", folderId: folderId, mode: "move", destinationId: msg.destinationId }
+      : { op: "delete_folder", folderId: folderId, mode: "unfiled" };
+    var result = folders.applyOperation(state, op, env);
+    if (result.error) return refuse(ws, userId, env, state, rid, result.error);
+    var saved = saveState(userId, result.state);
+    if (saved.error) {
+      var current = mode === "delete" ? reload(userId, env, state) : state;
+      return refuse(ws, userId, env, current, rid, mode === "delete"
+        ? "The sessions were deleted but the folder could not be removed. Try deleting it again."
+        : "The folder could not be updated, so nothing was changed. " + saved.error + ".");
+    }
+    ctx.pushToUser(userId, saved.state, env);
+    sendTo(ws, ctx.stateMessage(saved.state, env, { requestId: rid, folderDeleted: folderId }));
+  }
+
+  function handleMessage(ws, msg) {
+    if (msg.type === "session_folders_delete_preview") { preview(ws, msg); return true; }
+    if (msg.type === "session_folders_delete") { run(ws, msg); return true; }
+    return false;
+  }
+
+  return { handleMessage: handleMessage };
+}
+
+module.exports = { attachFolderDelete: attachFolderDelete };