gcf-board 0.2.16 → 0.2.18

package/README.md

@@ -52,6 +52,7 @@ It puts **GCF Board** on the desktop (Windows: a shortcut whose server console s
 - **Lessons** (core 0.7.10, harness 0.9.2): what got in an agent's way, asked at the end of each session, lands in the inbox with its kind (`tool`, `rules`, `framework`, `template`, `other`) and its item. The inbox filters them; a card shows `N lessons`, and the drawer lists the item's lessons with the inbox's buttons. A run's report line ends with `, N lessons`, and with `— code written outside aif-implement` when a session skipped that skill.
 - **Playtest**: `gcf playtest session` with the checklist grouped by subsystem; keep, tune or kill each item from the list. **Build** runs `dod.build`. A note goes to the inbox as `--source playtest`.
 - **Ended**: history (accepted) and graveyard (killed, dropped, won't-fix).
+- **Metrics**: `gcf-harness metrics --json` of the project — how many runs reached submit or close, what they cost, handoffs, plan checks, DoD attempts, guard firings, block reasons — and, with harness 0.9.5, the cost per item over all its runs and per week and day.
 
 The page updates by itself: the server watches each project's `gcf/` and `.gcf-session/runs/`.
 

package/dist/server/app.js

@@ -1,5 +1,6 @@
 // The board's HTTP server: the page, and an API that is a thin layer over `ai-factory gcf`.
-// Reads: projects, the board, a shown file, a run log, the playtest session. Writes: a project
+// Reads: projects, the board, a shown file, a run log, the playtest session, the run metrics
+// (`ai-factory gcf-harness metrics`). Writes: a project
 // on the board, a move, a run. Every write is a command of the framework.
 import { randomBytes } from 'node:crypto';
 import { createServer } from 'node:http';
@@ -90,8 +91,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));
     };
@@ -180,6 +186,14 @@ export function createApp(o) {
                 send(res, 200, jsonOf(r, 'gcf playtest session'));
             },
         ],
+        [
+            'GET',
+            /^\/api\/p\/([^/]+)\/metrics$/,
+            async (_req, res, m) => {
+                const r = await cli(await projectOf(m[1]), ['gcf-harness', 'metrics', '--json']);
+                send(res, 200, jsonOf(r, 'gcf-harness metrics'));
+            },
+        ],
         [
             // A build runs the project's own command: a write, so a POST with its Origin checked.
             'POST',
@@ -303,15 +317,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

@@ -43,11 +43,13 @@ function globalRoots() {
     return roots;
 }
 /**
- * The line of a refusal an operator reads: the core throws, and node prints the stack under
- * an `Error: <message>` line. Anything else is shown as it came.
+ * The refusal an operator reads: the core throws, and node prints the stack under an
+ * `Error: <message>` header, every line of the message (a git failure's cause comes after its
+ * first line). Anything else is shown as it came.
  */
 export function briefError(err) {
-    return err.match(/^\w*Error: (.+)$/m)?.[1].trim() ?? err.trim();
+    const m = err.match(/^\w*Error: ([\s\S]*?)\r?\n {4}at /m) ?? err.match(/^\w*Error: (.+)$/m);
+    return (m?.[1] ?? err).replace(/\r/g, '').trim();
 }
 /** Run `ai-factory <args>` in a project; a move can wait up to a minute on gcf's main lock. */
 export function runCli(entry, cwd, args, timeoutMs = 120_000) {
@@ -71,6 +73,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);