@shardworks/spider-apparatus 0.1.153 → 0.1.154

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shardworks/spider-apparatus",
-  "version": "0.1.153",
+  "version": "0.1.154",
   "license": "ISC",
   "repository": {
     "type": "git",
@@ -19,13 +19,13 @@
     "hono": "^4.7.11",
     "yaml": "^2.0.0",
     "zod": "4.3.6",
-    "@shardworks/nexus-core": "0.1.153",
-    "@shardworks/fabricator-apparatus": "0.1.153",
-    "@shardworks/clerk-apparatus": "0.1.153",
-    "@shardworks/stacks-apparatus": "0.1.153",
-    "@shardworks/tools-apparatus": "0.1.153",
-    "@shardworks/codexes-apparatus": "0.1.153",
-    "@shardworks/animator-apparatus": "0.1.153"
+    "@shardworks/nexus-core": "0.1.154",
+    "@shardworks/stacks-apparatus": "0.1.154",
+    "@shardworks/clerk-apparatus": "0.1.154",
+    "@shardworks/fabricator-apparatus": "0.1.154",
+    "@shardworks/tools-apparatus": "0.1.154",
+    "@shardworks/animator-apparatus": "0.1.154",
+    "@shardworks/codexes-apparatus": "0.1.154"
   },
   "devDependencies": {
     "@types/node": "25.5.0"

package/src/static/spider-ui.test.ts

@@ -220,3 +220,177 @@ describe('index.html status filter includes cancelled', () => {
     assert.ok(cancelledIdx > blockedIdx, 'cancelled option should appear after blocked');
   });
 });
