Skip to content

armgit / ECC

Public Imported from GitHub
0

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

fix(control-pane): bound snapshot loads and automatic polling

affaan-m621abca3503a
diff --git a/scripts/lib/control-pane/ui.js b/scripts/lib/control-pane/ui.js
index d42a13eae..38573b291 100644
--- a/scripts/lib/control-pane/ui.js
+++ b/scripts/lib/control-pane/ui.js
@@ -443,6 +443,9 @@ function renderControlPaneHtml() {
// the newest data any load brought, and the error box the outcome of the
// newest load that has finished, so a load that finishes late can neither
// replace newer data nor overrule a newer outcome.
+ const SNAPSHOT_DEADLINE_MS = 10000;
+ const SNAPSHOT_POLL_INTERVAL_MS = 15000;
+ let snapshotsInFlight = 0;
let loadsStarted = 0;
let newestFinished = 0;
let shownLoad = 0;
@@ -656,11 +659,28 @@ function renderControlPaneHtml() {
async function load(live = false) {
const id = ++loadsStarted;
const query = state.query;
+ snapshotsInFlight++;
+ let snapshotTimer = null;
try {
const url = new URL('/api/snapshot', window.location.href);
if (query) url.searchParams.set('query', query);
- const response = await fetch(url);
- const snapshot = await readJsonResponse(response);
+ const controller = new AbortController();
+ let rejectDeadline;
+ const deadline = new Promise((_resolve, reject) => { rejectDeadline = reject; });
+ snapshotTimer = setTimeout(() => {
+ // Reject first so the fixed timeout wins over an abort rejection.
+ rejectDeadline(new Error('Snapshot request timed out after 10 seconds.'));
+ controller.abort();
+ }, SNAPSHOT_DEADLINE_MS);
+ // Only fetch/body decoding races the deadline. Late abort-ignoring
+ // responses have no rendering or state side effects after losing.
+ const snapshot = await Promise.race([
+ (async () => {
+ const response = await fetch(url, { signal: controller.signal });
+ return readJsonResponse(response);
+ })(),
+ deadline
+ ]);
// A snapshot that cannot be shown fails its load like one that could
// not be fetched, and older data may still take the board.
if (id > shownLoad) {
@@ -673,6 +693,9 @@ function renderControlPaneHtml() {
failure = { error, live };
showFailure();
return;
+ } finally {
+ if (snapshotTimer !== null) clearTimeout(snapshotTimer);
+ snapshotsInFlight--;
}
if (id < newestFinished) {
// A newer load failed first. This data is still the newest on the
@@ -756,11 +779,12 @@ function renderControlPaneHtml() {
.catch(error => showError('#app', error));
};
- // Live board: refresh on a gentle interval; pause while a prompt/tab is hidden.
+ // Only automatic polls coalesce. Manual/query loads retain ordered overlap.
+ // Browser suspension may delay timers; this is not a wall-clock server SLA.
setInterval(() => {
- if (document.hidden) return;
+ if (document.hidden || snapshotsInFlight > 0) return;
load(true).catch(error => showError('#app', error));
- }, 15000);
+ }, SNAPSHOT_POLL_INTERVAL_MS);
load().catch(error => showError('#app', error));
</script>
diff --git a/tests/lib/control-pane-ui.test.js b/tests/lib/control-pane-ui.test.js
index a00cbf12f..922f1afe7 100644
--- a/tests/lib/control-pane-ui.test.js
+++ b/tests/lib/control-pane-ui.test.js
@@ -1,33 +1,38 @@
/**
* Tests for the browser script the local ECC2 control pane serves.
*/
-
const assert = require('assert');
const fs = require('fs');
const os = require('os');
const path = require('path');
const vm = require('vm');
-
const { buildControlPaneSnapshot } = require('../../scripts/lib/control-pane/state');
const { renderControlPaneHtml } = require('../../scripts/lib/control-pane/ui');
-
+const pages = new Set();
async function test(name, fn) {
- try {
- await fn();
- console.log(` PASS ${name}`);
- return true;
- } catch (error) {
+ let failed = false;
+ let failure;
+ try { await fn(); } catch (error) { failed = true; failure = error; }
+ finally {
+ for (const page of pages) {
+ try { await page.dispose(); } catch (error) {
+ if (!failed) { failed = true; failure = error; }
+ }
+ }
+ pages.clear();
+ }
+ if (failed) {
console.log(` FAIL ${name}`);
- console.log(` Error: ${error.message}`);
+ console.log(` Error: ${failure?.message ?? String(failure)}`);
return false;
}
+ console.log(` PASS ${name}`);
+ return true;
}
-
function inlineScript(html) {
const start = html.indexOf('<script>') + '<script>'.length;
return html.slice(start, html.lastIndexOf('</script>'));
}
-
// The page's clock. The page shows times with toLocaleString, which follows
// the locale's calendar (a Thai locale counts Buddhist years), so a test
// compares against the same call on this instant.
@@ -64,7 +69,45 @@ function openPage(snapshot, { hold = false } = {}) {
}
return elements.get(selector);
};
- const page = { online: true, hold, pending: [], requests: [], refresh: null, element, now: NOW };
+ const page = { online: true, hold, pending: [], requests: [], refresh: null, element, now: NOW,
+ timers: new Map(), timerCalls: [], clearCalls: [], tick: 0, ignoreAbort: false };
+ let timerId = 0;
+ class FakeAbortController {
+ constructor() {
+ const listeners = new Set();
+ this.signal = { aborted: false, listeners,
+ addEventListener: (_type, callback) => listeners.add(callback),
+ removeEventListener: (_type, callback) => listeners.delete(callback) };
+ this.aborts = 0;
+ }
+ abort() {
+ this.aborts++;
+ if (this.signal.aborted) return;
+ this.signal.aborted = true;
+ for (const listener of this.signal.listeners) listener();
+ }
+ }
+ page.fireTimer = id => {
+ const timer = page.timers.get(id);
+ assert.ok(timer, 'Expected a pending deadline');
+ page.timers.delete(id);
+ timer.callback();
+ };
+ page.advance = ms => {
+ page.tick += ms;
+ for (const [id, timer] of [...page.timers]) if (timer.at <= page.tick) page.fireTimer(id);
+ };
+ page.dispose = async () => {
+ await settle();
+ for (const request of page.requests) request.reply.fail(new Error('Fixture disposed'));
+ await settle();
+ const remaining = page.timers.size;
+ page.timers.clear();
+ assert.strictEqual(remaining, 0, 'Every load must remove its deadline after fixture settlement');
+ assert.ok(page.requests.every(request => request.reply.settled), 'All fake requests must settle');
+ assert.ok(page.requests.every(request => !request.options.signal || request.options.signal.listeners.size === 0), 'Fake abort listeners must be removed');
+ };
+ pages.add(page);
class Clock extends PageDate {
constructor(...args) {
super(...(args.length > 0 ? args : [page.now.getTime()]));
@@ -77,22 +120,65 @@ function openPage(snapshot, { hold = false } = {}) {
Intl,
Date: Clock,
console,
+ AbortController: FakeAbortController,
+ setTimeout: (callback, ms) => {
+ const id = ++timerId;
+ page.timerCalls.push({ id, ms });
+ page.timers.set(id, { callback, at: page.tick + ms });
+ return id;
+ },
+ clearTimeout: id => { page.clearCalls.push(id); page.timers.delete(id); },
fetch: (url, options = {}) =>
new Promise((resolve, reject) => {
- page.requests = [...page.requests, { url: String(url), options }];
- const reply = {
- succeed: (data = snapshot) => resolve({ ok: true, status: 200, statusText: 'OK', json: async () => data }),
- fail: () => reject(new TypeError('Failed to fetch'))
+ let bodyResolve;
+ let bodyReject;
+ let headers = false;
+ let queuedBody;
+ const reply = { settled: false, ignoreAbort: page.ignoreAbort };
+ const finish = () => {
+ reply.settled = true;
+ options.signal?.removeEventListener('abort', onAbort);
+ };
+ const onAbort = () => {
+ if (!reply.ignoreAbort) reply.fail(new Error('Synthetic AbortError'));
};
- if (page.hold) page.pending = [...page.pending, reply];
+ reply.respond = response => {
+ if (reply.settled || headers) return;
+ headers = true;
+ resolve({ ...response, json: async () => {
+ try { return await response.json(); } finally { finish(); }
+ } });
+ };
+ reply.headers = () => reply.respond({ ok: true, status: 200, json: () => new Promise((accept, refuse) => {
+ bodyResolve = accept; bodyReject = refuse;
+ if (queuedBody) (queuedBody.error ? refuse : accept)(queuedBody.error || queuedBody.data);
+ }) });
+ reply.succeed = (data = snapshot) => {
+ if (reply.settled) return;
+ if (!headers) reply.respond({ ok: true, status: 200, statusText: 'OK', json: async () => data });
+ else if (bodyResolve) bodyResolve(data);
+ else queuedBody = { data };
+ };
+ reply.fail = (error = new TypeError('Failed to fetch')) => {
+ if (reply.settled) return;
+ if (!headers) { finish(); reject(error); }
+ else if (bodyReject) bodyReject(error);
+ else queuedBody = { error };
+ };
+ page.requests.push({ url: String(url), options, reply });
+ options.signal?.addEventListener('abort', onAbort);
+ if (page.hold) page.pending.push(reply);
else if (page.online) reply.succeed();
else reply.fail();
}),
- setInterval: callback => {
+ setInterval: (callback, ms) => {
+ page.intervalMs = ms;
page.refresh = callback;
}
};
- vm.runInNewContext(inlineScript(renderControlPaneHtml()), page.script);
+ vm.createContext(page.script);
+ vm.runInContext(inlineScript(renderControlPaneHtml()), page.script);
+ page.state = () => JSON.parse(vm.runInContext('JSON.stringify({ loadedAt: loadedAt && loadedAt.getTime(), shownLoad, loadsStarted, newestFinished, query: state.query, shownQuery: state.shownQuery, allowActions: state.allowActions, active: typeof snapshotsInFlight === "undefined" ? null : snapshotsInFlight })', page.script));
return page;
}
@@ -142,6 +228,8 @@ async function runTests() {
let failed = 0;
const snapshot = await isolatedSnapshot();
+ // The original ordering cases below explicitly dispatch load(true) where
+ // overlap is intentional. Automatic interval coalescing is tested separately.
if (
await test('a failed live refresh is reported, and cleared by the next one that succeeds', async () => {
@@ -173,9 +261,9 @@ async function runTests() {
await settle();
page.hold = true;
- page.refresh();
+ page.script.load(true);
page.hold = false;
- page.refresh();
+ page.script.load(true);
await settle();
page.pending[0].fail();
await settle();
@@ -191,9 +279,9 @@ async function runTests() {
await settle();
page.hold = true;
- page.refresh();
- page.refresh();
- page.refresh();
+ page.script.load(true);
+ page.script.load(true);
+ page.script.load(true);
page.pending[1].succeed();
await settle();
page.pending[0].fail();
@@ -210,8 +298,8 @@ async function runTests() {
await settle();
page.hold = true;
- page.refresh();
- page.refresh();
+ page.script.load(true);
+ page.script.load(true);
page.pending[0].succeed();
await settle();
page.pending[1].fail();
@@ -230,8 +318,8 @@ async function runTests() {
await settle();
page.hold = true;
- page.refresh();
- page.refresh();
+ page.script.load(true);
+ page.script.load(true);
page.pending[1].fail();
await settle();
page.pending[0].succeed();
@@ -251,8 +339,8 @@ async function runTests() {
const answer = query => ({ ...snapshot, knowledge: { ...snapshot.knowledge, query } });
page.hold = true;
- page.refresh();
- page.refresh();
+ page.script.load(true);
+ page.script.load(true);
page.pending[1].succeed(answer('newer'));
await settle();
page.pending[0].succeed(answer('older'));
@@ -268,7 +356,7 @@ async function runTests() {
const page = openPage(snapshot, { hold: true });
const answer = query => ({ ...snapshot, knowledge: { ...snapshot.knowledge, query } });
- page.refresh();
+ page.script.load(true);
page.pending[1].fail();
await settle();
page.pending[0].succeed(answer('first'));
@@ -289,7 +377,7 @@ async function runTests() {
page.hold = true;
page.element('#refresh').listeners.click();
- page.refresh();
+ page.script.load(true);
page.pending[1].succeed();
await settle();
page.pending[0].fail();
@@ -306,7 +394,7 @@ async function runTests() {
await settle();
page.hold = true;
- page.refresh();
+ page.script.load(true);
page.element('#refresh').listeners.click();
page.pending[1].fail();
await settle();
@@ -332,8 +420,8 @@ async function runTests() {
};
page.hold = true;
- page.refresh();
- page.refresh();
+ page.script.load(true);
+ page.script.load(true);
page.pending[1].succeed(unshowable);
await settle();
const box = page.element('#app');
@@ -397,7 +485,7 @@ async function runTests() {
await settle();
const before = displayedBoard(page);
page.now = new Date(NOW.getTime() + 60_000);
- page.refresh();
+ page.script.load(true);
const invalid = {
...original,
dbPath: 'new-database', database: { exists: true },
@@ -454,6 +542,259 @@ async function runTests() {
) passed++;
else failed++;
+
+ const answer = (query, allowActions = false) => ({
+ ...snapshot, knowledge: { ...snapshot.knowledge, query }, execution: { allowActions },
+ });
+ const search = (page, query) => {
+ page.element('#query').value = query;
+ page.element('#query-form').listeners.submit({ preventDefault() {} });
+ };
+ const deadlineTests = [
+ ['actual intervals coalesce a stalled request, then timeout and recover', async () => {
+ const page = openPage(snapshot);
+ await settle();
+ const before = displayedBoard(page);
+ const accepted = page.state().loadedAt;
+ page.hold = true;
+ page.refresh();
+ const request = page.requests[1];
+ for (let i = 0; i < 4; i++) page.refresh();
+ assert.strictEqual(page.requests.length, 2, 'Only one automatic load may be active');
+ assert.strictEqual(page.state().active, 1);
+ assert.strictEqual(page.intervalMs, 15000);
+ assert.strictEqual(page.timerCalls.at(-1).ms, 10000);
+ page.advance(9999);
+ await settle();
+ assert.strictEqual(page.element('#app').hidden, true);
+ assert.strictEqual(request.options.signal.aborted, false);
+ page.advance(1);
+ await settle();
+ assert.strictEqual(request.options.signal.aborted, true);
+ assert.strictEqual(page.state().active, 0);
+ assert.strictEqual(page.timers.size, 0);
+ assert.deepStrictEqual(displayedBoard(page), before);
+ assert.strictEqual(page.state().loadedAt, accepted);
+ assert.match(page.element('#app').textContent, /Live refresh failed[\s\S]*Snapshot request timed out after 10 seconds/);
+ assert.ok(page.element('#app').textContent.includes(NOW.toLocaleString()));
+ page.hold = false;
+ page.now = new Date(NOW.getTime() + 60_000);
+ page.refresh();
+ await settle();
+ assert.strictEqual(page.requests.length, 3);
+ assert.strictEqual(page.element('#app').hidden, true);
+ assert.strictEqual(page.state().loadedAt, page.now.getTime());
+ assert.strictEqual(page.timers.size, 0);
+ }],
+ ['one total deadline includes headers and a stalled JSON body', async () => {
+ const page = openPage(snapshot);
+ await settle();
+ const before = displayedBoard(page);
+ page.hold = true;
+ page.refresh();
+ page.advance(4000);
+ page.pending[0].headers();
+ await settle();
+ page.advance(5999);
+ await settle();
+ assert.strictEqual(page.element('#app').hidden, true);
+ page.advance(1);
+ await settle();
+ assert.match(page.element('#app').textContent, /Snapshot request timed out after 10 seconds/);
+ assert.doesNotMatch(page.element('#app').textContent, /Synthetic AbortError/);
+ assert.deepStrictEqual(displayedBoard(page), before);
+ assert.strictEqual(page.requests[1].options.signal.aborted, true);
+ assert.strictEqual(page.state().active, 0);
+ }],
+ ['expired header response cannot overwrite a newer accepted query or permission', async () => {
+ const page = openPage(snapshot);
+ await settle();
+ page.hold = true; page.ignoreAbort = true;
+ page.refresh();
+ const late = page.pending[0];
+ page.advance(10000);
+ await settle();
+ search(page, 'new query');
+ page.pending[1].succeed(answer('new query', true));
+ await settle();
+ const before = displayedBoard(page);
+ const state = page.state();
+ late.succeed(answer('expired query', false));
+ await settle();
+ assert.deepStrictEqual(displayedBoard(page), before);
+ assert.deepStrictEqual(page.state(), state);
+ assert.strictEqual(page.element('#app').hidden, true);
+ }],
+ ['expired body response cannot overwrite a newer failure or release its active counter twice', async () => {
+ const page = openPage(snapshot);
+ await settle();
+ page.hold = true; page.ignoreAbort = true;
+ page.refresh();
+ const late = page.pending[0];
+ late.headers();
+ await settle();
+ page.advance(10000);
+ await settle();
+ page.refresh();
+ page.pending[1].fail(new Error('Newer failure'));
+ await settle();
+ const failure = page.element('#app').textContent;
+ const before = displayedBoard(page);
+ page.refresh(); // Another load remains active while the expired loser finishes.
+ late.succeed(answer('expired query', true));
+ await settle();
+ assert.deepStrictEqual(displayedBoard(page), before);
+ assert.strictEqual(page.element('#app').textContent, failure);
+ assert.strictEqual(page.state().active, 1);
+ page.refresh();
+ assert.strictEqual(page.requests.length, 4, 'Late completion must not reopen the automatic dispatch gate');
+ page.pending[2].succeed();
+ await settle();
+ assert.strictEqual(page.state().active, 0);
+ }],
+ ['expired late fetch rejection stays handled and preserves the newer outcome', async () => {
+ const page = openPage(snapshot);
+ await settle();
+ page.hold = true; page.ignoreAbort = true;
+ page.refresh();
+ const late = page.pending[0];
+ page.advance(10000);
+ await settle();
+ page.refresh();
+ page.pending[1].succeed();
+ await settle();
+ const state = page.state();
+ late.fail(new Error('Late ignored abort rejection'));
+ await settle();
+ assert.deepStrictEqual(page.state(), state);
+ assert.strictEqual(page.element('#app').hidden, true);
+ }],
+ ['initial timeout is visible without an invented last-good timestamp', async () => {
+ const page = openPage(snapshot, { hold: true });
+ page.refresh();
+ assert.strictEqual(page.requests.length, 1, 'Initial load also suppresses automatic dispatch');
+ page.advance(10000);
+ await settle();
+ assert.strictEqual(page.element('#app').hidden, false);
+ assert.match(page.element('#app').textContent, /Snapshot request timed out/);
+ assert.doesNotMatch(page.element('#app').textContent, /data below is from/);
+ assert.strictEqual(page.state().loadedAt, null);
+ page.hold = false;
+ page.refresh();
+ await settle();
+ assert.strictEqual(page.element('#app').hidden, true);
+ assert.strictEqual(page.state().loadedAt, NOW.getTime());
+ }],
+ ['manual and query loads may overlap a poll while actual intervals remain suppressed', async () => {
+ const page = openPage(snapshot);
+ await settle();
+ page.hold = true;
+ page.refresh();
+ page.element('#refresh').listeners.click();
+ search(page, 'query');
+ assert.strictEqual(page.requests.length, 4);
+ assert.strictEqual(page.state().active, 3);
+ page.pending[1].succeed();
+ await settle();
+ assert.strictEqual(page.state().active, 2);
+ page.refresh();
+ assert.strictEqual(page.requests.length, 4);
+ page.pending[2].succeed(answer('query'));
+ await settle();
+ assert.strictEqual(page.state().active, 1);
+ page.advance(10000);
+ await settle();
+ assert.strictEqual(page.state().active, 0);
+ assert.strictEqual(page.element('#app').hidden, true, 'Older timeout does not overrule newer success');
+ page.refresh();
+ assert.strictEqual(page.requests.length, 5);
+ }],
+ ['newer manual timeout remains visible when an older valid load supplies fallback data', async () => {
+ const page = openPage(snapshot);
+ await settle();
+ page.hold = true;
+ search(page, 'older');
+ search(page, 'newer');
+ // Adversarial completion order: fire only the newer timer, not wall time.
+ page.fireTimer(page.timerCalls.at(-1).id);
+ await settle();
+ page.pending[0].succeed(answer('older', true));
+ await settle();
+ assert.strictEqual(page.element('#query').value, 'older');
+ assert.strictEqual(page.state().shownQuery, 'older');
+ assert.strictEqual(page.state().allowActions, true);
+ assert.match(page.element('#app').textContent, /Snapshot request timed out/);
+ assert.doesNotMatch(page.element('#app').textContent, /Live refresh failed/);
+ assert.strictEqual(page.state().active, 0);
+ }],
+ ['hidden interval leaves existing failure intact until a visible successful refresh', async () => {
+ const page = openPage(snapshot);
+ await settle();
+ page.online = false;
+ page.refresh();
+ await settle();
+ const failure = page.element('#app').textContent;
+ page.script.document.hidden = true;
+ page.refresh();
+ assert.strictEqual(page.requests.length, 2);
+ assert.strictEqual(page.element('#app').textContent, failure);
+ page.script.document.hidden = false; page.online = true;
+ page.refresh();
+ await settle();
+ assert.strictEqual(page.element('#app').hidden, true);
+ }],
+ ['action POST remains unbounded by snapshot timers and its reload gets a deadline', async () => {
+ const page = openPage(snapshot);
+ await settle();
+ page.hold = true;
+ const action = page.script.runAction('recall-knowledge');
+ assert.strictEqual(page.requests[1].options.method, 'POST');
+ assert.strictEqual(page.requests[1].options.signal, undefined);
+ assert.strictEqual(page.timers.size, 0);
+ page.advance(10000);
+ assert.strictEqual(page.pending[0].settled, false);
+ page.pending[0].succeed({ ok: true });
+ await settle();
+ assert.match(page.requests[2].url, /\/api\/snapshot/);
+ assert.ok(page.requests[2].options.signal);
+ assert.strictEqual(page.timers.size, 1);
+ page.pending[1].succeed();
+ await action;
+ assert.strictEqual(page.timers.size, 0);
+ }],
+ ];
+ for (const route of ['HTTP failure', 'invalid JSON', 'malformed late section', 'fetch setup', 'controller setup', 'URL setup', 'timer setup']) {
+ deadlineTests.push([`${route} releases its timer and active counter for the next interval`, async () => {
+ const page = openPage(snapshot);
+ await settle();
+ page.hold = true;
+ const key = { 'fetch setup': 'fetch', 'controller setup': 'AbortController', 'URL setup': 'URL', 'timer setup': 'setTimeout' }[route];
+ const original = page.script[key];
+ if (key) page.script[key] = function () { throw new Error(route); };
+ page.refresh();
+ if (route === 'HTTP failure') page.pending[0].respond({ ok: false, json: async () => ({ error: route }) });
+ if (route === 'invalid JSON') page.pending[0].respond({ ok: true, json: async () => { throw new Error(route); } });
+ if (route === 'malformed late section') page.pending[0].succeed({ ...snapshot, actions: {} });
+ await settle();
+ assert.strictEqual(page.element('#app').hidden, false);
+ assert.strictEqual(page.state().active, 0);
+ assert.strictEqual(page.timers.size, 0);
+ if (key) page.script[key] = original;
+ page.hold = false;
+ const count = page.requests.length;
+ page.refresh();
+ await settle();
+ assert.strictEqual(page.requests.length, count + 1);
+ assert.strictEqual(page.element('#app').hidden, true);
+ assert.strictEqual(page.state().active, 0);
+ }]);
+ }
+ for (const [name, check] of deadlineTests) {
+ if (await test(name, check)) passed++;
+ else failed++;
+ }
+ assert.strictEqual(pages.size, 0, 'Every fake page and its pending requests were disposed');
+
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
process.exit(failed > 0 ? 1 : 0);
}