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

package/LICENSES/MIT-legacy.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSES/README.md

@@ -0,0 +1,7 @@
+# Licensing scope
+
+Clay Studio as a whole is licensed under the GNU Affero General Public License, version 3 only (AGPL-3.0-only), under the terms in the root [LICENSE](../LICENSE). This project-wide license does not narrow the grants that apply to preexisting portions previously covered by the project’s MIT license.
+
+Preexisting MIT-covered portions retain the grants and applicable copyright and permission notices from the MIT license. The byte-for-byte prior license text is preserved in [MIT-legacy.txt](MIT-legacy.txt), and this notice does not revoke or alter those earlier grants or notices.
+
+Third-party components and assets retain their own licenses and notices. In particular, the bundled Source Serif 4 font remains under the [SIL Open Font License 1.1](../lib/public/fonts/source-serif-4/LICENSE.md).

package/README.md

@@ -14,7 +14,7 @@
   <a href="https://www.npmjs.com/package/clay-server"><img src="https://img.shields.io/npm/v/clay-server" alt="npm version" /></a>
   <a href="https://www.npmjs.com/package/clay-server"><img src="https://img.shields.io/npm/dw/clay-server" alt="npm downloads" /></a>
   <a href="https://github.com/chadbyte/clay"><img src="https://img.shields.io/github/stars/chadbyte/clay" alt="GitHub stars" /></a>
-  <a href="https://github.com/chadbyte/clay/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT" /></a>
+  <a href="https://github.com/chadbyte/clay/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-AGPL--3.0--only-blue.svg" alt="License: AGPL-3.0-only" /></a>
 </p>
 
 Clay Studio turns local coding agents into a shared, persistent team. Run different agents from one browser workspace, join a teammate's live session, keep project knowledge between conversations, and automate work without handing your workspace to another cloud.
@@ -105,4 +105,4 @@ Clay Studio is not affiliated with the providers of the coding agents it support
 
 ## License
 
-[MIT](LICENSE)
+Clay Studio as a whole is licensed under the [GNU Affero General Public License, version 3 only](LICENSE) (AGPL-3.0-only). Preexisting portions previously covered by the project’s MIT license retain the grants and applicable notices from that license; see [LICENSES/MIT-legacy.txt](LICENSES/MIT-legacy.txt) and the [licensing scope notice](LICENSES/README.md). Third-party components remain under their respective licenses.

package/bin/cli.js

@@ -6,10 +6,8 @@ if (_nodeMajor < 20) {
   console.error("");
   console.error("\x1b[31m[clay] Node.js 20+ is required (current: " + process.version + ")\x1b[0m");
   console.error("[clay] The Claude Agent SDK 0.2.40+ requires Node 20 for Symbol.dispose support.");
-  console.error("[clay] If you cannot upgrade Node, use claude-relay@2.4.3 which supports Node 18.");
   console.error("");
   console.error("  Upgrade Node:  nvm install 22 && nvm use 22");
-  console.error("  Or use older:  npx claude-relay@2.4.3");
   console.error("");
   process.exit(78);
 }

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/daemon.js

@@ -5,10 +5,8 @@ var nodeMajor = parseInt(process.versions.node.split(".")[0], 10);
 if (nodeMajor < 20) {
   console.error("\x1b[31m[clay] Node.js 20+ is required (current: " + process.version + ")\x1b[0m");
   console.error("[clay] The Claude Agent SDK 0.2.40+ requires Node 20 for Symbol.dispose support.");
-  console.error("[clay] If you cannot upgrade Node, use claude-relay@2.4.3 which supports Node 18.");
   console.error("");
   console.error("  Upgrade Node:  nvm install 22 && nvm use 22");
-  console.error("  Or use older:  npx claude-relay@2.4.3");
   process.exit(78); // EX_CONFIG — fatal config error, don't auto-restart
 }
 

package/lib/default-ai-runtime.js

