gcf-board 0.2.16 → 0.2.17

package/dist/server/app.js

@@ -90,8 +90,13 @@ async function sendPage(res, web, pathname) {
 }
 export function createApp(o) {
     const watchers = new Map();
+    let closed = false;
     const watchAll = async () => {
-        for (const p of await listProjects())
+        const projects = await listProjects();
+        // A watcher set up after the server closed would keep the process alive.
+        if (closed)
+            return;
+        for (const p of projects)
             if (!watchers.has(p.name))
                 watchers.set(p.name, watchProject(p));
     };
@@ -303,15 +308,18 @@ export function createApp(o) {
     const server = createServer((req, res) => {
         handle(req, res).catch((e) => {
             if (res.headersSent)
-                return res.end();
-            send(res, e instanceof HttpError ? e.status : 500, { error: e.message });
+                res.end();
+            else
+                send(res, e instanceof HttpError ? e.status : 500, { error: e.message });
         });
     });
     // A broken projects.json must not take the server down: the page shows the error instead.
     server.on('listening', () => watchAll().catch((e) => console.error(`gcf-board: ${e.message}`)));
     server.on('close', () => {
+        closed = true;
         for (const stop of watchers.values())
             stop();
+        watchers.clear();
     });
     return server;
 }

package/dist/server/auth.js

@@ -1,7 +1,8 @@
 // The board starts agents that commit and push: whoever talks to it runs code on this machine.
-// It listens on 127.0.0.1 only, and every request needs the token printed at start (kept in a
-// cookie after the first visit). Host and Origin are checked too: a page in another tab can
-// reach 127.0.0.1 (DNS rebinding, a cross-site POST), but it cannot fake those headers.
+// It listens on 127.0.0.1 only. The URL printed at start carries the token; that visit gets a
+// session cookie (one per server process, never the token itself), and every request needs it.
+// Host and Origin are checked too: a page in another tab can reach 127.0.0.1 (DNS rebinding, a
+// cross-site POST), but it cannot fake those headers.
 import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { mkdir, readFile } from 'node:fs/promises';

package/dist/server/cli.js

@@ -71,6 +71,8 @@ export function runCli(entry, cwd, args, timeoutMs = 120_000) {
                 spawnSync('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
             else
                 child.kill();
+            // A grandchild holding the pipes keeps close from firing: the answer does not wait for it.
+            setTimeout(() => resolve({ ok: false, code: null, out, err }), 5_000).unref();
         }, timeoutMs);
         child.on('error', (e) => {
             clearTimeout(timer);

package/dist/server/runs.js

@@ -127,8 +127,9 @@ function schedule(run, at) {
         catch (e) {
             // The board's own run of an item takes it out of the schedule first, so this is rare;
             // the queue still goes on.
+            const why = e instanceof Error ? e.message : String(e);
             if (s)
-                trace(project, 'resume-failed', `${s.run.ids.join(', ')}: ${e.message}`);
+                trace(project, 'resume-failed', `${s.run.ids.join(', ')}: ${why}`);
             advance(project);
         }
         broadcast({ type: 'board', project });
@@ -142,9 +143,7 @@ function schedule(run, at) {
  * report.
  */
 function limited(run, result) {
-    const items = result
-        ?.items;
-    const hit = (items ?? []).filter((i) => i.limit_resets !== undefined);
+    const hit = (result?.items ?? []).filter((i) => i.limit_resets !== undefined);
     if (!hit.length)
         return '';
     const project = run.p.name;
@@ -204,6 +203,34 @@ export function stalled(ok, result) {
     const items = result?.items ?? [];
     return (items.length > 0 && items.every((i) => /another run works in the main/.test(i.error ?? '')));
 }
+/**
+ * The harness report a run printed, or null for none. A report of another shape counts as none:
+ * the close listener that reads it would throw, and take the server down with it.
+ */
+export function harnessReport(out) {
+    let r;
+    try {
+        r = JSON.parse(out);
+    }
+    catch {
+        // No report: the error says why.
+        return null;
+    }
+    if (typeof r !== 'object' || r === null || Array.isArray(r))
+        return null;
+    const { gate, items, orphans } = r;
+    const list = (v) => v === undefined || (Array.isArray(v) && v.every(isItem));
+    return (gate === undefined || typeof gate === 'string') && list(items) && list(orphans)
+        ? r
+        : null;
+}
+// The fields read as more than text: the id, and the reset a resume is scheduled at.
+function isItem(i) {
+    if (typeof i !== 'object' || i === null)
+        return false;
+    const { id, limit_resets: resets } = i;
+    return typeof id === 'string' && (resets == null || typeof resets === 'string');
+}
 function spawnRun(q, mode) {
     const { entry, p, ids } = q;
     const run = { project: p.name, ids, started: new Date().toISOString(), mode };
@@ -224,13 +251,7 @@ function spawnRun(q, mode) {
         // A spawn that fails fires both error and close: one end only.
         if (!active.delete(run))
             return;
-        let result = null;
-        try {
-            result = JSON.parse(out);
-        }
-        catch {
-            // No report: the error says why.
-        }
+        const result = harnessReport(out);
         // A run of a project removed meanwhile only reports: it pauses and schedules nothing.
         const kept = !forgotten.has(run);
         const stop = kept && mode === 'main' && queues.get(p.name)?.length && stalled(ok, result);
@@ -244,8 +265,7 @@ function spawnRun(q, mode) {
                 (stop ? 'the queue is paused: fix the cause, then resume it on the board' : '');
         if (stop)
             trace(p.name, 'queue-paused', `after ${ids.join(', ')}: ${note}`);
-        const handed = result?.items;
-        for (const i of handed ?? [])
+        for (const i of result?.items ?? [])
             if (kept && i.handoffs)
                 trace(p.name, 'handoff', `${i.id}: ${i.handoffs} context handoff(s) to a fresh session`);
         const brief = err && briefError(err);