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

package/lib/mate-scheduling.js

@@ -0,0 +1,103 @@
+var crypto = require('crypto');
+var userInput = require('./yoke/user-input');
+var input = require('./mate-schedule-input');
+var personal = require('./mcp-session-access');
+
+function attachMateScheduling(ctx) {
+  function owner(session) { return ctx.users.isMultiUser() ? session.ownerId : 'local-user'; }
+  function privateSession(session) {
+    if (!ctx.isMate || !session || ctx.sm.sessions.get(session.localId) !== session ||
+        session.destroying || session.mateCreationMode || session.taskStopRequested || session._mcpForeignInput ||
+        session.sessionVisibility === 'shared' || session.delegated || session._delegatedBy || session._pairDelegation) throw new Error('An active private Mate conversation is required.');
+    if (ctx.users.isMultiUser() && (session.ownerId !== ctx.projectOwnerId || !personal.canUsePersonalConnections(session, ctx.sm.sessions))) throw new Error('Only the Mate owner can schedule messages.');
+    if (!ctx.users.isMultiUser() && (session.ownerId || (session.history || []).some(function (event) { return event.type === 'user_message' && event.from && event.from !== 'default'; }))) throw new Error('Foreign input cannot authorize Mate schedules.');
+    ctx.authorizeAccess(session, owner(session));
+  }
+  function authorize(session) {
+    if (ctx.isHostAgent) throw new Error('Canonical Clay scheduling requires its separate owner-reviewed controls.');
+    privateSession(session);
+  }
+  function authorizeControl(session, control) {
+    privateSession(session);
+    return require('./canonical-clay-scheduling-authority').validate(control, ctx.slug, session);
+  }
+  function authorizeLifecycle(session) {
+    privateSession(session);
+    require('./canonical-clay-scheduling-authority').assertMate(ctx.projectOwnerId, ctx.mateId, ctx.users.isMultiUser());
+    if (ctx.isHostAgent) require('./canonical-clay-scheduling-authority').assertHost(ctx.projectOwnerId, ctx.mateId, ctx.users.isMultiUser());
+  }
+  function persistDraft(session, draft) {
+    var previous = session.mateScheduleDraft;
+    session.mateScheduleDraft = draft;
+    if (ctx.sm.saveSessionFile(session) !== true) {
+      session.mateScheduleDraft = previous;
+      throw new Error('The schedule draft could not be saved.');
+    }
+  }
+  function result(value) { return { content: [{ type: 'text', text: JSON.stringify(value) }] }; }
+  function getToolDefs(session) {
+    try { authorize(session); } catch (error) { return []; }
+    var generation = Number(session._sdkQueryGeneration || 0);
+    var originalOwner = owner(session);
+    function current() {
+      authorize(session);
+      if (generation !== Number(session._sdkQueryGeneration || 0) || owner(session) !== originalOwner) throw new Error('The schedule query is stale.');
+    }
+    function tool(name, description, properties, required, handler) {
+      return { name: name, queryBound: true, inputSchema: { type: 'object', properties: properties, required: required, additionalProperties: false },
+        description: description, handler: async function (args) {
+          try { current(); return result(await handler(args || {})); }
+          catch (error) { return result({ status: 'rejected', reason: error.message }); }
+        } };
+    }
+    var str = { type: 'string' };
+    var fields = { message: str, date: str, time: str, scheduleRule: { type: ['object', 'null'] } };
+    async function approve(draft, question, label, other) {
+      persistDraft(session, draft);
+      var reply = await userInput.dispatchUserInput(ctx.userInput(session), { questions: [{
+        id: 'approve', header: 'Mate schedule', question: question,
+        options: [{ label: label }, { label: other || 'Cancel' }], allowOther: false,
+      }] }, { source: 'mate-schedule', signal: session.abortController && session.abortController.signal });
+      current();
+      if (!session.mateScheduleDraft || session.mateScheduleDraft.id !== draft.id || session.mateScheduleDraft.revision !== draft.revision) throw new Error('The schedule draft is stale.');
+      var accepted = reply.status === 'submitted' && reply.answers.approve && reply.answers.approve.length === 1 && reply.answers.approve[0] === label;
+      if (!accepted) persistDraft(session, null);
+      return accepted;
+    }
+    async function review(args, update) {
+      var previous = update ? ctx.lifecycle.read(session, args) : null;
+      var value = input.normalize(args, previous);
+      var draft = { id: crypto.randomUUID(), revision: crypto.randomUUID(), value: value,
+        targetId: previous && previous.id, targetRevision: previous && previous.revision };
+      if (!await approve(draft, (update ? 'Update this schedule?\n' : 'Create this schedule?\n') + input.review(value), update ? 'Update schedule' : 'Create schedule')) return { status: 'cancelled' };
+      var record = update ? ctx.lifecycle.update(session, { id: draft.targetId, revision: draft.targetRevision }, value) : ctx.lifecycle.create(session, value, draft.id);
+      persistDraft(session, null);
+      return { status: update ? 'updated' : 'created', schedule: record, timezone: input.timezone() };
+    }
+    async function cancel(args) {
+      var record = ctx.lifecycle.read(session, args);
+      if (record.state === 'cancelled') return { status: 'cancelled', schedule: record };
+      var draft = { id: crypto.randomUUID(), revision: crypto.randomUUID(), targetId: record.id, targetRevision: record.revision };
+      if (!await approve(draft, 'Cancel this schedule?\n' + input.review({ message: record.message, rule: record.rule }), 'Cancel schedule', 'Keep schedule')) return { status: 'unchanged' };
+      record = ctx.lifecycle.cancel(session, { id: draft.targetId, revision: draft.targetRevision });
+      persistDraft(session, null);
+      return { status: 'cancelled', schedule: record };
+    }
+    var begin = tool('begin_mate_schedule_interview', 'Begin scheduling for this Mate. Ask exactly one structured question at a time. Never assume repetition.', {}, [], function () {
+      return { status: 'interview_started', timezone: input.timezone(), guidance: 'Collect the message, date/time, and explicitly requested repetition one question at a time. Then propose the complete schedule for the human approval card.' };
+    });
+    begin.structuredQuestionLimit = function () { try { current(); return 1; } catch (error) { return null; } };
+    return [begin,
+      tool('propose_mate_schedule', 'Review a complete message schedule in a server-owned approval card. Only authenticated human approval persists a schedule.', fields, ['message'], function (args) { return review(args, false); }),
+      tool('list_mate_schedules', 'List logical schedules and their stable IDs, revisions and lifecycle states in this private conversation.', {}, [], function () { return { schedules: ctx.lifecycle.list(session) }; }),
+      tool('read_mate_schedule', 'Read one logical schedule using its listed ID.', { id: str }, ['id'], function (args) { return { schedule: ctx.lifecycle.read(session, args) }; }),
+      tool('update_mate_schedule', 'Propose changes to an active schedule by listed ID and revision, with a fresh human approval card.', Object.assign({ id: str, revision: str }, fields), ['id', 'revision'], function (args) { return review(args, true); }),
+      tool('cancel_mate_schedule', 'Review cancellation by listed ID and revision in an authenticated human approval card. Cancellation persists across restart.', { id: str, revision: str }, ['id', 'revision'], cancel),
+    ];
+  }
+  return { authorize: authorize, authorizeControl: authorizeControl, authorizeLifecycle: authorizeLifecycle, owner: owner, getToolDefs: getToolDefs, getSystemPrompt: function (session) {
+    try { authorize(session); } catch (error) { return ''; }
+    return 'When scheduling for this Mate, call begin_mate_schedule_interview, ask exactly one structured question at a time, and clarify the message, local date/time in ' + input.timezone() + ', and explicitly requested repetition. Use scheduleRule for recurrence and count/until limits. propose_mate_schedule and update_mate_schedule present the exact authenticated human approval card. Chat text and model flags never approve schedules. Use listed logical IDs and revisions to read, update or cancel. Scheduled output uses this private Mate runtime and tools. Project Scheduled Tasks Driver/Worker tools remain unavailable.';
+  } };
+}
+module.exports = { attachMateScheduling: attachMateScheduling };

