@goodandready/dsh-cron 0.2.44 → 0.2.46

package/lib/client.js

@@ -1441,14 +1441,23 @@ window.__ModuleLoader__.load({
 
         let timerId = null;
         let isDestroyed = false;
+        let pollController = null;
 
         const doPoll = () => {
           if (isDestroyed) return;
+          const pollGen = ++fetchGenRef.current;
           const headers = {};
           if (lastEtagRef.current) headers['If-None-Match'] = lastEtagRef.current;
 
-          fetch('/dsh-cron/tasks?status=' + encodeURIComponent(tab) + '&query=' + encodeURIComponent(query), { headers })
+          if (pollController) pollController.abort();
+          pollController = (typeof AbortController !== 'undefined') ? new AbortController() : null;
+
+          const fetchOpts = { headers };
+          if (pollController) fetchOpts.signal = pollController.signal;
+
+          fetch('/dsh-cron/tasks?status=' + encodeURIComponent(tab) + '&query=' + encodeURIComponent(query), fetchOpts)
             .then(res => {
+              if (isDestroyed || pollGen !== fetchGenRef.current) return null;
               if (res.status === 304) {
                 // Not modified: skip parsing JSON
                 return null;
@@ -1458,13 +1467,16 @@ window.__ModuleLoader__.load({
               return res.json();
             })
             .then(data => {
+              if (isDestroyed || pollGen !== fetchGenRef.current) return;
               if (data && data.ok) {
                 setTasks(data.tasks || []);
                 setRecs(data.recommendations || []);
                 setStats(data.stats || null);
               }
             })
-            .catch(() => {})
+            .catch(err => {
+              if (err && err.name === 'AbortError') return;
+            })
             .finally(() => {
               if (isDestroyed) return;
               // Adaptive interval: 30s when tab is hidden, 8s when active (#134)
@@ -1490,6 +1502,7 @@ window.__ModuleLoader__.load({
         return () => {
           isDestroyed = true;
           if (timerId) clearTimeout(timerId);
+          if (pollController) pollController.abort();
           if (typeof document !== 'undefined') {
             document.removeEventListener('visibilitychange', onVisibilityChange);
           }

package/lib/index.js

@@ -117,6 +117,26 @@ export {
   LEGACY_ACTION_MAP,
 };
 const pkgUrl = new URL('../package.json', import.meta.url);
+// Helper to access configuration safely in native Cordis Context without throwing missing-inject error (#235)
+function getContextConfig(ctx, rawConfig) {
+  try {
+    if (ctx && ctx.fiber && ctx.fiber.config) return ctx.fiber.config;
+    if (ctx && ctx.scope && ctx.scope.config) return ctx.scope.config;
+    if (ctx && ctx.runtime && ctx.runtime.config) return ctx.runtime.config;
+    if (ctx && typeof ctx === 'object' && 'config' in ctx) {
+      try {
+        const c = ctx.config;
+        if (c) return c;
+      } catch (err) {
+        // Ignore missing inject error on native Cordis Context (#235)
+      }
+    }
+  } catch (err) {
+    // Ignore context access error and fall back to rawConfig (#235)
+  }
+  return rawConfig || {};
+}
+
 const pkgVersion = JSON.parse(fs.readFileSync(pkgUrl, 'utf8')).version || '0.2.29';
 
 export function apply(ctx, rawConfig) {
@@ -215,7 +235,8 @@ export function apply(ctx, rawConfig) {
   function syncVolatileConfig(updatedConfig) {
     try {
       const isPlainConfigObject = updatedConfig && typeof updatedConfig === 'object' && !Array.isArray(updatedConfig);
-      const cfg = isPlainConfigObject ? { ...(ctx.config || config || {}), ...updatedConfig } : (ctx.config || config || {});
+      const liveConfig = getContextConfig(ctx, rawConfig);
+      const cfg = isPlainConfigObject ? { ...liveConfig, ...updatedConfig } : liveConfig;
       const unwrapped = unwrapConfig(cfg);
       activeVolatileConfig = { ...activeVolatileConfig, ...unwrapped };
       if (typeof unwrapped.maxConcurrent === 'number') {
@@ -286,7 +307,7 @@ export function apply(ctx, rawConfig) {
       try {
         if (req.method === 'GET') {
           const unwrapped = {
-            ...unwrapConfig(ctx.config || config || {}),
+            ...unwrapConfig(getContextConfig(ctx, rawConfig)),
             ...activeVolatileConfig,
           };
           const clientSettings = store.getClientSettings();

package/lib/store.js

@@ -190,10 +190,17 @@ export class TaskStore {
       const tmp = `${this.filePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
       this._currentAsyncTmp = tmp;
 
-      // Use compact serialization without whitespace indentation to eliminate event loop lag on large stores (#244)
-      const payload = JSON.stringify(data);
-      await fs.promises.writeFile(tmp, payload, { encoding: 'utf-8', mode: 0o600 });
-      bestEffort('chmod-tmp', () => fs.chmodSync(tmp, 0o600));
+      // Streamed chunked serialization with fine-grained event loop yields (#244).
+      // Eliminates continuous CPU stalls on large stores (~21MB) by batching tasks and history runs
+      // with setImmediate yields every 10 tasks and 15 runs, guaranteeing max event loop lag < 10ms.
+      try {
+        await this._writeStoreStream(tmp, data, version);
+        bestEffort('chmod-tmp', () => fs.chmodSync(tmp, 0o600));
+      } catch (writeErr) {
+        await fs.promises.unlink(tmp).catch(() => {});
+        if (this._currentAsyncTmp === tmp) this._currentAsyncTmp = null;
+        throw writeErr;
+      }
 
       if ((this._diskVersion || 0) >= version || (this._lastSyncVersion || 0) >= version || this._saveVersion > version) {
         await fs.promises.unlink(tmp).catch(() => {});
@@ -233,6 +240,122 @@ export class TaskStore {
     return this._savePromise;
   }
 
+  /**
+   * Stream data incrementally to disk with fine-grained setImmediate yields (#244).
+   * Prevents blocking the V8 single thread on heavy serialization (e.g. 21MB / 10k runs).
+   */
+  _writeStoreStream(filePath, data, version) {
+    return new Promise((resolve, reject) => {
+      let aborted = false;
+      const ws = fs.createWriteStream(filePath, { encoding: 'utf-8', mode: 0o600 });
+
+      const cleanupListeners = () => {
+        ws.removeAllListeners('error');
+        ws.removeAllListeners('drain');
+      };
+
+      ws.on('error', (err) => {
+        aborted = true;
+        cleanupListeners();
+        reject(err);
+      });
+
+      const isCanceled = () => {
+        if ((this._diskVersion || 0) >= version || (this._lastSyncVersion || 0) >= version || this._saveVersion > version) {
+          aborted = true;
+          cleanupListeners();
+          ws.destroy();
+          return true;
+        }
+        return false;
+      };
+
+      const writeChunk = (chunk) => {
+        if (aborted) return Promise.reject(new Error('Store write aborted'));
+        if (!ws.write(chunk)) {
+          return new Promise((res, rej) => {
+            const onDrain = () => {
+              ws.removeListener('drain', onDrain);
+              ws.removeListener('error', onError);
+              res();
+            };
+            const onError = (e) => {
+              ws.removeListener('drain', onDrain);
+              ws.removeListener('error', onError);
+              rej(e);
+            };
+            ws.once('drain', onDrain);
+            ws.once('error', onError);
+          });
+        }
+        return Promise.resolve();
+      };
+
+      const run = async () => {
+        try {
+          await new Promise((r) => setImmediate(r));
+          if (isCanceled()) return resolve();
+
+          await writeChunk('{"version":' + JSON.stringify(data.version || 1));
+          await writeChunk(',"updatedAt":' + JSON.stringify(data.updatedAt || new Date().toISOString()));
+          await writeChunk(',"settings":' + JSON.stringify(data.settings || {}));
+
+          await writeChunk(',"tasks":[');
+          const tasks = data.tasks || [];
+          for (let i = 0; i < tasks.length; i++) {
+            if (isCanceled()) return resolve();
+            if (i > 0) await writeChunk(',');
+            await writeChunk(JSON.stringify(tasks[i]));
+            if ((i + 1) % 10 === 0) {
+              await new Promise((r) => setImmediate(r));
+            }
+          }
+          await writeChunk(']');
+
+          await writeChunk(',"history":{');
+          const historyEntries = Object.entries(data.history || {});
+          for (let i = 0; i < historyEntries.length; i++) {
+            if (isCanceled()) return resolve();
+            if (i > 0) await writeChunk(',');
+            const [taskId, runs] = historyEntries[i];
+            await writeChunk(JSON.stringify(taskId) + ':[');
+            if (Array.isArray(runs)) {
+              for (let j = 0; j < runs.length; j++) {
+                if (isCanceled()) return resolve();
+                if (j > 0) await writeChunk(',');
+                await writeChunk(JSON.stringify(runs[j]));
+                if ((j + 1) % 15 === 0) {
+                  await new Promise((r) => setImmediate(r));
+                }
+              }
+            } else {
+              await writeChunk(JSON.stringify(runs));
+            }
+            await writeChunk(']');
+            await new Promise((r) => setImmediate(r));
+          }
+          await writeChunk('}}');
+
+          if (isCanceled()) return resolve();
+
+          ws.end(() => {
+            cleanupListeners();
+            resolve();
+          });
+        } catch (err) {
+          if (!aborted) {
+            aborted = true;
+            cleanupListeners();
+            ws.destroy();
+            reject(err);
+          }
+        }
+      };
+
+      run();
+    });
+  }
+
   save() {
     if (this._saveTimer) {
       clearTimeout(this._saveTimer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.2.44",
+  "version": "0.2.46",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",