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.jsindex 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.jsindex 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);}