package/lib/mates.js

@@ -246,7 +246,7 @@ function updateMate(ctx, id, updates) {
   return null;
 }
 
-function deleteMate(ctx, id) {
+function deleteMate(ctx, id, options) {
   var data = loadMates(ctx);
   // Primary mates cannot be deleted (they are system infrastructure)
   for (var di = 0; di < data.mates.length; di++) {
@@ -259,15 +259,16 @@ function deleteMate(ctx, id) {
     return m.id !== id;
   });
   if (data.mates.length === before) return { error: "Mate not found" };
-  saveMates(ctx, data);
+  if (!options || !options.strictCleanup) saveMates(ctx, data);
 
   // Remove mate directory
   var mateDir = getMateDir(ctx, id);
   try {
     fs.rmSync(mateDir, { recursive: true, force: true });
   } catch (e) {
-    // Directory may not exist
+    if (options && options.strictCleanup) throw e;
   }
+  if (options && options.strictCleanup) saveMates(ctx, data);
 
   return { ok: true };
 }

package/lib/notes-checklist.js

@@ -0,0 +1,50 @@
+// Bounded source identities shared by checklist validation and reconciliation.
+function items(text) {
+  var lines = (text || '').split('\n').slice(1);
+  var occurrences = Object.create(null);
+  var out = [];
+  var fence = null;
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+    var match = line.match(/^\s*(\x60{3,}|~{3,})/);
+    if (match) { fence = fence === match[1].charAt(0) ? null : (fence || match[1].charAt(0)); continue; }
+    if (fence || !line.trim() || /^\s*#{1,6}\s/.test(line)) continue;
+    var occurrence = occurrences[line] || 0;
+    occurrences[line] = occurrence + 1;
+    var key = line + '\u0000' + occurrence;
+    if (i <= 1000 && key.length <= 2000 && encodeURIComponent(key).length <= 2000) out.push({ index: i, key: key });
+  }
+  return out;
+}
+
+function validState(value) {
+  if (!Array.isArray(value) && (!value || typeof value !== 'object')) return false;
+  var keys = Object.keys(value);
+  if (keys.length > 1000) return false;
+  for (var i = 0; i < keys.length; i++) {
+    if (keys[i].length > 2000 || typeof value[keys[i]] !== 'boolean') return false;
+  }
+  return true;
+}
+
+function normalizeState(value, text) {
+  var state = {};
+  items(text).forEach(function (item) {
+    var checked = value && value[Array.isArray(value) ? item.index : item.key];
+    if (typeof checked === 'boolean' && Object.keys(state).length < 1000) state[item.key] = checked;
+  });
+  return state;
+}
+
+function validateChange(note, changes) {
+  if (changes.checklistIndex === undefined) return null;
+  if (!Number.isInteger(changes.checklistIndex) || changes.checklistIndex < 0 || changes.checklistIndex > 1000) return null;
+  if (typeof changes.checklistChecked !== 'boolean' || typeof changes.checklistSource !== 'string' || typeof changes.checklistKey !== 'string') return null;
+  if (changes.checklistSource !== note.text || changes.checklistKey.length > 2000 || (changes.text !== undefined && changes.text !== note.text)) return null;
+  var item = items(note.text).find(function (item) { return item.index === changes.checklistIndex; });
+  var state = normalizeState(note.checklistState, note.text);
+  if (item && state[item.key] === undefined && Object.keys(state).length >= 1000) return null;
+  try { return item && item.key === decodeURIComponent(changes.checklistKey) ? item.key : null; } catch (error) { return null; }
+}
+
+module.exports = { validState: validState, normalizeState: normalizeState, validateChange: validateChange };

package/lib/notes.js

@@ -4,6 +4,7 @@ var crypto = require("crypto");
 var config = require("./config");
 var utils = require("./utils");
 var lifecycle = require("./notes-lifecycle");
+var checklist = require("./notes-checklist");
 
 function createNotesManager(opts) {
   var cwd = opts.cwd;
@@ -61,6 +62,8 @@ function createNotesManager(opts) {
       h: typeof data.h === "number" ? data.h : 180,
       color: data.color || "purple",
       opacity: typeof data.opacity === "number" ? data.opacity : 0.64,
+      checklistMode: data.checklistMode === true,
+      checklistState: checklist.validState(data.checklistState) ? checklist.normalizeState(data.checklistState, data.text || "") : [],
       minimized: false,
       // A new note is always an open attention item.
       state: lifecycle.STATE_OPEN,
@@ -84,13 +87,33 @@ function createNotesManager(opts) {
   function update(id, changes) {
     for (var i = 0; i < notes.length; i++) {
       if (notes[i].id === id) {
-        var allowed = ["text", "x", "y", "w", "h", "color", "minimized", "zIndex", "opacity"];
+        if (changes.checklistConvert === true) {
+          if (changes.checklistSource !== notes[i].text || changes.checklistVersion !== notes[i].updatedAt || notes[i].checklistMode === true) return null;
+          changes = Object.assign({}, changes, { text: "", checklistState: {}, checklistMode: true });
+        }
+        if (changes.checklistEdit === true && (notes[i].checklistMode !== true || changes.checklistSource !== notes[i].text || changes.checklistVersion !== notes[i].updatedAt || typeof changes.text !== "string")) return null;
+        if (changes.checklistMode !== undefined && typeof changes.checklistMode !== "boolean") return null;
+        if (changes.checklistState !== undefined && !checklist.validState(changes.checklistState)) return null;
+        var checklistKey = checklist.validateChange(notes[i], changes);
+        if (changes.checklistIndex !== undefined && !checklistKey) return null;
+        var previous = {};
+        var snapshotKeys = ["text", "x", "y", "w", "h", "color", "minimized", "zIndex", "opacity", "checklistMode", "checklistState", "hidden", "state", "closedAt", "closedBy", "updatedAt"];
+        for (var s = 0; s < snapshotKeys.length; s++) previous[snapshotKeys[s]] = notes[i][snapshotKeys[s]];
+        var allowed = ["text", "x", "y", "w", "h", "color", "minimized", "zIndex", "opacity", "checklistMode", "checklistState"];
         for (var j = 0; j < allowed.length; j++) {
           var key = allowed[j];
           if (changes[key] !== undefined) {
             notes[i][key] = changes[key];
           }
         }
+        if (checklistKey) {
+          var state = checklist.normalizeState(notes[i].checklistState, notes[i].text);
+          state[checklistKey] = changes.checklistChecked === true;
+          notes[i].checklistState = state;
+        }
+        if (changes.text !== undefined || changes.checklistState !== undefined || checklistKey) {
+          notes[i].checklistState = checklist.normalizeState(notes[i].checklistState, notes[i].text);
+        }
         // `hidden` is the legacy spelling of the lifecycle. Route it through the
         // transitions so state, hidden, and the close provenance can never
         // disagree, and so an old client cannot half-apply a close.
@@ -98,8 +121,11 @@ function createNotesManager(opts) {
           if (changes.hidden === true) lifecycle.applyClose(notes[i], changes.actor || null, Date.now());
           else lifecycle.applyReopen(notes[i]);
         }
-        notes[i].updatedAt = Date.now();
-        saveToDisk();
+        notes[i].updatedAt = Math.max(Date.now(), (previous.updatedAt || 0) + 1);
+        if (!saveToDisk()) {
+          for (var p = 0; p < snapshotKeys.length; p++) notes[i][snapshotKeys[p]] = previous[snapshotKeys[p]];
+          return null;
+        }
         return notes[i];
       }
     }
@@ -120,6 +146,25 @@ function createNotesManager(opts) {
     return null;
   }
 
+  // Human close includes the visible draft and an exact canonical snapshot.
+  // Recheck it here, then persist draft + lifecycle/removal in one transaction.
+  function closeHuman(id, changes, actor) {
+    for (var i = 0; i < notes.length; i++) {
+      var note = notes[i];
+      if (note.id !== id) continue;
+      if (note.text !== changes.expectedText || note.updatedAt !== changes.expectedVersion || typeof changes.draftText !== "string") return null;
+      if (!changes.draftText.trim()) {
+        notes.splice(i, 1);
+        if (saveToDisk()) return { removed: note };
+        notes.splice(i, 0, note);
+        return null;
+      }
+      var updated = update(id, { text: changes.draftText, hidden: true, actor: actor });
+      return updated ? { note: updated } : null;
+    }
+    return null;
+  }
+
   // Reopen a closed note. Idempotent.
   function reopen(id) {
     for (var i = 0; i < notes.length; i++) {
@@ -211,6 +256,7 @@ function createNotesManager(opts) {
     create: create,
     update: update,
     close: close,
+    closeHuman: closeHuman,
     reopen: reopen,
     remove: remove,
     removeClosed: removeClosed,

package/lib/os-users.js

@@ -153,6 +153,19 @@ function fsAsUser(op, args, osUserInfo) {
     });
     var binOutput = execFileSync(binSpawn.command, binSpawn.args, binSpawn.options);
     return { buffer: Buffer.from(binOutput.trim(), "base64") };
+  } else if (op === 'write_exact') {
+    script = [
+      "var fs = require('fs'), crypto = require('crypto'), path = require('path');",
+      "var f = " + JSON.stringify(args.file) + "; var expected = " + JSON.stringify(args.expected) + ";",
+      "var root = " + JSON.stringify(args.root) + "; var relative = path.relative(root, f);",
+      "function checkPath() { if (fs.realpathSync(root) !== root || path.isAbsolute(relative) || relative.split(path.sep).indexOf('..') >= 0) throw new Error('The canonical file boundary changed.'); var at = root; relative.split(path.sep).forEach(function (part) { at = path.join(at, part); if (fs.lstatSync(at).isSymbolicLink()) throw new Error('File parent symlinks are unavailable.'); }); }",
+      "checkPath();",
+      "var fd = fs.openSync(f, fs.constants.O_RDWR | fs.constants.O_NOFOLLOW);",
+      "try { var s = fs.fstatSync(fd);",
+      "if (!s.isFile() || s.nlink !== 1 || s.dev !== expected.dev || s.ino !== expected.ino || s.mode !== expected.mode || s.uid !== expected.uid || s.gid !== expected.gid || s.size !== expected.size || s.mtimeMs !== expected.mtime || crypto.createHash('sha256').update(fs.readFileSync(fd, 'utf8')).digest('hex') !== expected.hash) throw new Error('The exact file revision changed.');",
+      "checkPath(); fs.ftruncateSync(fd, 0); var bytes = Buffer.from(" + JSON.stringify(args.content) + ", 'utf8'), offset = 0; while (offset < bytes.length) { var written = fs.writeSync(fd, bytes, offset, bytes.length - offset, offset); if (!written) throw new Error('File write made no progress.'); offset += written; } fs.fsyncSync(fd); } finally { fs.closeSync(fd); }",
+      "process.stdout.write(JSON.stringify({ ok: true }));",
+    ].join(' ');
   } else if (op === "write") {
     script = [
       "var fs = require('fs');",
@@ -267,18 +280,18 @@ function isHomeDirectory(dirPath) {
  * Uses setfacl to add recursive + default ACL entries.
  * Skips home directories to avoid slow recursive ACL on large trees.
  */
-function grantProjectAccess(projectPath, linuxUser) {
+function grantProjectAccess(projectPath, linuxUser, options) {
   if (isHomeDirectory(projectPath)) {
     console.log("[os-users] Skipping ACL for home directory: " + projectPath);
-    return;
+    return true;
   }
   if (!isSafeLinuxUsername(linuxUser)) {
     console.error("[os-users] Invalid Linux username for ACL grant: " + linuxUser);
-    return;
+    return false;
   }
   var cacheKey = aclCacheKey(projectPath, linuxUser);
-  if (_aclGrantCache[cacheKey]) {
-    return;
+  if (_aclGrantCache[cacheKey] && !(options && options.force)) {
+    return true;
   }
   try {
     // Recursive ACL for existing files
@@ -295,6 +308,7 @@ function grantProjectAccess(projectPath, linuxUser) {
     });
     _aclGrantCache[cacheKey] = true;
     console.log("[os-users] Granted ACL access for " + linuxUser + " on " + projectPath);
+    return true;
   } catch (e) {
     delete _aclGrantCache[cacheKey];
     var errMsg = (e.stderr || e.message || "").toString();
@@ -305,6 +319,7 @@ function grantProjectAccess(projectPath, linuxUser) {
     } else {
       console.error("[os-users] Failed to grant ACL access for " + linuxUser + " on " + projectPath + ": " + errMsg);
     }
+    return false;
   }
 }
 

package/lib/project-admin-overview.js

@@ -0,0 +1,51 @@
+// This projection is an allowlist. Never add runtime/session/path objects here.
+function projectMetadata(status, access, users) {
+  if (!status || status.isMate || !access || access.error) return null;
+  var owner = access.ownerId && users.findUserById(access.ownerId);
+  return {
+    slug: status.slug,
+    project: status.title || status.project || status.slug,
+    title: status.title || status.project || status.slug,
+    projectOwnerId: owner ? owner.id : null,
+    ownerName: owner ? (owner.displayName || owner.username) : "Ownership needs recovery",
+    visibility: access.visibility,
+    contentAccess: false,
+    administrativeAccess: true,
+    ownershipRecovery: access.ownershipRecovery === "required" || !owner,
+    runtimeHealth: "Registered",
+  };
+}
+
+function metadataFor(user, status, access, users) {
+  if (!user || !users.findUserById(user.id) || user.role !== "admin" || !status || status.isMate || /^mate-/.test(status.slug)) return null;
+  return projectMetadata(status, access, users);
+}
+
+function escape(value) {
+  return String(value || "").replace(/[&<>"']/g, function (character) {
+    return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[character];
+  });
+}
+
+function page(metadata, projects) {
+  var privacyText = metadata.ownershipRecovery
+    ? "Content remains restricted because no verified owner is available. Ask the server operator to verify the account’s OS UID and real home/project mapping, then run the documented ownership repair."
+    : "Conversations, files and terminals are private. Ask the owner to share project access.";
+  var accessText = metadata.ownershipRecovery
+    ? "Ownership needs recovery. The server operator must independently verify or repair the authoritative account-to-OS mapping before ownership repair can succeed. Ambiguous records stay restricted; administrator status cannot claim this project. See the Project ownership and administrator access guide."
+    : "Only the project owner can change ownership, visibility and sharing. Administrator status does not grant access to private content.";
+  var strip = projects.filter(function (project) { return !project.isMate; }).map(function (project) {
+    return '<a class="icon-strip-item' + (project.slug === metadata.slug ? ' active' : '') + '" href="/p/' + encodeURIComponent(project.slug) + '/" title="' + escape(project.title || project.project) + '"><span class="icon-strip-name">' + escape((project.title || project.project || project.slug).substring(0, 2)) + '</span></a>';
+  }).join("");
+  return '<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>' + escape(metadata.title) + ' · Clay</title>' +
+    '<script src="/appearance-bootstrap.js"></script><link rel="stylesheet" href="/style.css"><link rel="stylesheet" href="/css/project-admin-overview.css"></head><body>' +
+    '<div id="layout"><header id="top-bar"><a href="/" class="top-bar-brand-link" aria-label="Clay home"><span class="top-bar-brand-wordmark"></span></a></header>' +
+    '<div id="layout-body"><nav id="icon-strip" aria-label="Projects"><div class="icon-strip-projects">' + strip + '</div></nav>' +
+    '<main id="main-area" class="project-admin-overview"><div class="project-admin-canvas"><h1>' + escape(metadata.title) + '</h1>' +
+    '<div role="tablist" aria-label="Project information"><button type="button" role="tab" aria-selected="true" id="overview-tab" aria-controls="overview-panel">Overview</button><button type="button" role="tab" aria-selected="false" id="access-tab" aria-controls="access-panel">Access</button></div>' +
+    '<section id="overview-panel" role="tabpanel" aria-labelledby="overview-tab"><dl><dt>Owner</dt><dd>' + escape(metadata.ownerName) + '</dd><dt>Visibility</dt><dd>' + escape(metadata.visibility) + '</dd><dt>Status</dt><dd>' + (metadata.ownershipRecovery ? 'Ownership needs recovery' : escape(metadata.runtimeHealth)) + '</dd><dt>Your access</dt><dd>Administrative metadata only</dd></dl><p>' + escape(privacyText) + '</p><p class="project-admin-secondary">Resource usage is unavailable for this project.</p></section>' +
+    '<section id="access-panel" role="tabpanel" aria-labelledby="access-tab" hidden><h2>Administrative metadata only</h2><p>' + escape(accessText) + '</p></section></div></main></div></div>' +
+    '<script type="module" src="/modules/project-admin-overview.js"></script></body></html>';
+}
+
+module.exports = { metadataFor: metadataFor, page: page };

package/lib/project-ask-user.js

@@ -25,7 +25,7 @@ function attachAskUser(ctx) {
       respond.cancel("Autonomous mode. Make your own decision.");
       return;
     }
-    var questions = request.source === "mcp-import" ? request.questions : planningQuestions(boundSession, request.questions);
+    var questions = ["mcp-import", "product-control"].indexOf(request.source) >= 0 ? request.questions : planningQuestions(boundSession, request.questions);
     var input = { questions: questions };
     if (request.source === 'mcp-import') input.source = 'mcp-import';
     if (!boundSession.pendingAskUser) boundSession.pendingAskUser = {};
@@ -40,6 +40,8 @@ function attachAskUser(ctx) {
     boundSession.pendingAskUser[request.id] = pending;
     if (respond && typeof respond.onSettle === "function") {
       respond.onSettle(function (result) {
+        if (request.source === 'product-control' && result.status !== 'submitted') ctx.record(boundSession, { type: 'product_control_question_expired', toolId: request.id, error: 'This exact change review expired or was cancelled. No change was authorized.' });
+        if (request.source === 'mate-schedule' && result.status !== 'submitted') ctx.record(boundSession, { type: 'mate_schedule_question_expired', toolId: request.id, error: 'This schedule review expired. Request a new review.' });
         if (request.source === 'mcp-import' && result.status !== 'submitted') ctx.record(boundSession, { type: 'mcp_import_consent_expired', toolId: request.id, source: 'mcp-import', error: 'Import consent expired or was cancelled. No connection was imported.' });
         if (boundSession.pendingAskUser && boundSession.pendingAskUser[request.id] === pending) delete boundSession.pendingAskUser[request.id];
       });
@@ -48,7 +50,7 @@ function attachAskUser(ctx) {
       ctx.record(boundSession, { type: "tool_executing", id: request.id, name: "AskUserQuestion", input: input, source: request.source });
     }
     var router = ctx.getWorkerQuestionRouter && ctx.getWorkerQuestionRouter();
-    if (router && request.source !== "mcp-import") router.routeQuestion(boundSession, request, respond, function (answers, driverId) {
+    if (router && request.source !== "mcp-import" && request.source !== "mate-schedule" && request.source !== "product-control") router.routeQuestion(boundSession, request, respond, function (answers, driverId) {
       var displayAnswers = {};
       request.questions.forEach(function (question, index) { displayAnswers[index] = answers[question.id].join(", "); });
       ctx.record(boundSession, { type: "ask_user_answered", toolId: request.id, answers: displayAnswers, answeredByDriver: driverId });

package/lib/project-delegated-follow-up.js

@@ -12,7 +12,7 @@ function unsafeReason(session, isPaired) {
   if (session.homeDebatePlanning || session.homeDebatePhase || session.debateSetupMode || session.debateState || session._debate) return "Debate sessions cannot receive project follow-ups.";
   if (session.loop || session.spawn || session.handoff || session.assignment || session.singleTurn || session._pairDelegation || isPaired) return "Orchestrated sessions cannot receive project follow-ups.";
   if (session.dangerouslySkipPermissions || session.permissionMode === "bypassPermissions") return "Full-access sessions cannot receive project follow-ups.";
-  if (session.destroying || session.scheduledMessage || session.rateLimitAutoContinuePending || session.taskStopRequested || session._runtimeRefreshRequested || session.pendingPush && session.pendingPush.length) return "Target session is not safely resumable right now.";
+  if (session.destroying || session.scheduledMessage || session.rateLimitAutoContinuePending || session.taskStopRequested || session._pendingMessageDrainPaused || session._runtimeRefreshRequested || session.pendingPush && session.pendingPush.length) return "Target session is not safely resumable right now.";
   return "";
 }
 
@@ -36,6 +36,7 @@ function attachDelegatedFollowUp(ctx) {
     var paired = !!(ctx.isPairedSession && ctx.isPairedSession(session));
     var reason = unsafeReason(session, paired);
     if (reason) throw new Error(reason);
+    if (ctx.isPendingQueuePaused && ctx.isPendingQueuePaused(session)) throw new Error("The Driver queue is stopped; explicit owner resume is required.");
     if (!ctx.canResumeVendor(session.vendor)) throw new Error("Target session provider cannot safely resume this conversation.");
     return { session: session, sessionRef: targetSessionRef, title: session.title || "Existing session" };
   }

package/lib/project-directory-claim.js

@@ -0,0 +1,65 @@
+// Reserve a new project directory before running Git or changing ownership.
+// Filesystem identity checks also keep failed attempts from deleting targets
+// replaced by another actor. Hostile OS/root mutation is outside this boundary.
+var fs = require("fs");
+var path = require("path");
+
+function canonical(candidate) {
+  var current = path.resolve(candidate);
+  var missing = [];
+  while (true) {
+    try { return path.join.apply(path, [fs.realpathSync(current)].concat(missing)); }
+    catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      // A dangling symlink is an existing object, not a missing directory.
+      try { fs.lstatSync(current); throw new Error("A project path contains a dangling symlink."); }
+      catch (statError) { if (statError.code !== "ENOENT") throw statError; }
+      var parent = path.dirname(current);
+      if (parent === current) throw error;
+      missing.unshift(path.basename(current));
+      current = parent;
+    }
+  }
+}
+
+function inside(root, candidate) {
+  var relative = path.relative(root, candidate);
+  return relative !== ".." && relative.indexOf(".." + path.sep) !== 0 && !path.isAbsolute(relative);
+}
+
+function rejectIntersection(target, projects, userId) {
+  (projects || []).forEach(function (project) {
+    var root = canonical(project.path);
+    if (target === root || inside(target, root) || (project.ownerId !== userId && inside(root, target))) {
+      throw new Error("The destination intersects a registered project.");
+    }
+  });
+}
+
+function claim(options) {
+  var slug = options.slug;
+  if (!slug || slug === "." || slug === ".." || path.basename(slug) !== slug) throw new Error("Invalid project directory name.");
+  var base = canonical(options.baseDir);
+  var target = path.join(base, slug);
+  rejectIntersection(target, options.projects, options.userId);
+  fs.mkdirSync(base, { recursive: true });
+  if (fs.realpathSync(options.baseDir) !== base) throw new Error("The project base directory changed.");
+  rejectIntersection(target, options.projects, options.userId);
+  // EEXIST rejects directories, files, symlinks and concurrent claims alike.
+  fs.mkdirSync(target, { mode: 0o700 });
+  var identity = fs.lstatSync(target);
+  function assertOwned() {
+    var current = fs.lstatSync(target);
+    if (!current.isDirectory() || current.isSymbolicLink() || current.dev !== identity.dev || current.ino !== identity.ino || fs.realpathSync(base) !== base) {
+      throw new Error("The claimed project directory changed.");
+    }
+  }
+  function cleanup() {
+    try { assertOwned(); } catch (error) { return false; }
+    fs.rmSync(target, { recursive: true });
+    return true;
+  }
+  return { path: target, assertOwned: assertOwned, cleanup: cleanup };
+}
+
+module.exports = { claim: claim, canonical: canonical };

package/lib/project-file-operations.js

@@ -0,0 +1,61 @@
+// Shared file-viewer effects. Authority and scope are derived by each caller.
+var fs = require('fs'), path = require('path'), crypto = require('crypto');
+var resolve = require('./project-file-path').resolveFilePath;
+function hash(content) { return crypto.createHash('sha256').update(content).digest('hex'); }
+function attachFileOperations(ctx) {
+  function list(scope, requested) {
+    var dir = resolve(ctx.cwd, requested || '.', scope);
+    var items = scope.identity ? ctx.fsAsUser('list', { dir: dir }, scope.identity) : fs.readdirSync(dir, { withFileTypes: true }).map(function (item) { return { name: item.name, isDir: item.isDirectory() }; });
+    return items.filter(function (item) { return !item.isDir || !ctx.IGNORED_DIRS.has(item.name); }).map(function (item) { return { name: item.name, type: item.isDir ? 'dir' : 'file', path: path.relative(ctx.cwd, path.join(dir, item.name)).split(path.sep).join('/') }; });
+  }
+  function read(scope, requested) {
+    var file = resolve(ctx.cwd, requested, scope), identity = scope.identity;
+    var stat = identity ? ctx.fsAsUser('stat', { file: file }, identity) : fs.statSync(file);
+    if (stat.size > ctx.FS_MAX_SIZE) return { binary: true, size: stat.size, error: 'File too large (' + (stat.size / 1024 / 1024).toFixed(1) + ' MB)' };
+    var ext = path.extname(file).toLowerCase();
+    if (ctx.BINARY_EXTS.has(ext)) {
+      var binary = { binary: true, size: stat.size };
+      if (ctx.IMAGE_EXTS.has(ext)) binary.imageUrl = 'api/file?path=' + encodeURIComponent(requested);
+      return binary;
+    }
+    return { content: identity ? ctx.fsAsUser('read', { file: file, readContent: true }, identity).content : fs.readFileSync(file, 'utf8'), size: stat.size };
+  }
+  function snapshot(scope, requested) {
+    var file = resolve(ctx.cwd, requested, scope), stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > 65536) throw new Error('Select a regular, singly linked text file of at most 64 KB.');
+    var result = read(scope, requested);
+    if (result.binary || typeof result.content !== 'string' || result.content.indexOf('\0') >= 0) throw new Error('Binary files are unavailable for canonical editing.');
+    return { dev: stat.dev, ino: stat.ino, mode: stat.mode, uid: stat.uid, gid: stat.gid, size: stat.size, mtime: stat.mtimeMs, hash: hash(result.content) };
+  }
+  function write(scope, requested, content, control) {
+    var file = resolve(ctx.cwd, requested, scope), attempted = false;
+    if (!control) {
+      if (scope.identity) ctx.fsAsUser('write', { file: file, content: content }, scope.identity);
+      else fs.writeFileSync(file, content, 'utf8');
+      return { ok: true };
+    }
+    if (typeof fs.constants.O_NOFOLLOW !== 'number') throw new Error('Canonical editing requires no-follow file descriptors on this platform.');
+    control.revalidate();
+    if (JSON.stringify(snapshot(scope, requested)) !== JSON.stringify(control.expected)) throw new Error('The exact file revision changed.');
+    try {
+      attempted = true;
+      if (scope.identity) ctx.fsAsUser('write_exact', { file: file, content: content, expected: control.expected, root: fs.realpathSync(ctx.cwd) }, scope.identity);
+      else {
+        var fd = fs.openSync(file, fs.constants.O_RDWR | fs.constants.O_NOFOLLOW);
+        try {
+          var stat = fs.fstatSync(fd), expected = control.expected;
+          if (!stat.isFile() || stat.nlink !== 1 || stat.dev !== expected.dev || stat.ino !== expected.ino || stat.mode !== expected.mode || stat.uid !== expected.uid || stat.gid !== expected.gid || stat.size !== expected.size || stat.mtimeMs !== expected.mtime || hash(fs.readFileSync(fd, 'utf8')) !== expected.hash) throw new Error('The open file revision changed.');
+          control.revalidate();
+          fs.ftruncateSync(fd, 0);
+          var bytes = Buffer.from(content, 'utf8'), offset = 0;
+          while (offset < bytes.length) { var written = fs.writeSync(fd, bytes, offset, bytes.length - offset, offset); if (!written) throw new Error('File write made no progress.'); offset += written; }
+          fs.fsyncSync(fd);
+        } finally { fs.closeSync(fd); }
+      }
+      control.revalidate();
+      return { status: 'completed', persisted: true, path: requested };
+    } catch (error) { error.productControlResult = { persisted: attempted ? 'unknown' : false, retrySafe: false, error: error.message }; throw error; }
+  }
+  return { list: list, read: read, write: write, snapshot: snapshot };
+}
+module.exports = { attachFileOperations: attachFileOperations };