clay-server 4.1.0-beta.4 → 4.1.0-beta.6

package/lib/autonomous-run-record.js

@@ -0,0 +1,32 @@
+var crypto = require("crypto");
+var ACTIVE_STATES = ["armed", "running", "reviewing", "waiting-worker", "waiting-user", "paused"];
+var TERMINAL_STATES = ["completed", "stopped", "limit", "error"];
+function clean(value, max) { return typeof value === "string" ? value.trim().substring(0, max) : ""; }
+function integer(value, fallback, max) { var number = Number(value); return Number.isFinite(number) ? Math.max(1, Math.min(max, Math.floor(number))) : fallback; }
+function criteria(value) { return (Array.isArray(value) ? value : []).slice(0, 10).map(function (item) { return clean(item, 1000); }).filter(Boolean); }
+function project(run) {
+  if (!run) return null;
+  return { id: run.id, state: run.state, objective: run.objective || "", successCriteria: run.successCriteria || [], continuationCount: run.continuationCount || 0,
+    maxContinuations: run.maxContinuations, startedAt: run.startedAt || null, deadlineAt: run.deadlineAt || null, maxMinutes: run.maxMinutes,
+    waitingReason: run.waitingReason || "", terminalReason: run.terminalReason || "", outcome: run.outcome || null, pausedAfterRestart: !!run.pausedAfterRestart,
+    armToken: run.state === "armed" ? run.armToken : undefined };
+}
+function restore(value) {
+  if (!value || typeof value !== "object" || ACTIVE_STATES.concat(TERMINAL_STATES).indexOf(value.state) === -1) return null;
+  var evidence = value.outcome && Array.isArray(value.outcome.evidence) ? value.outcome.evidence.slice(0, 20).map(function (item) { return clean(item, 2000); }).filter(Boolean) : [];
+  var assessments = value.outcome && Array.isArray(value.outcome.criteria) ? value.outcome.criteria.slice(0, 10).map(function (item) {
+    return item && { criterion: clean(item.criterion, 1000), met: item.met === true, evidence: clean(item.evidence, 2000) };
+  }).filter(function (item) { return item && item.criterion && item.evidence; }) : [];
+  var snapshot = value.permissionSnapshot && typeof value.permissionSnapshot === "object" ? value.permissionSnapshot : {};
+  var run = { version: 1, id: clean(value.id, 200) || crypto.randomUUID(), state: value.state, objective: clean(value.objective, 20000), successCriteria: criteria(value.successCriteria),
+    continuationCount: Math.max(0, Math.min(100, Math.floor(Number(value.continuationCount) || 0))), maxContinuations: integer(value.maxContinuations, 10, 100), maxMinutes: integer(value.maxMinutes, 60, 1440),
+    createdAt: Number.isFinite(value.createdAt) ? value.createdAt : Date.now(), startedAt: Number.isFinite(value.startedAt) ? value.startedAt : null, deadlineAt: Number.isFinite(value.deadlineAt) ? value.deadlineAt : null,
+    finishedAt: Number.isFinite(value.finishedAt) ? value.finishedAt : null, waitingReason: clean(value.waitingReason, 2000), terminalReason: clean(value.terminalReason, 2000), pausedAfterRestart: !!value.pausedAfterRestart,
+    cancellationEpoch: Math.max(0, Math.floor(Number(value.cancellationEpoch) || 0)), rateLimitUntil: Number.isFinite(value.rateLimitUntil) ? value.rateLimitUntil : null, continuationPending: false,
+    wakeSequence: Math.max(0, Math.floor(Number(value.wakeSequence) || 0)), completionRequested: !!value.completionRequested,
+    permissionSnapshot: { permissionMode: clean(snapshot.permissionMode, 100) || null, permissionModeBeforeFullAccess: clean(snapshot.permissionModeBeforeFullAccess, 100) || null, enabled: snapshot.enabled === true } };
+  if (value.state === "armed") run.armToken = clean(value.armToken, 200) || crypto.randomUUID();
+  if (value.outcome && typeof value.outcome === "object") run.outcome = { assessment: clean(value.outcome.assessment, 40), summary: clean(value.outcome.summary, 4000), evidence: evidence, criteria: assessments, reportedAt: Number.isFinite(value.outcome.reportedAt) ? value.outcome.reportedAt : null };
+  return run;
+}
+module.exports = { project: project, restore: restore };

