gcf-board 0.2.4 → 0.2.6

package/dist/server/app.js

@@ -7,10 +7,10 @@ import { existsSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { BOARD_SCHEMA } from '../shared/board.js';
-import { admit, COOKIE, hostAllowed, tokenInUrl } from './auth.js';
+import { admit, cookieName, hostAllowed, tokenInUrl } from './auth.js';
 import { briefError, runCli } from './cli.js';
-import { broadcast, subscribe, watchProject } from './events.js';
-import { followLog, readShown } from './files.js';
+import { broadcast, planRev, subscribe, watchProject } from './events.js';
+import { followLog, readShown, shownShape } from './files.js';
 import { HttpError } from './http-error.js';
 import { moveArgs, runIds } from './moves.js';
 import { addProject, listProjects, projectOf, removeProject } from './registry.js';
@@ -126,8 +126,10 @@ export function createApp(o) {
             /^\/api\/p\/([^/]+)\/board$/,
             async (_req, res, m) => {
                 const p = await projectOf(m[1]);
-                // The board's own runs ride along: what it started and what waits in its queue.
-                send(res, 200, { ...(await boardOf(p)), runs: runsOf(p.name) });
+                // The board's own runs ride along: what it started and what waits in its queue; and the
+                // count of plan writes, which tells the page an open plan's text changed.
+                const own = { runs: runsOf(p.name), plans_rev: planRev(p.name) };
+                send(res, 200, { ...(await boardOf(p)), ...own });
             },
         ],
         [
@@ -135,7 +137,12 @@ export function createApp(o) {
             /^\/api\/p\/([^/]+)\/file$/,
             async (_req, res, m, url) => {
                 const p = await projectOf(m[1]);
-                send(res, 200, { text: await readShown(p.path, url.searchParams.get('path') ?? '') });
+                const rel = url.searchParams.get('path') ?? '';
+                // A plan an item links (`plan:`) may lie anywhere in the project: the core names it.
+                const linked = !shownShape(rel) &&
+                    // A board the core cannot read links nothing: the path is refused, not a 500.
+                    (await boardOf(p).catch(() => ({ items: [] }))).items.some((i) => i.plan_file === rel);
+                send(res, 200, { text: await readShown(p.path, rel, linked) });
             },
         ],
         [
@@ -234,7 +241,7 @@ export function createApp(o) {
         const visit = req.method === 'GET' && !url.pathname.startsWith('/api/');
         if (visit && hostAllowed(req, o.port) && tokenInUrl(url, o.token)) {
             res.writeHead(302, {
-                'set-cookie': `${COOKIE}=${session}; HttpOnly; SameSite=Strict; Path=/`,
+                'set-cookie': `${cookieName(o.port)}=${session}; HttpOnly; SameSite=Strict; Path=/`,
                 // Always the root: a path like `//elsewhere` would send the browser off the board.
                 location: '/',
             });

package/dist/server/auth.js

@@ -8,7 +8,9 @@ import { mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { writeAtomic } from './atomic.js';
 import { homeDir } from './registry.js';
-export const COOKIE = 'gcf_board';
+// A browser keeps one cookie per name for all of 127.0.0.1: the port in the name lets two boards
+// on two ports stay signed in side by side.
+export const cookieName = (port) => `gcf_board_${port}`;
 // An empty or short token would let everyone in: such a file is replaced.
 const STRONG = /^[0-9a-f]{48}$/;
 /** The token of this machine's board: made once, kept in `~/.gcf/board-token`. */
@@ -23,10 +25,10 @@ export async function boardToken() {
     return token;
 }
 const same = (a, b) => b.length > 0 && a.length === b.length && timingSafeEqual(Buffer.from(a), Buffer.from(b));
-function cookieOf(req) {
+function cookieOf(req, name) {
     for (const part of (req.headers.cookie ?? '').split(';')) {
         const [k, ...v] = part.trim().split('=');
-        if (k === COOKIE)
+        if (k === name)
             return v.join('=');
     }
     return '';
@@ -42,7 +44,7 @@ export function admit(req, port, token) {
     const origin = req.headers.origin;
     if (write && !(origin && hosts.some((h) => origin === `http://${h}`)))
         return { ok: false, status: 403, message: 'a change comes from the board page only' };
-    if (!same(cookieOf(req), token))
+    if (!same(cookieOf(req, cookieName(port)), token))
         return { ok: false, status: 401, message: 'open the URL gcf-board printed at start' };
     return { ok: true };
 }

package/dist/server/desktop.js

@@ -11,11 +11,15 @@ export function openInBrowser(url) {
         : process.platform === 'darwin'
             ? ['open', [url]]
             : ['xdg-open', [url]];
+    // No browser to open: the operator opens the printed URL. A missing opener fails as an event,
+    // which unheard would end the server.
     try {
-        spawn(cmd, args, { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+        spawn(cmd, args, { detached: true, stdio: 'ignore', windowsHide: true })
+            .on('error', () => { })
+            .unref();
     }
     catch {
-        // No browser to open: the operator opens the printed URL.
+        // Refused at once: the same.
     }
 }
 /** A PowerShell single-quoted string: a quote inside is doubled. */

package/dist/server/events.js

@@ -1,6 +1,6 @@
-// Server-sent events: a project's `gcf/` or its run locks changed, a run the board started ended.
-// The page reads the board again on each one; the event carries no state of its own.
-import { watch, watchFile, unwatchFile } from 'node:fs';
+// Server-sent events: a project's `gcf/`, its plans or its run marks changed, a run the board
+// started ended. The page reads the board again on each one; the event carries no state of its own.
+import { readdirSync, readFileSync, statSync, watch } from 'node:fs';
 import path from 'node:path';
 const clients = new Set();
 /** Open an event stream on `res`. */
@@ -25,10 +25,59 @@ export function broadcast(event) {
     for (const c of clients)
         c.write(line);
 }
+// The core's SESSION_TTL_MS (session-mark.js): a mark nobody refreshed for this long is a session
+// that stopped. shortcut: a copy of the core's constant, read it from the board JSON once the core
+// reports a mark's expiry.
+const SESSION_TTL_MS = 120 * 60_000;
+const alive = (pid) => {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+};
+/**
+ * What makes items `running` in a runs directory: its entries, whether each lock's process
+ * lives, whether each session mark is fresh. A run that died or a session that expired changes
+ * it with no file written.
+ */
+export function runsState(dir, now = Date.now()) {
+    let names;
+    try {
+        names = readdirSync(dir).sort();
+    }
+    catch {
+        return '';
+    }
+    return names
+        .map((n) => {
+        const file = path.join(dir, n);
+        try {
+            if (n.endsWith('.lock'))
+                return `${n} ${alive(Number(readFileSync(file, 'utf8').split('\n')[0]))}`;
+            if (n.endsWith('.session'))
+                return `${n} ${now - statSync(file).mtimeMs < SESSION_TTL_MS}`;
+        }
+        catch {
+            // Gone meanwhile: the next poll sees it.
+        }
+        return n;
+    })
+        .join('\n');
+}
+// Each project's plan writes, counted: a plan's text can change while its checkbox progress stays,
+// so the page reads an open plan again when the count moves.
+const planRevs = new Map();
+export const planRev = (project) => planRevs.get(project) ?? 0;
 /**
- * Watch a project: `gcf/` (every move writes there) and `.gcf-session/runs` (a run's lock comes
- * and goes). The runs directory may not exist yet, so it is polled, not watched. Bursts of
- * writes make one event. Returns the stop.
+ * Watch a project: `gcf/` (every move writes there), `.ai-factory/plans` (a plan is written and
+ * edited) and `.gcf-session/runs` (a run's lock or session mark comes, goes or goes stale). The
+ * runs directory may not exist yet, so it is polled, not watched. Bursts of writes make one
+ * event. Returns the stop.
  */
 export function watchProject(p, debounceMs = 300) {
     let timer = null;
@@ -37,19 +86,38 @@ export function watchProject(p, debounceMs = 300) {
             clearTimeout(timer);
         timer = setTimeout(() => broadcast({ type: 'board', project: p.name }), debounceMs);
     };
-    let gcf = null;
-    try {
-        gcf = watch(path.join(p.path, 'gcf'), { recursive: true }, fire);
-        gcf.on('error', () => gcf?.close());
-    }
-    catch {
-        // gcf/ is gone: the board read shows the error, nothing to watch.
-    }
+    const watchers = [];
+    const watchDir = (dir, onChange) => {
+        try {
+            const w = watch(dir, { recursive: true }, (_e, file) => onChange(file));
+            w.on('error', () => w.close());
+            watchers.push(w);
+        }
+        catch {
+            // Not there: the board read shows what is missing.
+        }
+    };
+    watchDir(path.join(p.path, 'gcf'), fire);
+    // shortcut: a plan an item links outside .ai-factory/plans shows its new text only when its
+    // checkbox count moves; watch those files too if operators edit such plans by hand.
+    watchDir(path.join(p.path, '.ai-factory'), (file) => {
+        if (!/^plans[\\/]/.test(file ?? ''))
+            return;
+        planRevs.set(p.name, planRev(p.name) + 1);
+        fire();
+    });
     const runs = path.join(p.path, '.gcf-session', 'runs');
-    watchFile(runs, { interval: 1500 }, fire);
+    let last = runsState(runs);
+    const poll = setInterval(() => {
+        const now = runsState(runs);
+        if (now !== last)
+            fire();
+        last = now;
+    }, 1500);
     return () => {
-        gcf?.close();
-        unwatchFile(runs, fire);
+        for (const w of watchers)
+            w.close();
+        clearInterval(poll);
         if (timer)
             clearTimeout(timer);
     };

package/dist/server/files.js

@@ -1,5 +1,5 @@
-// The files a board shows: an item, its plan, its run log. Only those shapes, only inside the
-// project, symlinks resolved: the API is not a way to read the disk.
+// The files a board shows: an item, its plan, its run log. Only those shapes (or a plan an item
+// links), only inside the project, symlinks resolved: the API is not a way to read the disk.
 import { realpath, readFile, stat, open } from 'node:fs/promises';
 import path from 'node:path';
 import { StringDecoder } from 'node:string_decoder';
@@ -11,9 +11,11 @@ const SHOWN = [
     /^\.gcf-session\/runs\/[\w.-]+\.log$/,
 ];
 const MAX = 1024 * 1024;
-/** The absolute path of a shown file, or a 403. */
-export async function shownFile(root, rel) {
-    if (!SHOWN.some((r) => r.test(rel)) || rel.split('/').includes('..'))
+/** Whether `rel` has a shape the board shows without asking the core. */
+export const shownShape = (rel) => SHOWN.some((r) => r.test(rel));
+/** The absolute path of a shown file (or a plan an item links, `linked`), or a 403. */
+export async function shownFile(root, rel, linked = false) {
+    if (!(linked || shownShape(rel)) || rel.split('/').includes('..'))
         throw new HttpError(403, `${rel} is not a file the board shows`);
     const file = path.join(root, rel);
     const real = await realpath(file).catch(() => {
@@ -25,8 +27,8 @@ export async function shownFile(root, rel) {
     return real;
 }
 /** The text of a shown file; a large one is cut to its last megabyte. */
-export async function readShown(root, rel) {
-    const file = await shownFile(root, rel);
+export async function readShown(root, rel, linked = false) {
+    const file = await shownFile(root, rel, linked);
     const { size } = await stat(file);
     if (size <= MAX)
         return readFile(file, 'utf8');

package/dist/server/runs.js

@@ -4,6 +4,7 @@
 // In `run_mode: main` the checkout takes one run at a time: a run asked for meanwhile waits in
 // the project's queue and starts when the one before it ends.
 import { spawn } from 'node:child_process';
+import { briefError } from './cli.js';
 import { broadcast } from './events.js';
 import { HttpError } from './http-error.js';
 // A board that stops leaves its runs going: killing one would lose its integrate step.
@@ -80,7 +81,15 @@ function spawnRun({ entry, p, ids }, mode) {
         if (stop)
             paused.add(p.name);
         const why = stop ? '\nthe queue is paused: fix the cause, then resume it on the board' : '';
-        broadcast({ type: 'run', project: p.name, ids, ok, result, err: (err + message + why).trim() });
+        const brief = err && briefError(err);
+        broadcast({
+            type: 'run',
+            project: p.name,
+            ids,
+            ok,
+            result,
+            err: (brief + message + why).trim(),
+        });
         if (mode === 'main')
             advance(p.name);
         broadcast({ type: 'board', project: p.name });
@@ -99,7 +108,8 @@ export function startRun(entry, p, ids, mode = 'worktree') {
     const busy = ids.filter((id) => queued.includes(id) || going.some((r) => r.ids.includes(id)));
     if (busy.length)
         throw new HttpError(409, `already running from this board: ${busy.join(', ')}`);
-    if (mode === 'main' && going.some((r) => r.mode === 'main')) {
+    // A paused queue holds a new main run too: it would repeat the failure, and jump the queue.
+    if (mode === 'main' && (paused.has(p.name) || going.some((r) => r.mode === 'main'))) {
         queues.set(p.name, [...(queues.get(p.name) ?? []), { entry, p, ids, mode }]);
         broadcast({ type: 'board', project: p.name });
         return { queued: ids };