@@ -0,0 +1,117 @@
+// Pure and injected resolution for a Clay-owned Default AI runtime.
+
+var modelEntryMatches = require("./model-entry").modelEntryMatches;
+var modelEntryValue = require("./model-entry").modelEntryValue;
+
+var KNOWN_VENDORS = ["claude", "codex", "grok", "kimi", "copilot", "qwen", "junie", "antigravity", "opencode", "kiro"];
+var VENDOR_FAMILY_ORDER = {
+  claude: ["opus", "sonnet", "haiku"],
+  codex: ["astra", "sol", "gpt", "o"],
+};
+
+function text(entry) {
+  if (typeof entry === "string") return entry;
+  return entry && [entry.value, entry.id, entry.resolvedModel, entry.displayName, entry.name].filter(Boolean).join(" ") || "";
+}
+
+function selectTopModel(vendor, catalog) {
+  var models = catalog && Array.isArray(catalog.models) ? catalog.models : [];
+  if (!models.length) return "";
+  var defaultModel = catalog.defaultModel;
+  if (KNOWN_VENDORS.indexOf(vendor) === -1 && defaultModel) {
+    for (var di = 0; di < models.length; di++) if (modelEntryMatches(models[di], defaultModel)) return modelEntryValue(models[di]);
+  }
+  var familyOrder = VENDOR_FAMILY_ORDER[vendor] || [];
+  if (familyOrder.length) {
+    for (var fi = 0; fi < familyOrder.length; fi++) {
+      for (var mi = 0; mi < models.length; mi++) if (new RegExp("(^|[^a-z])" + familyOrder[fi] + "([^a-z]|$)", "i").test(text(models[mi]))) return modelEntryValue(models[mi]);
+    }
+  }
+  if (defaultModel) for (var ci = 0; ci < models.length; ci++) if (modelEntryMatches(models[ci], defaultModel)) return modelEntryValue(models[ci]);
+  return modelEntryValue(models[0]);
+}
+
+function modelEntry(models, value) {
+  for (var i = 0; i < models.length; i++) if (modelEntryMatches(models[i], value)) return models[i];
+  return null;
+}
+
+function effortValue(entry) {
+  if (typeof entry === "string") return entry;
+  return entry && (entry.value || entry.id || entry.name || "");
+}
+
+function supportedEfforts(model, catalog) {
+  if (model && Array.isArray(model.supportedEffortLevels)) return { levels: model.supportedEffortLevels.map(effortValue).filter(Boolean), specified: true };
+  if (catalog && Array.isArray(catalog.effortLevels)) return { levels: catalog.effortLevels.map(effortValue).filter(Boolean), specified: true };
+  return { levels: [], specified: false };
+}
+
+function resolveEffort(preference, selectedModel, catalog) {
+  var support = supportedEfforts(selectedModel, catalog);
+  var supported = support.levels;
+  var explicit = preference && preference.effort || "";
+  if (explicit && support.specified && supported.indexOf(explicit) === -1) return { ok: false, error: "The saved Default AI effort is unavailable for the selected model." };
+  if (explicit) return { ok: true, effort: explicit };
+  if (preference && Object.prototype.hasOwnProperty.call(preference, "effort")) return { ok: true, effort: "" };
+  var modelDefault = selectedModel && (selectedModel.defaultReasoningEffort || selectedModel.defaultEffort) || "";
+  if (modelDefault && (!support.specified || supported.indexOf(modelDefault) !== -1)) return { ok: true, effort: modelDefault };
+  var providerDefault = catalog && catalog.defaultEffort || "";
+  if (providerDefault && (!support.specified || supported.indexOf(providerDefault) !== -1)) return { ok: true, effort: providerDefault };
+  return { ok: true, effort: "" };
+}
+
+function exactModel(models, requested) {
+  if (!requested) return "";
+  for (var i = 0; i < models.length; i++) if (modelEntryMatches(models[i], requested)) return modelEntryValue(models[i]);
+  return "";
+}
+
+function identityError(options) {
+  if (options.multiUser === true && !(typeof options.userId === "string" && options.userId)) return "Authenticated user identity is required.";
+  return "";
+}
+
+async function resolveDefaultAiRuntime(options) {
+  options = options || {};
+  if (options.identity && typeof options.identity === "object") {
+    options = Object.assign({}, options.identity, options);
+  }
+  var identityProblem = identityError(options);
+  if (identityProblem) return { ready: false, error: identityProblem };
+  if (typeof options.getPreference !== "function") return { ready: false, error: "Default AI preference reader is unavailable." };
+  var stored = await options.getPreference(options.userId);
+  if (!stored || stored.error) return { ready: false, error: stored && stored.error || "Default AI preference could not be read." };
+  var preference = stored.preference || null;
+  var getAvailability = options.getInstalledVendors || options.getAvailability;
+  var installed = typeof getAvailability === "function" ? await getAvailability(options.userId) : options.installedVendors || [];
+  installed = Array.isArray(installed) ? installed : [];
+  var vendor = preference && preference.vendor || options.preferredVendor || installed[0] || "";
+  if (!vendor || installed.indexOf(vendor) === -1) return { ready: false, error: "Default AI vendor is unavailable.", preference: preference, vendor: vendor };
+  if (typeof options.getCatalog !== "function") return { ready: false, error: "Default AI model catalog is unavailable.", preference: preference, vendor: vendor };
+  var catalog = await options.getCatalog(vendor, options.userId);
+  var models = catalog && Array.isArray(catalog.models) ? catalog.models : [];
+  if (!catalog || catalog.status !== "ready" || !models.length) return { ready: false, error: catalog && catalog.error || "Default AI models are unavailable.", preference: preference, vendor: vendor, catalog: catalog || null };
+  var model = preference && preference.model ? exactModel(models, preference.model) : "";
+  if (preference && preference.model && !model) return { ready: false, error: "The saved Default AI model is unavailable.", preference: preference, vendor: vendor, catalog: catalog };
+  if (!model) model = selectTopModel(vendor, catalog);
+  if (!model) return { ready: false, error: "No usable Default AI model is available.", preference: preference, vendor: vendor, catalog: catalog };
+  var selectedModel = modelEntry(models, model);
+  var effort = resolveEffort(preference, selectedModel, catalog);
+  if (!effort.ok) return { ready: false, error: effort.error, preference: preference, vendor: vendor, model: model, catalog: catalog };
+  return { ready: true, vendor: vendor, model: model, effort: effort.effort, preference: preference, source: stored.source || (preference ? "explicit" : "default"), catalog: catalog };
+}
+
+function createDefaultAiRuntimeResolver(deps) {
+  deps = deps || {};
+  return {
+    resolve: function (options) { return resolveDefaultAiRuntime(Object.assign({}, deps, options || {})); },
+    save: function (userId, preference) {
+      if (deps.multiUser === true && !(typeof userId === "string" && userId)) return Promise.resolve({ ok: false, error: "Authenticated user identity is required." });
+      if (typeof deps.savePreference !== "function") return Promise.resolve({ ok: false, error: "Default AI preference writer is unavailable." });
+      return Promise.resolve(deps.savePreference(userId, preference));
+    },
+  };
+}
+
+module.exports = { resolveDefaultAiRuntime: resolveDefaultAiRuntime, createDefaultAiRuntimeResolver: createDefaultAiRuntimeResolver, selectTopModel: selectTopModel, exactModel: exactModel, resolveEffort: resolveEffort, KNOWN_VENDORS: KNOWN_VENDORS, VENDOR_FAMILY_ORDER: VENDOR_FAMILY_ORDER };

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 };