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.

test(plan-canvas): close owned resources across failure paths

affaan-m63f30ffc366b
diff --git a/tests/scripts/plan-canvas.test.js b/tests/scripts/plan-canvas.test.js
index cc3da84d2..da4746272 100644
--- a/tests/scripts/plan-canvas.test.js
+++ b/tests/scripts/plan-canvas.test.js
@@ -21,6 +21,11 @@ const { createPlanCanvasServer } = require('../../scripts/lib/plan-canvas/server
class SkippedTest extends Error {}
+function failureText(error) {
+ try { return error?.stack || error?.message || String(error); }
+ catch { return 'Unprintable thrown value'; }
+}
+
function createTestRunner(log = console.log) {
let results = { passed: 0, failed: 0, skipped: 0 };
return {
@@ -36,7 +41,7 @@ function createTestRunner(log = console.log) {
log(` SKIP ${name}: ${error.message}`);
} else {
results = { ...results, failed: results.failed + 1 };
- log(` FAIL ${name}\n Error: ${error.stack || error.message}`);
+ log(` FAIL ${name}\n Error: ${failureText(error)}`);
}
}
}
@@ -102,6 +107,42 @@ async function withFixtureCleanup(callback, cleanups) {
return result;
}
+// Explicit close and finally cleanup await the same attempt, including failure.
+function onceCleanup(cleanup) {
+ let pending;
+ return () => {
+ if (!pending) pending = Promise.resolve().then(cleanup);
+ return pending;
+ };
+}
+
+async function withResourceScope(callback) {
+ const clients = [];
+ const servers = [];
+ const roots = [];
+ const own = (group, cleanup) => {
+ const close = onceCleanup(cleanup);
+ group.push(close);
+ return close;
+ };
+ const resources = {
+ client: cleanup => own(clients, cleanup),
+ server: cleanup => own(servers, cleanup),
+ root: cleanup => own(roots, cleanup),
+ };
+ return withFixtureCleanup(() => callback(resources), () => [...clients, ...servers, ...roots]);
+}
+
+// Requests are owned before setup writes or awaits. Destroy the response and
+// request independently so one cleanup failure cannot leave the other open.
+function ownHttpClient(req, getResponse, resources) {
+ const cleanup = () => withFixtureCleanup(() => {}, () => {
+ const response = getResponse();
+ return [...(response ? [() => response.destroy()] : []), () => req.destroy()];
+ });
+ return resources ? resources.client(cleanup) : onceCleanup(cleanup);
+}
+
// Capture fresh real dispatchers without binding sockets. Each request captures
// its own filesystem facade; the fixture owns those canvases until teardown.
// Artifact bodies are inert response bytes, never executed in a browser.
@@ -673,10 +714,13 @@ async function fixtureIsolationTests(test) {
}
}
-function request(port, method, requestPath, { body = null, headers = {} } = {}) {
- return new Promise((resolve, reject) => {
+function request(port, method, requestPath, {
+ body = null, headers = {}, resources, transport = http, onData = () => {}
+} = {}) {
+ let response;
+ const pending = new Promise((resolve, reject) => {
const payload = body === null ? null : JSON.stringify(body);
- const req = http.request(
+ const req = transport.request(
{
host: '127.0.0.1',
port,
@@ -688,17 +732,24 @@ function request(port, method, requestPath, { body = null, headers = {} } = {})
: headers
},
res => {
+ response = res;
+ res.on('error', reject);
let data = '';
res.on('data', chunk => {
data += chunk;
+ onData(chunk);
});
res.on('end', () => resolve({ statusCode: res.statusCode, headers: res.headers, body: data }));
}
);
+ ownHttpClient(req, () => response, resources);
req.on('error', reject);
if (payload) req.write(payload);
req.end();
});
+ // Cleanup can reject an abandoned long-poll; awaiters still see this rejection.
+ pending.catch(() => {});
+ return pending;
}
function jsonBody(res) {
@@ -706,13 +757,16 @@ function jsonBody(res) {
}
// Open an SSE stream and collect parsed events into `received`.
-function openSse(port, key) {
+function openSse(port, key, { resources, transport = http } = {}) {
const received = [];
let close = () => {};
+ let response;
const ready = new Promise((resolve, reject) => {
- const req = http.get(
+ const req = transport.get(
{ host: '127.0.0.1', port, path: `/events/${key}`, agent: false },
res => {
+ response = res;
+ res.on('error', reject);
let buffer = '';
res.on('data', chunk => {
buffer += chunk;
@@ -730,9 +784,10 @@ function openSse(port, key) {
resolve();
}
);
+ close = ownHttpClient(req, () => response, resources);
req.on('error', reject);
- close = () => req.destroy();
});
+ ready.catch(() => {});
return { received, ready, close: () => close() };
}
@@ -751,6 +806,128 @@ function waitFor(predicate, { timeoutMs = 3000, intervalMs = 20 } = {}) {
});
}
+// Deterministic ownership checks: no socket/listener or shared module mutation.
+async function integrationCleanupTests(test) {
+ async function capture(callback) {
+ try { return { threw: false, value: await callback() }; }
+ catch (error) { return { threw: true, error }; }
+ }
+ for (const primary of [Object.freeze(new Error('primary integration failure')), 0, false, null, undefined]) {
+ await test(`integration resource cleanup preserves ${String(primary)} and attempts all stages`, async () => {
+ const stages = [];
+ const secondary = new Error('cleanup failure');
+ const result = await capture(() => withResourceScope(async resources => {
+ resources.root(() => { stages.push('root'); throw secondary; });
+ resources.server(() => { stages.push('server'); throw secondary; });
+ resources.client(() => { stages.push('client'); throw secondary; });
+ throw primary;
+ }));
+ assert.strictEqual(result.threw, true);
+ assert.ok(Object.is(result.error, primary));
+ assert.deepStrictEqual(stages, ['client', 'server', 'root']);
+ });
+ await test(`runner records falsy/frozen failure ${String(primary)} without replacing it`, async () => {
+ const output = [];
+ const runner = createTestRunner(line => output.push(line));
+ await runner.test('failure', () => { throw primary; });
+ assert.deepStrictEqual(runner.results, { passed: 0, failed: 1, skipped: 0 });
+ assert.strictEqual(output.length, 1);
+ assert.match(output[0], /FAIL failure/);
+ });
+ }
+ await test('cleanup-only failure reports the first failure after every owned stage', async () => {
+ const first = Object.freeze(new Error('client cleanup'));
+ const stages = [];
+ const result = await capture(() => withResourceScope(resources => {
+ resources.client(() => { stages.push('client'); throw first; });
+ resources.server(() => { stages.push('server'); throw new Error('server cleanup'); });
+ resources.root(() => { stages.push('root'); throw new Error('root cleanup'); });
+ }));
+ assert.strictEqual(result.error, first);
+ assert.deepStrictEqual(stages, ['client', 'server', 'root']);
+ });
+ await test('explicit server close and automatic cleanup share one close attempt', async () => {
+ let attempts = 0;
+ await withResourceScope(async resources => {
+ const close = resources.server(async () => { attempts++; });
+ await close();
+ await close();
+ });
+ assert.strictEqual(attempts, 1);
+ });
+ await test('second acquisition failure still closes the first server and roots', async () => {
+ const primary = new Error('second acquisition');
+ const stages = [];
+ const result = await capture(() => withResourceScope(resources => {
+ resources.root(() => stages.push('root-one'));
+ resources.server(() => stages.push('server-one'));
+ resources.root(() => stages.push('root-two'));
+ throw primary;
+ }));
+ assert.strictEqual(result.error, primary);
+ assert.deepStrictEqual(stages, ['server-one', 'root-one', 'root-two']);
+ });
+ function fakeHttp() {
+ const { EventEmitter } = require('events');
+ const stages = [];
+ const request = new EventEmitter();
+ const response = new EventEmitter();
+ let respond;
+ request.write = () => {};
+ request.end = () => {};
+ request.destroy = () => { stages.push('request'); request.emit('error', new Error('owned request destroyed')); };
+ response.destroy = () => { stages.push('response'); };
+ return {
+ stages, request, response,
+ transport: { get(_options, callback) { respond = callback; return request; }, request(_options, callback) { respond = callback; return request; } },
+ respond() { respond(response); },
+ };
+ }
+ for (const headers of [false, true]) {
+ await test(`SSE failure cleanup owns request before headers=${headers}`, async () => {
+ const fake = fakeHttp();
+ const primary = new Error('SSE assertion');
+ let sse;
+ const result = await capture(() => withResourceScope(async resources => {
+ sse = openSse(1, 'synthetic', { resources, transport: fake.transport });
+ if (headers) { fake.respond(); await sse.ready; }
+ throw primary;
+ }));
+ assert.strictEqual(result.error, primary);
+ assert.deepStrictEqual(fake.stages, headers ? ['response', 'request'] : ['request']);
+ await sse.ready.catch(() => {});
+ await sse.close();
+ assert.strictEqual(fake.stages.filter(stage => stage === 'request').length, 1);
+ });
+ }
+ await test('abandoned long-poll cleanup reaps its client without an unhandled rejection', async () => {
+ const fake = fakeHttp();
+ const primary = new Error('heartbeat assertion');
+ let pending;
+ const chunks = [];
+ const result = await capture(() => withResourceScope(async resources => {
+ pending = request(1, 'GET', '/synthetic', { resources, transport: fake.transport, onData: chunk => chunks.push(chunk.toString()) });
+ fake.respond();
+ fake.response.emit('data', Buffer.from(' '));
+ throw primary;
+ }));
+ assert.strictEqual(result.error, primary);
+ assert.deepStrictEqual(chunks, [' ']);
+ assert.deepStrictEqual(fake.stages, ['response', 'request']);
+ assert.strictEqual((await capture(() => pending)).threw, true);
+ });
+ await test('request setup failure after acquisition closes its client and keeps the original error', async () => {
+ const fake = fakeHttp();
+ const primary = Object.freeze(new Error('write failed'));
+ fake.request.write = () => { throw primary; };
+ const result = await capture(() => withResourceScope(resources => request(1, 'POST', '/synthetic', {
+ body: {}, resources, transport: fake.transport,
+ })));
+ assert.strictEqual(result.error, primary);
+ assert.deepStrictEqual(fake.stages, ['request']);
+ });
+}
+
async function main() {
console.log('\n=== Testing plan-canvas server ===\n');
@@ -759,425 +936,430 @@ async function main() {
await artifactSecurityTests(test);
await artifactRaceTests(test);
await fixtureIsolationTests(test);
+ await integrationCleanupTests(test);
if (process.argv.includes('--artifact-security-only')) {
printResults(suite.results);
return;
}
- const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-canvas-server-'));
- const artifact = path.join(tmp, 'demo.plan.md');
- fs.writeFileSync(artifact, '# Plan: Demo\n\n## Files to Change\n\n| File | Action |\n|---|---|\n| `a.js` | UPDATE |\n');
- const htmlArtifact = path.join(tmp, 'report.html');
- fs.writeFileSync(htmlArtifact, '<!DOCTYPE html><html><body><h1>Report</h1></body></html>');
- fs.writeFileSync(path.join(tmp, 'style.css'), 'body { color: red }');
- const outsideDir = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-canvas-outside-'));
- fs.writeFileSync(path.join(outsideDir, 'secret.txt'), 'secret');
-
- const store = createSessionStore({ stateDir: path.join(tmp, 'state') });
- let idleFired = false;
- const canvas = createPlanCanvasServer({
- store,
- version: '9.9.9-test',
- heartbeatMs: 25,
- idleTimeoutMs: 0,
- onIdleShutdown: () => {
- idleFired = true;
- }
- });
- const { port } = await canvas.listen(0);
-
- let key = null;
- let htmlKey = null;
+ await withResourceScope(async resources => {
+ const integrationTest = (name, callback) => test(name, () => withResourceScope(owned => callback({
+ request: (port, method, requestPath, options = {}) => request(port, method, requestPath, { ...options, resources: owned }),
+ openSse: (port, key) => openSse(port, key, { resources: owned }),
+ ownServer: canvas => owned.server(() => canvas.close()),
+ })));
+ const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-canvas-server-'));
+ resources.root(() => fs.rmSync(tmp, { recursive: true, force: true }));
+ const artifact = path.join(tmp, 'demo.plan.md');
+ fs.writeFileSync(artifact, '# Plan: Demo\n\n## Files to Change\n\n| File | Action |\n|---|---|\n| `a.js` | UPDATE |\n');
+ const htmlArtifact = path.join(tmp, 'report.html');
+ fs.writeFileSync(htmlArtifact, '<!DOCTYPE html><html><body><h1>Report</h1></body></html>');
+ fs.writeFileSync(path.join(tmp, 'style.css'), 'body { color: red }');
+ const outsideDir = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-canvas-outside-'));
+ resources.root(() => fs.rmSync(outsideDir, { recursive: true, force: true }));
+ fs.writeFileSync(path.join(outsideDir, 'secret.txt'), 'secret');
+
+ const store = createSessionStore({ stateDir: path.join(tmp, 'state') });
+ let idleFired = false;
+ const canvas = createPlanCanvasServer({
+ store,
+ version: '9.9.9-test',
+ heartbeatMs: 25,
+ idleTimeoutMs: 0,
+ onIdleShutdown: () => {
+ idleFired = true;
+ }
+ });
+ const closeCanvas = resources.server(() => canvas.close());
+ const { port } = await canvas.listen(0);
- await test('GET /health identifies the app and version', async () => {
- const res = await request(port, 'GET', '/health');
- assert.deepStrictEqual(jsonBody(res), { ok: true, app: 'ecc-plan-canvas', version: '9.9.9-test' });
- });
+ let key = null;
+ let htmlKey = null;
- await test('requests with a non-loopback Host header are rejected', async () => {
- const res = await request(port, 'GET', '/health', { headers: { host: 'evil.example.com' } });
- assert.strictEqual(res.statusCode, 403);
- });
+ await integrationTest('GET /health identifies the app and version', async ({ request }) => {
+ const res = await request(port, 'GET', '/health');
+ assert.deepStrictEqual(jsonBody(res), { ok: true, app: 'ecc-plan-canvas', version: '9.9.9-test' });
+ });
- await test('requests with a cross-site Origin are rejected', async () => {
- const res = await request(port, 'POST', '/shutdown', { headers: { origin: 'https://evil.example.com' } });
- assert.strictEqual(res.statusCode, 403);
- });
+ await integrationTest('requests with a non-loopback Host header are rejected', async ({ request }) => {
+ const res = await request(port, 'GET', '/health', { headers: { host: 'evil.example.com' } });
+ assert.strictEqual(res.statusCode, 403);
+ });
- await test('POST /api/sessions opens a session for an existing artifact', async () => {
- const res = await request(port, 'POST', '/api/sessions', { body: { file: artifact } });
- assert.strictEqual(res.statusCode, 200);
- const body = jsonBody(res);
- assert.strictEqual(body.status, 'open');
- assert.match(body.key, /^[a-f0-9]{12}$/);
- key = body.key;
- });
+ await integrationTest('requests with a cross-site Origin are rejected', async ({ request }) => {
+ const res = await request(port, 'POST', '/shutdown', { headers: { origin: 'https://evil.example.com' } });
+ assert.strictEqual(res.statusCode, 403);
+ });
- await test('POST /api/sessions 404s for a missing artifact', async () => {
- const res = await request(port, 'POST', '/api/sessions', { body: { file: path.join(tmp, 'nope.md') } });
- assert.strictEqual(res.statusCode, 404);
- });
+ await integrationTest('POST /api/sessions opens a session for an existing artifact', async ({ request }) => {
+ const res = await request(port, 'POST', '/api/sessions', { body: { file: artifact } });
+ assert.strictEqual(res.statusCode, 200);
+ const body = jsonBody(res);
+ assert.strictEqual(body.status, 'open');
+ assert.match(body.key, /^[a-f0-9]{12}$/);
+ key = body.key;
+ });
- await test('GET /canvas/:key serves the ECC chrome with CSP', async () => {
- const res = await request(port, 'GET', `/canvas/${key}`);
- assert.strictEqual(res.statusCode, 200);
- assert.ok(res.headers['content-security-policy'].includes("default-src 'self'"));
- assert.ok(res.body.includes('Plan Canvas'));
- assert.ok(res.body.includes('pc-session'));
- assert.ok(res.body.includes('Approve plan'));
- assert.ok(res.body.includes('sandbox="allow-scripts allow-forms allow-popups"'));
- });
+ await integrationTest('POST /api/sessions 404s for a missing artifact', async ({ request }) => {
+ const res = await request(port, 'POST', '/api/sessions', { body: { file: path.join(tmp, 'nope.md') } });
+ assert.strictEqual(res.statusCode, 404);
+ });
- await test('markdown artifacts render in the ECC plan template with the SDK', async () => {
- const res = await request(port, 'GET', `/artifact/${key}/`);
- assert.strictEqual(res.statusCode, 200);
- assert.ok(res.body.includes('<h1 id="plan-demo">'));
- assert.ok(res.body.includes('<table>'));
- assert.ok(res.body.includes('<script src="/sdk.js">'));
- assert.strictEqual(res.headers['content-security-policy'], 'sandbox allow-scripts allow-forms allow-popups');
- // No diagram in this plan → no Mermaid loader shipped.
- assert.ok(!res.body.includes('mermaid.run'));
- });
+ await integrationTest('GET /canvas/:key serves the ECC chrome with CSP', async ({ request }) => {
+ const res = await request(port, 'GET', `/canvas/${key}`);
+ assert.strictEqual(res.statusCode, 200);
+ assert.ok(res.headers['content-security-policy'].includes("default-src 'self'"));
+ assert.ok(res.body.includes('Plan Canvas'));
+ assert.ok(res.body.includes('pc-session'));
+ assert.ok(res.body.includes('Approve plan'));
+ assert.ok(res.body.includes('sandbox="allow-scripts allow-forms allow-popups"'));
+ });
- await test('a plan containing ```mermaid serves the themed Mermaid loader', async () => {
- const diagram = path.join(tmp, 'flow.plan.md');
- fs.writeFileSync(diagram, '# Flow\n\n```mermaid\nflowchart LR\n A --> B\n```\n');
- const opened = jsonBody(await request(port, 'POST', '/api/sessions', { body: { file: diagram } }));
- const res = await request(port, 'GET', `/artifact/${opened.key}/`);
- assert.ok(res.body.includes('<pre class="mermaid">'), 'diagram container present');
- assert.ok(res.body.includes('mermaid.run'), 'loader injected');
- assert.ok(res.body.includes("securityLevel: 'strict'"), 'sanitizing config present');
- await request(port, 'POST', '/api/end', { body: { file: diagram } });
- });
+ await integrationTest('markdown artifacts render in the ECC plan template with the SDK', async ({ request }) => {
+ const res = await request(port, 'GET', `/artifact/${key}/`);
+ assert.strictEqual(res.statusCode, 200);
+ assert.ok(res.body.includes('<h1 id="plan-demo">'));
+ assert.ok(res.body.includes('<table>'));
+ assert.ok(res.body.includes('<script src="/sdk.js">'));
+ assert.strictEqual(res.headers['content-security-policy'], 'sandbox allow-scripts allow-forms allow-popups');
+ // No diagram in this plan → no Mermaid loader shipped.
+ assert.ok(!res.body.includes('mermaid.run'));
+ });
- await test('HTML artifacts pass through with the SDK injected before </body>', async () => {
- const open = await request(port, 'POST', '/api/sessions', { body: { file: htmlArtifact } });
- htmlKey = jsonBody(open).key;
- const res = await request(port, 'GET', `/artifact/${htmlKey}/`);
- assert.ok(res.body.includes('<h1>Report</h1>'));
- assert.ok(res.body.includes('<script src="/sdk.js"></script>\n</body>'));
- });
+ await integrationTest('a plan containing ```mermaid serves the themed Mermaid loader', async ({ request }) => {
+ const diagram = path.join(tmp, 'flow.plan.md');
+ fs.writeFileSync(diagram, '# Flow\n\n```mermaid\nflowchart LR\n A --> B\n```\n');
+ const opened = jsonBody(await request(port, 'POST', '/api/sessions', { body: { file: diagram } }));
+ const res = await request(port, 'GET', `/artifact/${opened.key}/`);
+ assert.ok(res.body.includes('<pre class="mermaid">'), 'diagram container present');
+ assert.ok(res.body.includes('mermaid.run'), 'loader injected');
+ assert.ok(res.body.includes("securityLevel: 'strict'"), 'sanitizing config present');
+ await request(port, 'POST', '/api/end', { body: { file: diagram } });
+ });
- await test('sibling assets are served, traversal is blocked', async () => {
- const ok = await request(port, 'GET', `/artifact/${key}/style.css`);
- assert.strictEqual(ok.statusCode, 200);
- assert.ok(ok.body.includes('color: red'));
- const escape = await request(port, 'GET', `/artifact/${key}/..%2F${path.basename(outsideDir)}%2Fsecret.txt`);
- assert.strictEqual(escape.statusCode, 403);
- });
+ await integrationTest('HTML artifacts pass through with the SDK injected before </body>', async ({ request }) => {
+ const open = await request(port, 'POST', '/api/sessions', { body: { file: htmlArtifact } });
+ htmlKey = jsonBody(open).key;
+ const res = await request(port, 'GET', `/artifact/${htmlKey}/`);
+ assert.ok(res.body.includes('<h1>Report</h1>'));
+ assert.ok(res.body.includes('<script src="/sdk.js"></script>\n</body>'));
+ });
- await test('artifact responses carry a sandbox CSP (direct-navigation hardening)', async () => {
- const md = await request(port, 'GET', `/artifact/${key}/`);
- assert.strictEqual(md.statusCode, 200);
- assert.strictEqual(md.headers['content-security-policy'], 'sandbox allow-scripts allow-forms allow-popups');
- const html = await request(port, 'GET', `/artifact/${htmlKey}/`);
- assert.strictEqual(html.statusCode, 200);
- assert.strictEqual(html.headers['content-security-policy'], 'sandbox allow-scripts allow-forms allow-popups');
- });
+ await integrationTest('sibling assets are served, traversal is blocked', async ({ request }) => {
+ const ok = await request(port, 'GET', `/artifact/${key}/style.css`);
+ assert.strictEqual(ok.statusCode, 200);
+ assert.ok(ok.body.includes('color: red'));
+ const escape = await request(port, 'GET', `/artifact/${key}/..%2F${path.basename(outsideDir)}%2Fsecret.txt`);
+ assert.strictEqual(escape.statusCode, 403);
+ });
- await test('missing-artifact 404 escapes the file path', async () => {
- // Quotes and ampersands are escapable on every platform (Windows
- // rejects < > in filenames, so angle brackets stay out of fixtures).
- const evilFile = path.join(tmp, `evil'b&xss.plan.md`);
- fs.writeFileSync(evilFile, '# Evil\n');
- const opened = jsonBody(await request(port, 'POST', '/api/sessions', { body: { file: evilFile } }));
- fs.rmSync(evilFile);
- const res = await request(port, 'GET', `/artifact/${opened.key}/`);
- assert.strictEqual(res.statusCode, 404);
- assert.ok(!res.body.includes(`evil'b&xss`), 'raw filename must not appear in the 404 page');
- assert.ok(res.body.includes('evil&#39;b&amp;xss'), 'filename must be HTML-escaped in the 404 page');
- });
+ await integrationTest('artifact responses carry a sandbox CSP (direct-navigation hardening)', async ({ request }) => {
+ const md = await request(port, 'GET', `/artifact/${key}/`);
+ assert.strictEqual(md.statusCode, 200);
+ assert.strictEqual(md.headers['content-security-policy'], 'sandbox allow-scripts allow-forms allow-popups');
+ const html = await request(port, 'GET', `/artifact/${htmlKey}/`);
+ assert.strictEqual(html.statusCode, 200);
+ assert.strictEqual(html.headers['content-security-policy'], 'sandbox allow-scripts allow-forms allow-popups');
+ });
- await test('symlinked sibling assets escaping the artifact dir are blocked', async () => {
- createTestSymlink(path.join(outsideDir, 'secret.txt'), path.join(tmp, 'evil-link.txt'));
- createTestSymlink(path.join(tmp, 'style.css'), path.join(tmp, 'ok-link.css'));
- const blocked = await request(port, 'GET', `/artifact/${key}/evil-link.txt`);
- assert.strictEqual(blocked.statusCode, 403);
- const allowed = await request(port, 'GET', `/artifact/${key}/ok-link.css`);
- assert.strictEqual(allowed.statusCode, 200);
- assert.ok(allowed.body.includes('color: red'));
- });
+ await integrationTest('missing-artifact 404 escapes the file path', async ({ request }) => {
+ // Quotes and ampersands are escapable on every platform (Windows
+ // rejects < > in filenames, so angle brackets stay out of fixtures).
+ const evilFile = path.join(tmp, `evil'b&xss.plan.md`);
+ fs.writeFileSync(evilFile, '# Evil\n');
+ const opened = jsonBody(await request(port, 'POST', '/api/sessions', { body: { file: evilFile } }));
+ fs.rmSync(evilFile);
+ const res = await request(port, 'GET', `/artifact/${opened.key}/`);
+ assert.strictEqual(res.statusCode, 404);
+ assert.ok(!res.body.includes(`evil'b&xss`), 'raw filename must not appear in the 404 page');
+ assert.ok(res.body.includes('evil&#39;b&amp;xss'), 'filename must be HTML-escaped in the 404 page');
+ });
- await test('served HTML siblings carry the sandbox CSP', async () => {
- fs.writeFileSync(path.join(tmp, 'note.html'), '<!DOCTYPE html><html><body><p>hi</p></body></html>');
- const res = await request(port, 'GET', `/artifact/${key}/note.html`);
- assert.strictEqual(res.statusCode, 200);
- assert.strictEqual(res.headers['content-security-policy'], 'sandbox allow-scripts allow-forms allow-popups');
- });
+ await integrationTest('symlinked sibling assets escaping the artifact dir are blocked', async ({ request }) => {
+ createTestSymlink(path.join(outsideDir, 'secret.txt'), path.join(tmp, 'evil-link.txt'));
+ createTestSymlink(path.join(tmp, 'style.css'), path.join(tmp, 'ok-link.css'));
+ const blocked = await request(port, 'GET', `/artifact/${key}/evil-link.txt`);
+ assert.strictEqual(blocked.statusCode, 403);
+ const allowed = await request(port, 'GET', `/artifact/${key}/ok-link.css`);
+ assert.strictEqual(allowed.statusCode, 200);
+ assert.ok(allowed.body.includes('color: red'));
+ });
- await test('symlinked assets take their MIME from the link name', async () => {
- fs.writeFileSync(path.join(tmp, 'realfile'), 'body { color: blue }');
- createTestSymlink(path.join(tmp, 'realfile'), path.join(tmp, 'theme.css'));
- const res = await request(port, 'GET', `/artifact/${key}/theme.css`);
- assert.strictEqual(res.statusCode, 200);
- assert.ok(String(res.headers['content-type']).startsWith('text/css'));
- });
+ await integrationTest('served HTML siblings carry the sandbox CSP', async ({ request }) => {
+ fs.writeFileSync(path.join(tmp, 'note.html'), '<!DOCTYPE html><html><body><p>hi</p></body></html>');
+ const res = await request(port, 'GET', `/artifact/${key}/note.html`);
+ assert.strictEqual(res.statusCode, 200);
+ assert.strictEqual(res.headers['content-security-policy'], 'sandbox allow-scripts allow-forms allow-popups');
+ });
- await test('static chrome assets are served', async () => {
- for (const asset of ['/canvas.css', '/client.js', '/sdk.js']) {
- const res = await request(port, 'GET', asset);
- assert.strictEqual(res.statusCode, 200, `${asset} should be 200`);
- }
- });
+ await integrationTest('symlinked assets take their MIME from the link name', async ({ request }) => {
+ fs.writeFileSync(path.join(tmp, 'realfile'), 'body { color: blue }');
+ createTestSymlink(path.join(tmp, 'realfile'), path.join(tmp, 'theme.css'));
+ const res = await request(port, 'GET', `/artifact/${key}/theme.css`);
+ assert.strictEqual(res.statusCode, 200);
+ assert.ok(String(res.headers['content-type']).startsWith('text/css'));
+ });
- await test('await with timeoutMs returns waiting when idle', async () => {
- const res = await request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}&timeoutMs=50`);
- assert.strictEqual(jsonBody(res).status, 'waiting');
- });
+ await integrationTest('static chrome assets are served', async ({ request }) => {
+ for (const asset of ['/canvas.css', '/client.js', '/sdk.js']) {
+ const res = await request(port, 'GET', asset);
+ assert.strictEqual(res.statusCode, 200, `${asset} should be 200`);
+ }
+ });
- await test('await returns missing for files without a session', async () => {
- const res = await request(port, 'GET', `/api/await?file=${encodeURIComponent(path.join(tmp, 'other.md'))}`);
- assert.strictEqual(jsonBody(res).status, 'missing');
- });
+ await integrationTest('await with timeoutMs returns waiting when idle', async ({ request }) => {
+ const res = await request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}&timeoutMs=50`);
+ assert.strictEqual(jsonBody(res).status, 'waiting');
+ });
- await test('browser feedback wakes a blocking await; presence transitions', async () => {
- const sse = openSse(port, key);
- await sse.ready;
- const awaitPromise = request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}`);
- await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'listening'));
-
- const post = await request(port, 'POST', `/api/session/${key}/feedback`, {
- body: {
- items: [
- { kind: 'annotation', text: 'tighten this', anchor: { selector: 'h2:nth-of-type(1)', tag: 'h2', snippet: 'Files to Change' } },
- { kind: 'verdict', verdict: 'request-changes' }
- ]
- }
+ await integrationTest('await returns missing for files without a session', async ({ request }) => {
+ const res = await request(port, 'GET', `/api/await?file=${encodeURIComponent(path.join(tmp, 'other.md'))}`);
+ assert.strictEqual(jsonBody(res).status, 'missing');
});
- assert.strictEqual(jsonBody(post).accepted, 2);
- const result = jsonBody(await awaitPromise);
- assert.strictEqual(result.status, 'feedback');
- assert.strictEqual(result.items.length, 2);
- assert.strictEqual(result.items[0].anchor.selector, 'h2:nth-of-type(1)');
- assert.strictEqual(result.items[1].verdict, 'request-changes');
+ await integrationTest('browser feedback wakes a blocking await; presence transitions', async ({ request, openSse }) => {
+ const sse = openSse(port, key);
+ await sse.ready;
+ const awaitPromise = request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}`);
+ await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'listening'));
+
+ const post = await request(port, 'POST', `/api/session/${key}/feedback`, {
+ body: {
+ items: [
+ { kind: 'annotation', text: 'tighten this', anchor: { selector: 'h2:nth-of-type(1)', tag: 'h2', snippet: 'Files to Change' } },
+ { kind: 'verdict', verdict: 'request-changes' }
+ ]
+ }
+ });
+ assert.strictEqual(jsonBody(post).accepted, 2);
- await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'thinking'));
- await waitFor(() => sse.received.some(e => e.event === 'chat-sync' && e.data.chat.length === 2));
- sse.close();
- });
+ const result = jsonBody(await awaitPromise);
+ assert.strictEqual(result.status, 'feedback');
+ assert.strictEqual(result.items.length, 2);
+ assert.strictEqual(result.items[0].anchor.selector, 'h2:nth-of-type(1)');
+ assert.strictEqual(result.items[1].verdict, 'request-changes');
- // Regression: feedback sent with nobody parked on `await` used to leave the
- // pill claiming "agent working" while the message sat undelivered forever.
- await test('feedback with no listener reports queued, not working', async () => {
- const queuedArtifact = path.join(tmp, 'queued.plan.md');
- fs.writeFileSync(queuedArtifact, '# Plan: Queued\n');
- const opened = jsonBody(await request(port, 'POST', '/api/sessions', { body: { file: queuedArtifact } }));
- const sse = openSse(port, opened.key);
- await sse.ready;
- await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'waiting'));
-
- const post = await request(port, 'POST', `/api/session/${opened.key}/feedback`, {
- body: { items: [{ kind: 'chat', text: 'anyone there?' }] }
+ await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'thinking'));
+ await waitFor(() => sse.received.some(e => e.event === 'chat-sync' && e.data.chat.length === 2));
+ await sse.close();
});
- assert.strictEqual(jsonBody(post).presence, 'queued');
- assert.strictEqual(canvas.presenceFor(opened.key), 'queued');
- await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'queued'));
-
- // Draining it hands the batch over and flips the indicator to thinking.
- const drained = jsonBody(await request(port, 'GET', `/api/await?key=${opened.key}&timeoutMs=0`));
- assert.strictEqual(drained.status, 'feedback');
- assert.strictEqual(canvas.presenceFor(opened.key), 'thinking');
- sse.close();
- });
- await test('typing endpoint drives the indicator and reply clears it', async () => {
- const typingArtifact = path.join(tmp, 'typing.plan.md');
- fs.writeFileSync(typingArtifact, '# Plan: Typing\n');
- const opened = jsonBody(await request(port, 'POST', '/api/sessions', { body: { file: typingArtifact } }));
- const sse = openSse(port, opened.key);
- await sse.ready;
+ // Regression: feedback sent with nobody parked on `await` used to leave the
+ // pill claiming "agent working" while the message sat undelivered forever.
+ await integrationTest('feedback with no listener reports queued, not working', async ({ request, openSse }) => {
+ const queuedArtifact = path.join(tmp, 'queued.plan.md');
+ fs.writeFileSync(queuedArtifact, '# Plan: Queued\n');
+ const opened = jsonBody(await request(port, 'POST', '/api/sessions', { body: { file: queuedArtifact } }));
+ const sse = openSse(port, opened.key);
+ await sse.ready;
+ await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'waiting'));
+
+ const post = await request(port, 'POST', `/api/session/${opened.key}/feedback`, {
+ body: { items: [{ kind: 'chat', text: 'anyone there?' }] }
+ });
+ assert.strictEqual(jsonBody(post).presence, 'queued');
+ assert.strictEqual(canvas.presenceFor(opened.key), 'queued');
+ await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'queued'));
+
+ // Draining it hands the batch over and flips the indicator to thinking.
+ const drained = jsonBody(await request(port, 'GET', `/api/await?key=${opened.key}&timeoutMs=0`));
+ assert.strictEqual(drained.status, 'feedback');
+ assert.strictEqual(canvas.presenceFor(opened.key), 'thinking');
+ await sse.close();
+ });
- const typing = await request(port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'typing' } });
- assert.strictEqual(jsonBody(typing).presence, 'typing');
- await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'typing'));
+ await integrationTest('typing endpoint drives the indicator and reply clears it', async ({ request, openSse }) => {
+ const typingArtifact = path.join(tmp, 'typing.plan.md');
+ fs.writeFileSync(typingArtifact, '# Plan: Typing\n');
+ const opened = jsonBody(await request(port, 'POST', '/api/sessions', { body: { file: typingArtifact } }));
+ const sse = openSse(port, opened.key);
+ await sse.ready;
- const thinking = await request(port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'thinking' } });
- assert.strictEqual(jsonBody(thinking).presence, 'thinking');
+ const typing = await request(port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'typing' } });
+ assert.strictEqual(jsonBody(typing).presence, 'typing');
+ await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'typing'));
- const bad = await request(port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'dancing' } });
- assert.strictEqual(bad.statusCode, 400);
+ const thinking = await request(port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'thinking' } });
+ assert.strictEqual(jsonBody(thinking).presence, 'thinking');
- // A landed reply must take the bubble down, not leave it spinning.
- await request(port, 'POST', `/api/session/${opened.key}/reply`, { body: { text: 'done' } });
- assert.strictEqual(canvas.presenceFor(opened.key), 'waiting');
- await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'waiting'));
- sse.close();
- });
+ const bad = await request(port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'dancing' } });
+ assert.strictEqual(bad.statusCode, 400);
- await test('thinking and typing states expire instead of sticking', async () => {
- const staleArtifact = path.join(tmp, 'stale.plan.md');
- fs.writeFileSync(staleArtifact, '# Plan: Stale\n');
- const staleStore = createSessionStore({ stateDir: path.join(tmp, 'stale-state') });
- const staleCanvas = createPlanCanvasServer({
- store: staleStore,
- version: '9.9.9-test',
- idleTimeoutMs: 0,
- thinkingStaleMs: 40,
- typingExpiryMs: 20,
- presenceSweepMs: 0
- });
- const bound = await staleCanvas.listen(0);
- const opened = jsonBody(await request(bound.port, 'POST', '/api/sessions', { body: { file: staleArtifact } }));
-
- await request(bound.port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'typing' } });
- assert.strictEqual(staleCanvas.presenceFor(opened.key), 'typing');
- await new Promise(resolve => setTimeout(resolve, 60));
- assert.strictEqual(staleCanvas.presenceFor(opened.key), 'waiting');
-
- // An abandoned agent decays to queued so the human is never told a
- // stalled session is still being worked on.
- await request(bound.port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'thinking' } });
- await request(bound.port, 'POST', `/api/session/${opened.key}/feedback`, {
- body: { items: [{ kind: 'chat', text: 'still there?' }] }
+ // A landed reply must take the bubble down, not leave it spinning.
+ await request(port, 'POST', `/api/session/${opened.key}/reply`, { body: { text: 'done' } });
+ assert.strictEqual(canvas.presenceFor(opened.key), 'waiting');
+ await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'waiting'));
+ await sse.close();
});
- assert.strictEqual(staleCanvas.presenceFor(opened.key), 'thinking');
- await new Promise(resolve => setTimeout(resolve, 60));
- assert.strictEqual(staleCanvas.presenceFor(opened.key), 'queued');
- await staleCanvas.close();
- });
- // The stuck pill only self-heals if the decay is pushed to an idle browser
- // that is not making any requests of its own.
- await test('presence sweep pushes the decayed state to an idle browser', async () => {
- const sweepArtifact = path.join(tmp, 'sweep.plan.md');
- fs.writeFileSync(sweepArtifact, '# Plan: Sweep\n');
- const sweepStore = createSessionStore({ stateDir: path.join(tmp, 'sweep-state') });
- const sweepCanvas = createPlanCanvasServer({
- store: sweepStore,
- version: '9.9.9-test',
- idleTimeoutMs: 0,
- thinkingStaleMs: 50,
- presenceSweepMs: 20
+ await integrationTest('thinking and typing states expire instead of sticking', async ({ request, ownServer }) => {
+ const staleArtifact = path.join(tmp, 'stale.plan.md');
+ fs.writeFileSync(staleArtifact, '# Plan: Stale\n');
+ const staleStore = createSessionStore({ stateDir: path.join(tmp, 'stale-state') });
+ const staleCanvas = createPlanCanvasServer({
+ store: staleStore,
+ version: '9.9.9-test',
+ idleTimeoutMs: 0,
+ thinkingStaleMs: 40,
+ typingExpiryMs: 20,
+ presenceSweepMs: 0
+ });
+ const closeStaleCanvas = ownServer(staleCanvas);
+ const bound = await staleCanvas.listen(0);
+ const opened = jsonBody(await request(bound.port, 'POST', '/api/sessions', { body: { file: staleArtifact } }));
+
+ await request(bound.port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'typing' } });
+ assert.strictEqual(staleCanvas.presenceFor(opened.key), 'typing');
+ await new Promise(resolve => setTimeout(resolve, 60));
+ assert.strictEqual(staleCanvas.presenceFor(opened.key), 'waiting');
+
+ // An abandoned agent decays to queued so the human is never told a
+ // stalled session is still being worked on.
+ await request(bound.port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'thinking' } });
+ await request(bound.port, 'POST', `/api/session/${opened.key}/feedback`, {
+ body: { items: [{ kind: 'chat', text: 'still there?' }] }
+ });
+ assert.strictEqual(staleCanvas.presenceFor(opened.key), 'thinking');
+ await new Promise(resolve => setTimeout(resolve, 60));
+ assert.strictEqual(staleCanvas.presenceFor(opened.key), 'queued');
+ await closeStaleCanvas();
});
- const bound = await sweepCanvas.listen(0);
- const opened = jsonBody(await request(bound.port, 'POST', '/api/sessions', { body: { file: sweepArtifact } }));
- const sse = openSse(bound.port, opened.key);
- await sse.ready;
- await request(bound.port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'thinking' } });
- await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'thinking'));
+ // The stuck pill only self-heals if the decay is pushed to an idle browser
+ // that is not making any requests of its own.
+ await integrationTest('presence sweep pushes the decayed state to an idle browser', async ({ request, openSse, ownServer }) => {
+ const sweepArtifact = path.join(tmp, 'sweep.plan.md');
+ fs.writeFileSync(sweepArtifact, '# Plan: Sweep\n');
+ const sweepStore = createSessionStore({ stateDir: path.join(tmp, 'sweep-state') });
+ const sweepCanvas = createPlanCanvasServer({
+ store: sweepStore,
+ version: '9.9.9-test',
+ idleTimeoutMs: 0,
+ thinkingStaleMs: 50,
+ presenceSweepMs: 20
+ });
+ const closeSweepCanvas = ownServer(sweepCanvas);
+ const bound = await sweepCanvas.listen(0);
+ const opened = jsonBody(await request(bound.port, 'POST', '/api/sessions', { body: { file: sweepArtifact } }));
+ const sse = openSse(bound.port, opened.key);
+ await sse.ready;
+
+ await request(bound.port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'thinking' } });
+ await waitFor(() => sse.received.some(e => e.event === 'presence' && e.data.state === 'thinking'));
+
+ const before = sse.received.length;
+ await waitFor(() =>
+ sse.received.slice(before).some(e => e.event === 'presence' && e.data.state === 'waiting')
+ );
+ await sse.close();
+ await closeSweepCanvas();
+ });
- const before = sse.received.length;
- await waitFor(() =>
- sse.received.slice(before).some(e => e.event === 'presence' && e.data.state === 'waiting')
- );
- sse.close();
- await sweepCanvas.close();
- });
+ await integrationTest('long-poll heartbeat whitespace arrives before the payload', async ({ request }) => {
+ const chunks = [];
+ const done = request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}`, {
+ onData: chunk => chunks.push(chunk.toString()),
+ });
+ // Heartbeats tick every 25ms in this test server; wait for a few first.
+ await waitFor(() => chunks.join('').length >= 3);
+ assert.ok(/^\s+$/.test(chunks.join('')), 'expected only whitespace before payload');
+ await request(port, 'POST', `/api/session/${key}/feedback`, { body: { items: [{ kind: 'chat', text: 'wake up' }] } });
+ await done;
+ const full = chunks.join('');
+ assert.strictEqual(JSON.parse(full.trim()).status, 'feedback');
+ });
- await test('long-poll heartbeat whitespace arrives before the payload', async () => {
- const chunks = [];
- const done = new Promise((resolve, reject) => {
- const req = http.get(
- { host: '127.0.0.1', port, path: `/api/await?file=${encodeURIComponent(artifact)}`, agent: false },
- res => {
- res.on('data', chunk => chunks.push(chunk.toString()));
- res.on('end', resolve);
- }
+ await integrationTest('agent reply lands in the chat via SSE chat-sync', async ({ request, openSse }) => {
+ const sse = openSse(port, key);
+ await sse.ready;
+ const res = await request(port, 'POST', `/api/session/${key}/reply`, { body: { text: 'reworked, please re-check' } });
+ assert.strictEqual(jsonBody(res).status, 'sent');
+ await waitFor(() =>
+ sse.received.some(
+ e => e.event === 'chat-sync' && e.data.chat.some(m => m.role === 'agent' && m.text.includes('reworked'))
+ )
);
- req.on('error', reject);
+ await sse.close();
});
- // Heartbeats tick every 25ms in this test server; wait for a few first.
- await waitFor(() => chunks.join('').length >= 3);
- assert.ok(/^\s+$/.test(chunks.join('')), 'expected only whitespace before payload');
- await request(port, 'POST', `/api/session/${key}/feedback`, { body: { items: [{ kind: 'chat', text: 'wake up' }] } });
- await done;
- const full = chunks.join('');
- assert.strictEqual(JSON.parse(full.trim()).status, 'feedback');
- });
-
- await test('agent reply lands in the chat via SSE chat-sync', async () => {
- const sse = openSse(port, key);
- await sse.ready;
- const res = await request(port, 'POST', `/api/session/${key}/reply`, { body: { text: 'reworked, please re-check' } });
- assert.strictEqual(jsonBody(res).status, 'sent');
- await waitFor(() =>
- sse.received.some(
- e => e.event === 'chat-sync' && e.data.chat.some(m => m.role === 'agent' && m.text.includes('reworked'))
- )
- );
- sse.close();
- });
- await test('live reload: editing the artifact emits an SSE reload event', async () => {
- const sse = openSse(port, key);
- await sse.ready;
- fs.appendFileSync(artifact, '\n## Addendum\n');
- await waitFor(() => sse.received.some(e => e.event === 'reload'), { timeoutMs: 4000 });
- sse.close();
- });
+ await integrationTest('live reload: editing the artifact emits an SSE reload event', async ({ openSse }) => {
+ const sse = openSse(port, key);
+ await sse.ready;
+ fs.appendFileSync(artifact, '\n## Addendum\n');
+ await waitFor(() => sse.received.some(e => e.event === 'reload'), { timeoutMs: 4000 });
+ await sse.close();
+ });
- await test('send-and-end delivers the final batch and ends the session', async () => {
- const awaitPromise = request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}`);
- await waitFor(() => canvas.presenceFor(key) === 'listening');
- await request(port, 'POST', `/api/session/${key}/feedback`, {
- body: { items: [{ kind: 'chat', text: 'looks good, wrapping up' }], endSession: true }
+ await integrationTest('send-and-end delivers the final batch and ends the session', async ({ request }) => {
+ const awaitPromise = request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}`);
+ await waitFor(() => canvas.presenceFor(key) === 'listening');
+ await request(port, 'POST', `/api/session/${key}/feedback`, {
+ body: { items: [{ kind: 'chat', text: 'looks good, wrapping up' }], endSession: true }
+ });
+ const result = jsonBody(await awaitPromise);
+ assert.strictEqual(result.status, 'feedback');
+ assert.strictEqual(result.sessionEnded, true);
+ assert.strictEqual(result.endedBy, 'user');
+ const after = await request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}&timeoutMs=0`);
+ assert.strictEqual(jsonBody(after).status, 'ended');
});
- const result = jsonBody(await awaitPromise);
- assert.strictEqual(result.status, 'feedback');
- assert.strictEqual(result.sessionEnded, true);
- assert.strictEqual(result.endedBy, 'user');
- const after = await request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}&timeoutMs=0`);
- assert.strictEqual(jsonBody(after).status, 'ended');
- });
- await test('user-ended sessions return 409 on plain reopen, open with reopen:true', async () => {
- const refused = await request(port, 'POST', '/api/sessions', { body: { file: artifact } });
- assert.strictEqual(refused.statusCode, 409);
- assert.strictEqual(jsonBody(refused).status, 'user-ended');
- const forced = await request(port, 'POST', '/api/sessions', { body: { file: artifact, reopen: true } });
- assert.strictEqual(forced.statusCode, 200);
- });
+ await integrationTest('user-ended sessions return 409 on plain reopen, open with reopen:true', async ({ request }) => {
+ const refused = await request(port, 'POST', '/api/sessions', { body: { file: artifact } });
+ assert.strictEqual(refused.statusCode, 409);
+ assert.strictEqual(jsonBody(refused).status, 'user-ended');
+ const forced = await request(port, 'POST', '/api/sessions', { body: { file: artifact, reopen: true } });
+ assert.strictEqual(forced.statusCode, 200);
+ });
- await test('agent end via POST /api/end allows plain reopen', async () => {
- const res = await request(port, 'POST', '/api/end', { body: { file: artifact } });
- assert.strictEqual(jsonBody(res).endedBy, 'agent');
- const reopened = await request(port, 'POST', '/api/sessions', { body: { file: artifact } });
- assert.strictEqual(reopened.statusCode, 200);
- });
+ await integrationTest('agent end via POST /api/end allows plain reopen', async ({ request }) => {
+ const res = await request(port, 'POST', '/api/end', { body: { file: artifact } });
+ assert.strictEqual(jsonBody(res).endedBy, 'agent');
+ const reopened = await request(port, 'POST', '/api/sessions', { body: { file: artifact } });
+ assert.strictEqual(reopened.statusCode, 200);
+ });
- await test('feedback on an ended session is refused with 409', async () => {
- await request(port, 'POST', `/api/end`, { body: { file: htmlArtifact } });
- const res = await request(port, 'POST', `/api/session/${htmlKey}/feedback`, {
- body: { items: [{ kind: 'chat', text: 'too late' }] }
+ await integrationTest('feedback on an ended session is refused with 409', async ({ request }) => {
+ await request(port, 'POST', `/api/end`, { body: { file: htmlArtifact } });
+ const res = await request(port, 'POST', `/api/session/${htmlKey}/feedback`, {
+ body: { items: [{ kind: 'chat', text: 'too late' }] }
+ });
+ assert.strictEqual(res.statusCode, 409);
});
- assert.strictEqual(res.statusCode, 409);
- });
- await test('GET / lists sessions in the ECC shell', async () => {
- const res = await request(port, 'GET', '/');
- assert.ok(res.body.includes('Plan Canvas sessions'));
- assert.ok(res.body.includes('demo.plan.md'));
- });
+ await integrationTest('GET / lists sessions in the ECC shell', async ({ request }) => {
+ const res = await request(port, 'GET', '/');
+ assert.ok(res.body.includes('Plan Canvas sessions'));
+ assert.ok(res.body.includes('demo.plan.md'));
+ });
- await test('POST /shutdown triggers the shutdown callback', async () => {
- const res = await request(port, 'POST', '/shutdown');
- assert.strictEqual(jsonBody(res).status, 'stopping');
- await waitFor(() => idleFired);
- });
+ await integrationTest('POST /shutdown triggers the shutdown callback', async ({ request }) => {
+ const res = await request(port, 'POST', '/shutdown');
+ assert.strictEqual(jsonBody(res).status, 'stopping');
+ await waitFor(() => idleFired);
+ });
- await test('close() settles a held long-poll instead of hanging', async () => {
- await request(port, 'POST', '/api/sessions', { body: { file: artifact, reopen: true } });
- const held = request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}`);
- await waitFor(() => canvas.presenceFor(store.findByFile(artifact).key) === 'listening');
- await canvas.close();
- const result = jsonBody(await held);
- assert.strictEqual(result.status, 'waiting');
- assert.ok(result.note.includes('shutting down'));
+ await integrationTest('close() settles a held long-poll instead of hanging', async ({ request }) => {
+ await request(port, 'POST', '/api/sessions', { body: { file: artifact, reopen: true } });
+ const held = request(port, 'GET', `/api/await?file=${encodeURIComponent(artifact)}`);
+ await waitFor(() => canvas.presenceFor(store.findByFile(artifact).key) === 'listening');
+ await closeCanvas();
+ const result = jsonBody(await held);
+ assert.strictEqual(result.status, 'waiting');
+ assert.ok(result.note.includes('shutting down'));
+ });
});
- fs.rmSync(tmp, { recursive: true, force: true });
- fs.rmSync(outsideDir, { recursive: true, force: true });
-
console.log('\n' + '='.repeat(40));
printResults(suite.results);
console.log('='.repeat(40));
}
+// Stay nonzero if setup or cleanup stalls without a live handle or summary.
+process.exitCode = 1;
main().catch(err => {
- console.error(err);
+ console.error(failureText(err));
console.log('Passed: 0');
console.log('Failed: 1');
- process.exit(1);
+ process.exitCode = 1;
});