package/lib/autonomous-run-scheduler.js

@@ -0,0 +1,92 @@
+var sessionProvenance = require("./session-provenance");
+
+function attachAutonomousRunScheduler(ctx) {
+  var scheduler = ctx.scheduler;
+  var type = "autonomous-wake:" + ctx.projectId;
+  var unregister = null;
+  function isMultiUser() { return typeof ctx.isMultiUser === "function" ? ctx.isMultiUser() : !!ctx.isMultiUser; }
+
+  function origin(session) {
+    var existing = session.sessionOriginId;
+    var value = sessionProvenance.ensureOrigin(session);
+    if (!existing) ctx.sm.saveSessionFile(session);
+    return value;
+  }
+  function owner(session) {
+    if (isMultiUser()) {
+      if (!session.ownerId) throw new Error("Until complete requires an explicit session owner.");
+      return session.ownerId;
+    }
+    return "local-user";
+  }
+  function matching(job, session, run, kind) {
+    return job.type === type && job.projectId === ctx.projectId && job.target.id === origin(session) &&
+      job.payload.runId === run.id && (!kind || job.payload.kind === kind);
+  }
+  function queued(session, run, kind) {
+    var jobs = scheduler.listJobs();
+    for (var i = jobs.length - 1; i >= 0; i--) if (jobs[i].state === "queued" && matching(jobs[i], session, run, kind)) return jobs[i];
+    return null;
+  }
+  function schedule(session, run, kind, runAt) {
+    var sessionOrigin = origin(session);
+    run.wakeSequence = Math.max(0, Math.floor(Number(run.wakeSequence) || 0)) + 1;
+    if (ctx.sm && typeof ctx.sm.saveSessionFile === "function") ctx.sm.saveSessionFile(session);
+    var spec = {
+      type: type,
+      idempotencyKey: "autonomous:" + sessionOrigin + ":" + run.id + ":" + kind + ":" + run.cancellationEpoch + ":" + run.wakeSequence,
+      ownerId: owner(session),
+      projectId: ctx.projectId,
+      target: { kind: "project-session-origin", id: sessionOrigin },
+      payload: { kind: kind, runId: run.id, epoch: run.cancellationEpoch, wakeSequence: run.wakeSequence, sessionOrigin: sessionOrigin, cliSessionId: session.cliSessionId || null },
+      runAt: Number(runAt),
+    };
+    var current = queued(session, run, kind);
+    return current ? scheduler.replaceQueued(current.id, spec) : scheduler.enqueue(spec);
+  }
+  function cancel(session, run, kinds) {
+    if (!run) return;
+    var jobs = scheduler.listJobs();
+    for (var i = 0; i < jobs.length; i++) {
+      if (jobs[i].state !== "queued" || !matching(jobs[i], session, run)) continue;
+      if (kinds && kinds.indexOf(jobs[i].payload.kind) === -1) continue;
+      scheduler.cancel(jobs[i].id, "autonomous_run_cancelled_or_replaced");
+    }
+  }
+  function findSession(job) {
+    var found = null;
+    ctx.sm.sessions.forEach(function (session) {
+      if (!found && session.sessionOriginId === job.target.id) found = session;
+    });
+    return found;
+  }
+  function exact(job) {
+    var session = findSession(job);
+    var run = session && session.autonomousRun;
+    if (!session || !run || run.id !== job.payload.runId) return null;
+    if (job.payload.kind !== "deadline" && owner(session) !== job.ownerId) return null;
+    if (Number(run.cancellationEpoch || 0) !== Number(job.payload.epoch)) return null;
+    if (run.state === "armed" || run.state === "paused" || ["completed", "stopped", "limit", "error"].indexOf(run.state) !== -1) return null;
+    if (job.payload.kind !== "deadline" && ctx.authorize && !ctx.authorize(session)) return null;
+    return { session: session, run: run };
+  }
+  function canRun(job) {
+    var current;
+    try { current = exact(job); } catch (error) { return true; }
+    if (!current) return true;
+    return job.payload.kind !== "continuation" || (!current.session.isProcessing && !current.session._queryStarting);
+  }
+  function dispatch(job, execution) {
+    var current = exact(job);
+    if (!current) throw new Error("The Until complete wake no longer belongs to an authorized active run.");
+    execution.recordMetadata({ projectId: ctx.projectId, runId: current.run.id, kind: job.payload.kind, sessionOrigin: job.target.id, epoch: job.payload.epoch });
+    execution.recordReceipt({ state: "dispatching", runId: current.run.id, kind: job.payload.kind, sessionOrigin: job.target.id, recordedAt: Date.now() });
+    return ctx.onWake(job.payload.kind, current.session, current.run);
+  }
+  function start() {
+    if (!unregister) unregister = scheduler.registerHandler(type, dispatch, { canRun: canRun });
+  }
+  return { schedule: schedule, cancel: cancel, start: start, shutdown: function () { if (unregister) { unregister(); unregister = null; } } };
+}
+
+module.exports = { attachAutonomousRunScheduler: attachAutonomousRunScheduler };