+
+// ── Rig auto-polling ────────────────────────────────────────────────────
+
+describe('spider.js rig list polling', () => {
+  it('declares rigListPollTimer state variable', () => {
+    assert.match(
+      spiderJs,
+      /var rigListPollTimer\s*=\s*null/,
+      'should declare rigListPollTimer state variable',
+    );
+  });
+
+  it('declares currentRigPollTimer state variable', () => {
+    assert.match(
+      spiderJs,
+      /var currentRigPollTimer\s*=\s*null/,
+      'should declare currentRigPollTimer state variable',
+    );
+  });
+
+  it('declares RIG_POLL_INTERVAL constant', () => {
+    assert.match(
+      spiderJs,
+      /var RIG_POLL_INTERVAL\s*=\s*2000/,
+      'should declare RIG_POLL_INTERVAL at 2000ms',
+    );
+  });
+
+  it('defines isRigInFlight helper checking running and blocked', () => {
+    assert.match(
+      spiderJs,
+      /function isRigInFlight\(rig\)/,
+      'should define isRigInFlight helper',
+    );
+    assert.match(
+      spiderJs,
+      /rig\.status === 'running' \|\| rig\.status === 'blocked'/,
+      'isRigInFlight should check running or blocked',
+    );
+  });
+
+  it('defines stopRigListPoll that clears the interval', () => {
+    assert.match(
+      spiderJs,
+      /function stopRigListPoll\(\)/,
+      'should define stopRigListPoll',
+    );
+    assert.match(
+      spiderJs,
+      /clearInterval\(rigListPollTimer\)/,
+      'stopRigListPoll should clear rigListPollTimer',
+    );
+  });
+
+  it('defines stopCurrentRigPoll that clears the interval', () => {
+    assert.match(
+      spiderJs,
+      /function stopCurrentRigPoll\(\)/,
+      'should define stopCurrentRigPoll',
+    );
+    assert.match(
+      spiderJs,
+      /clearInterval\(currentRigPollTimer\)/,
+      'stopCurrentRigPoll should clear currentRigPollTimer',
+    );
+  });
+
+  it('starts rig list polling after fetchRigs succeeds', () => {
+    // The fetchRigs promise chain should call startRigListPollIfNeeded
+    const fetchRigsBlock = spiderJs.match(
+      /function fetchRigs\([\s\S]*?\.catch/,
+    );
+    assert.ok(fetchRigsBlock, 'should find fetchRigs function');
+    assert.match(
+      fetchRigsBlock[0],
+      /startRigListPollIfNeeded\(\)/,
+      'fetchRigs should call startRigListPollIfNeeded after rendering',
+    );
+  });
+
+  it('starts current rig polling in showRigDetail', () => {
+    const showRigBlock = spiderJs.match(
+      /function showRigDetail\(rig\)[\s\S]*?startCurrentRigPoll\(\)/,
+    );
+    assert.ok(
+      showRigBlock,
+      'showRigDetail should call startCurrentRigPoll',
+    );
+  });
+
+  it('stops current rig poll when navigating back to list', () => {
+    const backBlock = spiderJs.match(
+      /function backToList\(\)[\s\S]*?stopCurrentRigPoll\(\)/,
+    );
+    assert.ok(
+      backBlock,
+      'backToList should call stopCurrentRigPoll',
+    );
+  });
+
+  it('stops current rig poll when selecting a new rig', () => {
+    const showRigBlock = spiderJs.match(
+      /function showRigDetail\(rig\)[\s\S]*?stopCurrentRigPoll\(\)/,
+    );
+    assert.ok(
+      showRigBlock,
+      'showRigDetail should call stopCurrentRigPoll before starting new poll',
+    );
+  });
+
+  it('fetchCurrentRigQuiet fetches /api/rig/show with rig id', () => {
+    assert.match(
+      spiderJs,
+      /function fetchCurrentRigQuiet\(\)/,
+      'should define fetchCurrentRigQuiet',
+    );
+    assert.match(
+      spiderJs,
+      /\/api\/rig\/show\?id=/,
+      'fetchCurrentRigQuiet should fetch /api/rig/show',
+    );
+  });
+
+  it('fetchCurrentRigQuiet preserves selectedEngineId across polls', () => {
+    // The poll handler should find the updated engine by selectedEngineId.
+    // Use a greedy match to capture the whole function body up to the next
+    // top-level function declaration.
+    const pollBlock = spiderJs.match(
+      /function fetchCurrentRigQuiet[\s\S]*?(?=\n  function )/,
+    );
+    assert.ok(pollBlock, 'should find fetchCurrentRigQuiet');
+    assert.match(
+      pollBlock[0],
+      /selectedEngineId/,
+      'should reference selectedEngineId to preserve selection',
+    );
+  });
+
+  it('fetchCurrentRigQuiet stops polling on terminal status', () => {
+    const pollBlock = spiderJs.match(
+      /function fetchCurrentRigQuiet[\s\S]*?(?=\n  function )/,
+    );
+    assert.ok(pollBlock, 'should find fetchCurrentRigQuiet');
+    assert.match(
+      pollBlock[0],
+      /isRigInFlight/,
+      'should check isRigInFlight and stop when terminal',
+    );
+  });
+
+  it('refresh button resets rig list poll cycle', () => {
+    const refreshBlock = spiderJs.match(
+      /refresh-btn[\s\S]*?fetchRigs/,
+    );
+    assert.ok(refreshBlock, 'should find refresh button handler');
+    assert.match(
+      refreshBlock[0],
+      /stopRigListPoll\(\)/,
+      'refresh button should stop existing poll before fetching',
+    );
+  });
+
+  it('rig list quiet poll stops itself when no in-flight rigs remain', () => {
+    const quietBlock = spiderJs.match(
+      /function fetchRigListQuiet[\s\S]*?stopRigListPoll/,
+    );
+    assert.ok(quietBlock, 'should find fetchRigListQuiet');
+    assert.match(
+      quietBlock[0],
+      /hasInFlight/,
+      'should check for in-flight rigs and stop poll if none',
+    );
+  });
+});

package/src/static/spider.js

@@ -18,6 +18,10 @@
   var sessionPollTimer = null;
   var sessionEventSource = null;
   var selectedTemplateName = null;
+  var rigListPollTimer = null;
+  var currentRigPollTimer = null;
+
+  var RIG_POLL_INTERVAL = 2000;
 
   // ── Badge mapping ──────────────────────────────────────────────────────
 
@@ -129,6 +133,112 @@
     stopSessionPoll();
   }
 