package/lib/durable-scheduler-record.js

@@ -0,0 +1,61 @@
+var STATES = ["queued", "claimed", "running", "completed", "failed", "cancelled", "interrupted"];
+
+function boundedString(value, name) {
+  if (typeof value !== "string" || !value.trim() || value.length > 256) throw new Error("invalid " + name);
+}
+
+function timestamp(value, name) {
+  if (typeof value !== "number" || !isFinite(value) || value < 0) throw new Error("invalid " + name);
+}
+
+function jsonSize(value, name, maximum) {
+  var serialized;
+  try { serialized = JSON.stringify(value); } catch (error) { throw new Error("invalid " + name); }
+  if (serialized === undefined || Buffer.byteLength(serialized, "utf8") > maximum) throw new Error("invalid " + name);
+}
+
+function validateExecution(job) {
+  if (job.state === "queued" || job.state === "cancelled") {
+    if (job.execution !== null) throw new Error("invalid execution for " + job.state + " job");
+    return;
+  }
+  if (!job.execution || typeof job.execution !== "object" || Array.isArray(job.execution)) {
+    throw new Error("missing saved execution");
+  }
+  boundedString(job.execution.claimId, "saved claim id");
+  timestamp(job.execution.claimedAt, "saved claimedAt");
+  if (job.execution.startedAt !== undefined) timestamp(job.execution.startedAt, "saved startedAt");
+  if (job.execution.completedAt !== undefined) timestamp(job.execution.completedAt, "saved completedAt");
+  if (job.execution.failedAt !== undefined) timestamp(job.execution.failedAt, "saved failedAt");
+  if (job.execution.interruptedAt !== undefined) timestamp(job.execution.interruptedAt, "saved interruptedAt");
+  jsonSize(job.execution, "saved execution", 256 * 1024);
+}
+
+function validateSavedJobs(jobs) {
+  var ids = Object.create(null);
+  var keys = Object.create(null);
+  for (var i = 0; i < jobs.length; i++) {
+    var job = jobs[i];
+    if (!job || typeof job !== "object" || Array.isArray(job)) throw new Error("invalid saved job");
+    boundedString(job.id, "saved job id");
+    boundedString(job.idempotencyKey, "saved idempotencyKey");
+    boundedString(job.type, "saved job type");
+    boundedString(job.ownerId, "saved ownerId");
+    boundedString(job.projectId, "saved projectId");
+    if (ids[job.id] || keys[job.idempotencyKey]) throw new Error("duplicate saved job identity");
+    if (STATES.indexOf(job.state) === -1) throw new Error("invalid saved state");
+    timestamp(job.runAt, "saved runAt");
+    timestamp(job.createdAt, "saved createdAt");
+    timestamp(job.updatedAt, "saved updatedAt");
+    if (!job.target || typeof job.target !== "object" || Array.isArray(job.target)) throw new Error("invalid saved target");
+    boundedString(job.target.kind, "saved target kind");
+    boundedString(job.target.id, "saved target id");
+    jsonSize(job.target, "saved target", 4096);
+    jsonSize(job.payload, "saved payload", 256 * 1024);
+    validateExecution(job);
+    ids[job.id] = true;
+    keys[job.idempotencyKey] = true;
+  }
+}
+
+module.exports = { validateSavedJobs: validateSavedJobs };

package/lib/durable-scheduler-store.js

@@ -0,0 +1,185 @@
+var fs = require("fs");
+var path = require("path");
+var crypto = require("crypto");
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function makeError(message, code, cause) {
+  var error = new Error(message);
+  error.code = code;
+  if (cause) error.cause = cause;
+  return error;
+}
+
+function pidIsAlive(pid) {
+  if (typeof pid !== "number" || !isFinite(pid) || Math.floor(pid) !== pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !!(error && error.code !== "ESRCH");
+  }
+}
+
+function attachDurableSchedulerStore(ctx) {
+  var filePath = ctx.filePath;
+  var namespace = ctx.namespace;
+  var fsImpl = ctx.fs || fs;
+  var lockPath = filePath + ".lock";
+  var guardPath = lockPath + ".acquire";
+  var lockToken = crypto.randomBytes(16).toString("hex");
+  var lockFd = null;
+  var closed = false;
+
+  if (!filePath || !namespace) throw new Error("Scheduler store requires filePath and namespace");
+
+  function acquireLockUnderGuard() {
+    try {
+      lockFd = fsImpl.openSync(lockPath, "wx", 0o600);
+      fsImpl.writeFileSync(lockFd, JSON.stringify({ pid: process.pid, namespace: namespace, token: lockToken }) + "\n");
+      return;
+    } catch (error) {
+      if (!error || error.code !== "EEXIST") {
+        if (lockFd !== null) {
+          try { fsImpl.closeSync(lockFd); } catch (closeError) {}
+          lockFd = null;
+          try { fsImpl.unlinkSync(lockPath); } catch (unlinkError) {}
+        }
+        throw makeError("Unable to lock scheduler store: " + error.message, "SCHEDULER_STORE_LOCK", error);
+      }
+    }
+
+    var lock;
+    try {
+      lock = JSON.parse(fsImpl.readFileSync(lockPath, "utf8"));
+    } catch (error) {
+      throw makeError("Scheduler store lock is unreadable", "SCHEDULER_STORE_LOCK", error);
+    }
+    if (pidIsAlive(lock.pid)) {
+      throw makeError("Scheduler store is already owned by process " + lock.pid, "SCHEDULER_STORE_LOCKED");
+    }
+    var stalePath = lockPath + ".stale-" + process.pid + "-" + lockToken;
+    try {
+      fsImpl.renameSync(lockPath, stalePath);
+      lockFd = fsImpl.openSync(lockPath, "wx", 0o600);
+      fsImpl.writeFileSync(lockFd, JSON.stringify({ pid: process.pid, namespace: namespace, token: lockToken }) + "\n");
+      try { fsImpl.unlinkSync(stalePath); } catch (cleanupError) {}
+    } catch (error) {
+      if (lockFd !== null) {
+        try { fsImpl.closeSync(lockFd); } catch (closeError) {}
+        lockFd = null;
+        try { fsImpl.unlinkSync(lockPath); } catch (unlinkError) {}
+      }
+      try { fsImpl.unlinkSync(stalePath); } catch (cleanupError) {}
+      throw makeError("Unable to recover stale scheduler store lock", "SCHEDULER_STORE_LOCK", error);
+    }
+  }
+
+  function acquireLock() {
+    fsImpl.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    try {
+      fsImpl.mkdirSync(guardPath, { mode: 0o700 });
+    } catch (error) {
+      if (error && error.code === "EEXIST") {
+        throw makeError("Scheduler store acquisition is already in progress or requires manual stale-guard recovery", "SCHEDULER_STORE_LOCKED", error);
+      }
+      throw makeError("Unable to guard scheduler store acquisition", "SCHEDULER_STORE_LOCK", error);
+    }
+
+    var acquisitionError = null;
+    try {
+      acquireLockUnderGuard();
+    } catch (error) {
+      acquisitionError = error;
+    }
+    try {
+      fsImpl.rmdirSync(guardPath);
+    } catch (error) {
+      if (lockFd !== null) {
+        try { fsImpl.closeSync(lockFd); } catch (closeError) {}
+        lockFd = null;
+        try { fsImpl.unlinkSync(lockPath); } catch (unlinkError) {}
+      }
+      throw makeError("Unable to release scheduler store acquisition guard", "SCHEDULER_STORE_LOCK", error);
+    }
+    if (acquisitionError) throw acquisitionError;
+  }
+
+  function emptyData() {
+    return { version: 1, namespace: namespace, jobs: [] };
+  }
+
+  function load() {
+    if (closed) throw makeError("Scheduler store is closed", "SCHEDULER_STORE_CLOSED");
+    if (!fsImpl.existsSync(filePath)) return emptyData();
+    var parsed;
+    try {
+      parsed = JSON.parse(fsImpl.readFileSync(filePath, "utf8"));
+    } catch (error) {
+      throw makeError("Scheduler store is corrupt or unreadable", "SCHEDULER_STORE_CORRUPT", error);
+    }
+    if (!parsed || parsed.version !== 1 || parsed.namespace !== namespace || !Array.isArray(parsed.jobs)) {
+      throw makeError("Scheduler store has an invalid schema or namespace", "SCHEDULER_STORE_CORRUPT");
+    }
+    return clone(parsed);
+  }
+
+  function save(data) {
+    if (closed) throw makeError("Scheduler store is closed", "SCHEDULER_STORE_CLOSED");
+    var serialized;
+    try {
+      serialized = JSON.stringify(data, null, 2) + "\n";
+    } catch (error) {
+      throw makeError("Scheduler store data is not serializable", "SCHEDULER_STORE_WRITE", error);
+    }
+    var temporary = filePath + ".tmp-" + process.pid;
+    var temporaryFd = null;
+    try {
+      temporaryFd = fsImpl.openSync(temporary, "w", 0o600);
+      fsImpl.writeFileSync(temporaryFd, serialized, "utf8");
+      if (typeof fsImpl.fsyncSync === "function") fsImpl.fsyncSync(temporaryFd);
+      fsImpl.closeSync(temporaryFd);
+      temporaryFd = null;
+      fsImpl.renameSync(temporary, filePath);
+      try { fsImpl.chmodSync(filePath, 0o600); } catch (error) {}
+      var directoryFd = null;
+      try {
+        directoryFd = fsImpl.openSync(path.dirname(filePath), "r");
+        if (typeof fsImpl.fsyncSync === "function") fsImpl.fsyncSync(directoryFd);
+      } catch (error) {
+        var unsupported = error && (error.code === "EINVAL" || error.code === "ENOTSUP" || error.code === "EISDIR" || error.code === "EBADF" || error.code === "EPERM" || error.code === "EACCES");
+        if (!unsupported) throw error;
+      } finally {
+        if (directoryFd !== null) {
+          try { fsImpl.closeSync(directoryFd); } catch (closeError) {}
+        }
+      }
+    } catch (error) {
+      if (temporaryFd !== null) {
+        try { fsImpl.closeSync(temporaryFd); } catch (closeError) {}
+      }
+      try { fsImpl.unlinkSync(temporary); } catch (cleanupError) {}
+      throw makeError("Scheduler store write failed", "SCHEDULER_STORE_WRITE", error);
+    }
+  }
+
+  function close() {
+    if (closed) return;
+    closed = true;
+    if (lockFd !== null) {
+      try { fsImpl.closeSync(lockFd); } catch (error) {}
+      lockFd = null;
+    }
+    try {
+      var lock = JSON.parse(fsImpl.readFileSync(lockPath, "utf8"));
+      if (lock.pid === process.pid && lock.namespace === namespace && lock.token === lockToken) fsImpl.unlinkSync(lockPath);
+    } catch (error) {}
+  }
+
+  acquireLock();
+  return { load: load, save: save, close: close, filePath: filePath, namespace: namespace };
+}
+
+module.exports = { attachDurableSchedulerStore: attachDurableSchedulerStore };