+  // ── Rig polling helpers ────────────────────────────────────────────────
+
+  function isRigInFlight(rig) {
+    return rig.status === 'running' || rig.status === 'blocked';
+  }
+
+  function stopRigListPoll() {
+    if (rigListPollTimer !== null) {
+      clearInterval(rigListPollTimer);
+      rigListPollTimer = null;
+    }
+  }
+
+  function stopCurrentRigPoll() {
+    if (currentRigPollTimer !== null) {
+      clearInterval(currentRigPollTimer);
+      currentRigPollTimer = null;
+    }
+  }
+
+  function startRigListPollIfNeeded() {
+    stopRigListPoll();
+    var hasInFlight = rigs.some(isRigInFlight);
+    if (!hasInFlight) return;
+    rigListPollTimer = setInterval(function () {
+      fetchRigListQuiet();
+    }, RIG_POLL_INTERVAL);
+  }
+
+  /** Refetch rig list without resetting filters — silent background refresh. */
+  function fetchRigListQuiet() {
+    var rigUrl = '/api/rig/list?limit=100';
+    if (currentStatusFilter) {
+      rigUrl += '&status=' + encodeURIComponent(currentStatusFilter);
+    }
+
+    var rigPromise = fetch(rigUrl).then(function (r) { return r.json(); });
+    var writPromise = fetch('/api/writ/list?limit=100').then(function (r) { return r.json(); });
+
+    Promise.all([rigPromise, writPromise]).then(function (results) {
+      rigs = Array.isArray(results[0]) ? results[0] : [];
+      buildWritLookup(Array.isArray(results[1]) ? results[1] : []);
+      renderRigList();
+
+      // Re-evaluate whether polling should continue
+      var hasInFlight = rigs.some(isRigInFlight);
+      if (!hasInFlight) {
+        stopRigListPoll();
+      }
+    }).catch(function (err) {
+      console.error('[spider] rig list poll error:', err);
+    });
+  }
+
+  function startCurrentRigPoll() {
+    stopCurrentRigPoll();
+    if (!currentRig || !isRigInFlight(currentRig)) return;
+    currentRigPollTimer = setInterval(function () {
+      fetchCurrentRigQuiet();
+    }, RIG_POLL_INTERVAL);
+  }
+
+  /** Refetch the currently-viewed rig and update detail + pipeline in place. */
+  function fetchCurrentRigQuiet() {
+    if (!currentRig) { stopCurrentRigPoll(); return; }
+    fetch('/api/rig/show?id=' + encodeURIComponent(currentRig.id))
+      .then(function (r) { return r.json(); })
+      .then(function (rig) {
+        if (!currentRig || currentRig.id !== rig.id) return; // navigated away
+        currentRig = rig;
+
+        // Update the meta table
+        var metaTable = document.getElementById('detail-meta');
+        if (metaTable) {
+          metaTable.innerHTML =
+            '<tbody>' +
+            '<tr><th>ID</th><td>' + esc(rig.id) + '</td></tr>' +
+            '<tr><th>Writ</th><td><a href="/pages/clerk/?writ=' + esc(rig.writId) + '">' + esc(rig.writId) + '</a></td></tr>' +
+            '<tr><th>Status</th><td>' + badgeHtml(rig.status) + '</td></tr>' +
+            '<tr><th>Created</th><td>' + esc(formatDate(rig.createdAt)) + '</td></tr>' +
+            '</tbody>';
+        }
+
+        // Re-render pipeline, preserving selection
+        renderPipeline(rig);
+
+        // If an engine was selected, update engine detail with fresh data
+        if (selectedEngineId) {
+          var updatedEngine = (rig.engines || []).find(function (e) {
+            return e.id === selectedEngineId;
+          });
+          if (updatedEngine) {
+            showEngineDetail(updatedEngine);
+          }
+        }
+
+        // Stop polling once terminal
+        if (!isRigInFlight(rig)) {
+          stopCurrentRigPoll();
+        }
+      })
+      .catch(function (err) {
+        console.error('[spider] current rig poll error:', err);
+      });
+  }
+
   // ── Fetch rigs ─────────────────────────────────────────────────────────
 
   function fetchRigs(statusFilter) {
@@ -145,6 +255,7 @@
       rigs = Array.isArray(results[0]) ? results[0] : [];
       buildWritLookup(Array.isArray(results[1]) ? results[1] : []);
       renderRigList();
+      startRigListPollIfNeeded();
     }).catch(function (err) {
       console.error('Failed to fetch rigs/writs:', err);
       rigs = [];
@@ -236,6 +347,7 @@
     selectedEngineId = null;
 
     stopSessionStream();
+    stopCurrentRigPoll();
 
     document.getElementById('rig-list-view').style.display = 'none';
     document.getElementById('rig-detail-view').style.display = '';
@@ -279,6 +391,8 @@
 
     var engineDetail = document.getElementById('engine-detail');
     if (engineDetail) engineDetail.style.display = 'none';
+
+    startCurrentRigPoll();
   }
 
   // ── Render pipeline (generic) ──────────────────────────────────────────
@@ -646,6 +760,7 @@
 
   function backToList() {
     stopSessionStream();
+    stopCurrentRigPoll();
     currentRig = null;
     selectedEngineId = null;
     document.getElementById('rig-detail-view').style.display = 'none';
@@ -877,6 +992,7 @@
     var refreshBtn = document.getElementById('refresh-btn');
     if (refreshBtn) {
       refreshBtn.addEventListener('click', function () {
+        stopRigListPoll();
         fetchRigs(currentStatusFilter);
       });
     }