mirror of
https://github.com/garrytan/gstack.git
synced 2026-06-05 01:28:15 +02:00
feat(design): introduce design daemon — multi-board persistent server
Adds design/src/daemon.ts: a Bun.serve daemon that hosts many boards
under /boards/<id>/ instead of one server per `$D compare --serve` call.
Spawned by daemon-client (next commit); for now wired only via tests.
Endpoint table:
GET /health liveness + version + counts (unauth)
GET / index of recent boards
POST /api/boards publish; daemon derives sourceDir
from realpath(html). body sourceDir
IGNORED (Codex trust-boundary fix).
POST /shutdown graceful; refuses if active boards
exist (Codex data-loss fix)
GET /boards/<id> 301 → /boards/<id>/ (trailing slash
is load-bearing — relative URLs in
board JS resolve against pathname)
GET /boards/<id>/ render board HTML
GET /boards/<id>/api/progress state machine status (no idle reset)
POST /boards/<id>/api/feedback submit/regen; writes feedback.json
or feedback-pending.json with
boardId + publishedAt augmented in
POST /boards/<id>/api/reload swap HTML; per-board allowedDir
guard rejects traversal, directories,
out-of-allowed-dir symlinks
Lifecycle:
- 24h idle timeout (DESIGN_DAEMON_IDLE_MS for tests).
- Idle with active boards extends 1h up to 4x, then force-shuts (Codex).
- LRU cap 50 boards; evicts done before non-done; 503 when 50 non-done.
- Per-board async mutex serializes feedback POST vs reload POST.
- SIGTERM/SIGINT/uncaughtException → graceful shutdown, state file unlink.
- Stdout: DAEMON_STARTED port=<N> (the line the client parses).
Shared utilities live in design/src/daemon-state.ts: atomic state-file
write/read (mode 0o600), fs.openSync('wx') lock, isProcessAlive, cmdline
identity verification (/proc on Linux, ps on macOS), CMDLINE_MARKER
constant. Modeled on browse/src/cli.ts lock + spawn patterns.
design/test/daemon.test.ts: 30 tests, all green. Covers every endpoint,
both error paths and happy paths, cross-board feedback isolation, the
trailing-slash redirect, the directory-not-file reload rejection, LRU
preferring done over non-done, /shutdown refusal with active boards,
all path-traversal guards. Uses the exported fetchHandler in-process
(no spawn) so the suite runs in ~70ms.
design/test/daemon-tests-fixtures.ts: shared helpers — req() builder,
tmp-dir helpers, daemon reset, and a spawnDaemonForTest() helper used
by the next commit's discovery tests.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Garry Tan
@@ -0,0 +1,185 @@
|
||||
/**
|
||||
* Pure utilities for design-daemon discovery.
|
||||
*
|
||||
* Shared between daemon.ts (writes/removes the state file) and
|
||||
* daemon-client.ts (reads state, decides spawn-vs-attach). Mirrors
|
||||
* browse/src/cli.ts:109-315 — same atomic-write + fs.openSync 'wx' lock
|
||||
* pattern, with an added cmdline-based identity check to guard against
|
||||
* SIGTERM hitting a reused PID (Codex finding on the daemon plan).
|
||||
*/
|
||||
|
||||
import { execFileSync } from "child_process";
|
||||
import fs from "fs";
|
||||
import os from "os";
|
||||
import path from "path";
|
||||
|
||||
export interface DaemonState {
|
||||
pid: number;
|
||||
port: number;
|
||||
startedAt: string; // ISO 8601
|
||||
version: string;
|
||||
serverPath: string;
|
||||
cmdlineMarker: string;
|
||||
}
|
||||
|
||||
// String we grep for in the spawned daemon's cmdline to confirm a pid is
|
||||
// ours before sending any signal. Must appear in argv at spawn time.
|
||||
export const CMDLINE_MARKER = "gstack-design-daemon";
|
||||
|
||||
export function resolveStateFilePath(): string {
|
||||
try {
|
||||
const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
|
||||
encoding: "utf8",
|
||||
stdio: ["ignore", "pipe", "ignore"],
|
||||
}).trim();
|
||||
if (root) return path.join(root, ".gstack", "design.json");
|
||||
} catch {
|
||||
// not in a git repo — fall through
|
||||
}
|
||||
return path.join(process.cwd(), ".gstack", "design.json");
|
||||
}
|
||||
|
||||
export function resolveLockFilePath(stateFile: string = resolveStateFilePath()): string {
|
||||
return `${stateFile}.lock`;
|
||||
}
|
||||
|
||||
export function resolveDaemonLogPath(): string {
|
||||
return path.join(os.homedir(), ".gstack", "design-daemon.log");
|
||||
}
|
||||
|
||||
export function resolveStartupLogPath(): string {
|
||||
return path.join(os.homedir(), ".gstack", "design-daemon-startup.log");
|
||||
}
|
||||
|
||||
export function readStateFile(stateFile: string = resolveStateFilePath()): DaemonState | null {
|
||||
try {
|
||||
return JSON.parse(fs.readFileSync(stateFile, "utf-8")) as DaemonState;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
export function writeStateFile(
|
||||
state: DaemonState,
|
||||
stateFile: string = resolveStateFilePath(),
|
||||
): void {
|
||||
fs.mkdirSync(path.dirname(stateFile), { recursive: true });
|
||||
const tmp = `${stateFile}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`;
|
||||
fs.writeFileSync(tmp, JSON.stringify(state, null, 2), { mode: 0o600 });
|
||||
fs.renameSync(tmp, stateFile);
|
||||
}
|
||||
|
||||
export function removeStateFile(stateFile: string = resolveStateFilePath()): void {
|
||||
try {
|
||||
fs.unlinkSync(stateFile);
|
||||
} catch {
|
||||
// already gone
|
||||
}
|
||||
}
|
||||
|
||||
export interface HealthOk {
|
||||
ok: true;
|
||||
version: string;
|
||||
uptime: number;
|
||||
boards: number;
|
||||
activeBoards: number;
|
||||
}
|
||||
|
||||
export async function healthCheck(
|
||||
port: number,
|
||||
timeoutMs: number = 2000,
|
||||
): Promise<HealthOk | null> {
|
||||
try {
|
||||
const resp = await fetch(`http://127.0.0.1:${port}/health`, {
|
||||
signal: AbortSignal.timeout(timeoutMs),
|
||||
});
|
||||
if (!resp.ok) return null;
|
||||
const body = (await resp.json()) as Partial<HealthOk> | null;
|
||||
if (body && body.ok === true && typeof body.version === "string") {
|
||||
return body as HealthOk;
|
||||
}
|
||||
return null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
export function isProcessAlive(pid: number): boolean {
|
||||
if (!pid || pid <= 0) return false;
|
||||
try {
|
||||
process.kill(pid, 0);
|
||||
return true;
|
||||
} catch (e: unknown) {
|
||||
// EPERM means it exists, we just can't signal it. ESRCH means it's gone.
|
||||
const code = (e as NodeJS.ErrnoException | undefined)?.code;
|
||||
return code === "EPERM";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the cmdline of a running process. Returns "" on any error.
|
||||
* Linux: /proc/<pid>/cmdline (NUL-separated argv). macOS: `ps -p PID -o command=`.
|
||||
*/
|
||||
export function readCmdline(pid: number): string {
|
||||
if (!isProcessAlive(pid)) return "";
|
||||
try {
|
||||
if (process.platform === "linux") {
|
||||
const raw = fs.readFileSync(`/proc/${pid}/cmdline`, "utf-8");
|
||||
return raw.replace(/\0/g, " ").trim();
|
||||
}
|
||||
if (process.platform === "darwin") {
|
||||
return execFileSync("ps", ["-p", String(pid), "-o", "command="], {
|
||||
encoding: "utf8",
|
||||
stdio: ["ignore", "pipe", "ignore"],
|
||||
}).trim();
|
||||
}
|
||||
return "";
|
||||
} catch {
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* True only when the process at `pid` has `marker` in its cmdline. Used to
|
||||
* avoid SIGTERMing an unrelated process that happens to have inherited a
|
||||
* PID from a stale state file (the Codex PID-reuse concern). On systems
|
||||
* where readCmdline is unsupported (or fails), this returns false — safer
|
||||
* to skip the signal than to risk killing the wrong process.
|
||||
*/
|
||||
export function verifyIdentity(pid: number, marker: string): boolean {
|
||||
if (!marker) return false;
|
||||
return readCmdline(pid).includes(marker);
|
||||
}
|
||||
|
||||
/**
|
||||
* Acquire an exclusive lock on `lockPath`. Returns a release function, or
|
||||
* null if held by another live process. Stale locks (PID dead) are reclaimed
|
||||
* once; if reclaim also fails the caller waits and retries via state re-read.
|
||||
*/
|
||||
export function acquireLock(lockPath: string): (() => void) | null {
|
||||
try {
|
||||
fs.mkdirSync(path.dirname(lockPath), { recursive: true });
|
||||
// 'wx' = create exclusive, fail if exists. Atomic check-and-create.
|
||||
const fd = fs.openSync(lockPath, "wx");
|
||||
fs.writeSync(fd, `${process.pid}\n`);
|
||||
fs.closeSync(fd);
|
||||
return () => {
|
||||
try {
|
||||
fs.unlinkSync(lockPath);
|
||||
} catch {
|
||||
// already gone
|
||||
}
|
||||
};
|
||||
} catch {
|
||||
// Held — check if holder is alive
|
||||
try {
|
||||
const holderPid = parseInt(fs.readFileSync(lockPath, "utf-8").trim(), 10);
|
||||
if (holderPid && isProcessAlive(holderPid)) return null;
|
||||
// Stale, reclaim
|
||||
fs.unlinkSync(lockPath);
|
||||
return acquireLock(lockPath);
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,592 @@
|
||||
/**
|
||||
* Persistent design board daemon.
|
||||
*
|
||||
* One process hosts many boards under /boards/<id>/. Spawned by
|
||||
* daemon-client.ts when no live daemon is found on the project's discovery
|
||||
* file (.gstack/design.json). Replaces the per-invocation server in
|
||||
* serve.ts as the default for `$D compare --serve`; serve.ts is kept as
|
||||
* the --no-daemon legacy/test path.
|
||||
*
|
||||
* Endpoints (see plan docs/designs path for full table):
|
||||
* GET / index of boards
|
||||
* GET /health liveness + version (unauth)
|
||||
* POST /api/boards publish a new board
|
||||
* POST /shutdown graceful exit (refused if active)
|
||||
* GET /boards/<id> 301 → /boards/<id>/
|
||||
* GET /boards/<id>/ render board HTML
|
||||
* GET /boards/<id>/api/progress state machine status
|
||||
* POST /boards/<id>/api/feedback submit/regenerate
|
||||
* POST /boards/<id>/api/reload swap board HTML
|
||||
*
|
||||
* Lifecycle:
|
||||
* start → bind 127.0.0.1:N → write state file → serve until 24h idle or
|
||||
* explicit /shutdown → remove state file → exit 0
|
||||
*
|
||||
* The daemon refuses /shutdown when boards are non-done; the idle timer
|
||||
* extends rather than killing in that case (up to a 28h hard ceiling).
|
||||
* Both are Codex-flagged guards against silent loss of in-memory history.
|
||||
*/
|
||||
|
||||
import fs from "fs";
|
||||
import path from "path";
|
||||
|
||||
import {
|
||||
CMDLINE_MARKER,
|
||||
DaemonState,
|
||||
removeStateFile,
|
||||
resolveDaemonLogPath,
|
||||
writeStateFile,
|
||||
} from "./daemon-state";
|
||||
|
||||
// ─── Tunables (env overrides for tests) ──────────────────────────
|
||||
|
||||
const DEFAULT_IDLE_MS = 24 * 60 * 60 * 1000; // 24h
|
||||
const IDLE_MS = parseInt(
|
||||
process.env.DESIGN_DAEMON_IDLE_MS || String(DEFAULT_IDLE_MS),
|
||||
10,
|
||||
);
|
||||
const IDLE_EXTENSION_MS = parseInt(
|
||||
process.env.DESIGN_DAEMON_EXTENSION_MS || String(60 * 60 * 1000), // 1h
|
||||
10,
|
||||
);
|
||||
const MAX_EXTENSIONS = parseInt(process.env.DESIGN_DAEMON_MAX_EXTENSIONS || "4", 10);
|
||||
const IDLE_CHECK_INTERVAL_MS = parseInt(
|
||||
process.env.DESIGN_DAEMON_CHECK_MS || "60000",
|
||||
10,
|
||||
);
|
||||
const MAX_BOARDS = parseInt(process.env.DESIGN_DAEMON_MAX_BOARDS || "50", 10);
|
||||
|
||||
const VERSION = process.env.DESIGN_DAEMON_VERSION || readVersion();
|
||||
|
||||
function readVersion(): string {
|
||||
try {
|
||||
// VERSION file lives at the repo root; design/ is one level down.
|
||||
return fs
|
||||
.readFileSync(path.join(import.meta.dir, "..", "..", "VERSION"), "utf-8")
|
||||
.trim() || "unknown";
|
||||
} catch {
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Per-board state ─────────────────────────────────────────────
|
||||
|
||||
export type BoardState = "serving" | "regenerating" | "done";
|
||||
|
||||
export interface Board {
|
||||
id: string;
|
||||
htmlContent: string;
|
||||
sourceDir: string; // realpath of the dir feedback files write to
|
||||
allowedDir: string; // realpath anchor for path-traversal guard
|
||||
state: BoardState;
|
||||
publishedAt: number;
|
||||
lastTouched: number;
|
||||
publisherPid: number;
|
||||
title?: string;
|
||||
}
|
||||
|
||||
// In-memory: keyed by board id.
|
||||
const boards = new Map<string, Board>();
|
||||
// Per-board mutex chain — serializes feedback POST vs reload POST on the
|
||||
// same board so the daemon doesn't race a state mutation against an HTML swap.
|
||||
const boardMutex = new Map<string, Promise<void>>();
|
||||
|
||||
let lastMeaningfulActivity = Date.now();
|
||||
let idleExtensions = 0;
|
||||
let shuttingDown = false;
|
||||
let serverRef: ReturnType<typeof Bun.serve> | null = null;
|
||||
let idleInterval: ReturnType<typeof setInterval> | null = null;
|
||||
const startTime = Date.now();
|
||||
const daemonLog = openDaemonLog();
|
||||
|
||||
function openDaemonLog(): fs.WriteStream | null {
|
||||
try {
|
||||
const p = resolveDaemonLogPath();
|
||||
fs.mkdirSync(path.dirname(p), { recursive: true });
|
||||
return fs.createWriteStream(p, { flags: "a" });
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function dlog(...args: unknown[]): void {
|
||||
const line = `[${new Date().toISOString()}] ${args.map(String).join(" ")}\n`;
|
||||
if (daemonLog) daemonLog.write(line);
|
||||
process.stderr.write(line);
|
||||
}
|
||||
|
||||
// ─── Helpers ─────────────────────────────────────────────────────
|
||||
|
||||
function newBoardId(): string {
|
||||
const now = new Date();
|
||||
const y = now.getUTCFullYear().toString().padStart(4, "0");
|
||||
const mo = (now.getUTCMonth() + 1).toString().padStart(2, "0");
|
||||
const d = now.getUTCDate().toString().padStart(2, "0");
|
||||
const hh = now.getUTCHours().toString().padStart(2, "0");
|
||||
const mm = now.getUTCMinutes().toString().padStart(2, "0");
|
||||
const ss = now.getUTCSeconds().toString().padStart(2, "0");
|
||||
const rand = Math.random().toString(36).slice(2, 8).padEnd(6, "0");
|
||||
return `b-${y}${mo}${d}-${hh}${mm}${ss}-${rand}`;
|
||||
}
|
||||
|
||||
async function withBoardMutex<T>(id: string, fn: () => Promise<T>): Promise<T> {
|
||||
const prev = boardMutex.get(id) || Promise.resolve();
|
||||
let release!: () => void;
|
||||
const next = new Promise<void>((r) => {
|
||||
release = r;
|
||||
});
|
||||
boardMutex.set(id, prev.then(() => next));
|
||||
await prev;
|
||||
try {
|
||||
return await fn();
|
||||
} finally {
|
||||
release();
|
||||
if (boardMutex.get(id) === next) boardMutex.delete(id);
|
||||
}
|
||||
}
|
||||
|
||||
function markMeaningfulActivity(): void {
|
||||
lastMeaningfulActivity = Date.now();
|
||||
idleExtensions = 0;
|
||||
}
|
||||
|
||||
function nonDoneCount(): number {
|
||||
let n = 0;
|
||||
for (const b of boards.values()) if (b.state !== "done") n += 1;
|
||||
return n;
|
||||
}
|
||||
|
||||
function hasActiveBoards(): boolean {
|
||||
return nonDoneCount() > 0;
|
||||
}
|
||||
|
||||
// LRU eviction. Prefers `done` boards as victims so an active regen doesn't
|
||||
// vanish mid-flight. Returns the evicted id, or null when the map fits.
|
||||
function evictOne(): string | null {
|
||||
if (boards.size <= MAX_BOARDS) return null;
|
||||
let oldestDone: Board | null = null;
|
||||
let oldestAny: Board | null = null;
|
||||
for (const b of boards.values()) {
|
||||
if (b.state === "done") {
|
||||
if (!oldestDone || b.lastTouched < oldestDone.lastTouched) oldestDone = b;
|
||||
}
|
||||
if (!oldestAny || b.lastTouched < oldestAny.lastTouched) oldestAny = b;
|
||||
}
|
||||
const victim = oldestDone || oldestAny;
|
||||
if (!victim) return null;
|
||||
boards.delete(victim.id);
|
||||
boardMutex.delete(victim.id);
|
||||
dlog(`evicted board ${victim.id} state=${victim.state}`);
|
||||
return victim.id;
|
||||
}
|
||||
|
||||
function evictUntilUnderCap(): void {
|
||||
while (boards.size > MAX_BOARDS) {
|
||||
if (!evictOne()) break;
|
||||
}
|
||||
}
|
||||
|
||||
function findActiveBoardForSourceDir(sourceDir: string): Board | null {
|
||||
for (const b of boards.values()) {
|
||||
if (b.sourceDir === sourceDir && b.state !== "done") return b;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function escapeHtml(s: string): string {
|
||||
return s.replace(/[&<>"']/g, (c) =>
|
||||
({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" }[c]!),
|
||||
);
|
||||
}
|
||||
|
||||
// ─── Shutdown ─────────────────────────────────────────────────────
|
||||
|
||||
async function gracefulShutdown(exitCode = 0): Promise<void> {
|
||||
if (shuttingDown) return;
|
||||
shuttingDown = true;
|
||||
dlog(`shutting down boards=${boards.size} code=${exitCode}`);
|
||||
if (idleInterval) clearInterval(idleInterval);
|
||||
try {
|
||||
serverRef?.stop();
|
||||
} catch {
|
||||
// already stopped
|
||||
}
|
||||
removeStateFile();
|
||||
if (daemonLog) daemonLog.end();
|
||||
setTimeout(() => process.exit(exitCode), 50);
|
||||
}
|
||||
|
||||
export function idleCheckTick(): void {
|
||||
if (shuttingDown) return;
|
||||
const idle = Date.now() - lastMeaningfulActivity;
|
||||
if (idle < IDLE_MS) return;
|
||||
if (hasActiveBoards()) {
|
||||
if (idleExtensions >= MAX_EXTENSIONS) {
|
||||
dlog(`idle past hard ceiling with ${nonDoneCount()} active boards — forcing shutdown`);
|
||||
gracefulShutdown(0);
|
||||
return;
|
||||
}
|
||||
idleExtensions += 1;
|
||||
// Push lastMeaningfulActivity forward by an extension window without
|
||||
// marking real activity (so the count stays correct).
|
||||
lastMeaningfulActivity = Date.now() - IDLE_MS + IDLE_EXTENSION_MS;
|
||||
dlog(
|
||||
`idle with ${nonDoneCount()} active boards — extending ${IDLE_EXTENSION_MS / 60000}min (${idleExtensions}/${MAX_EXTENSIONS})`,
|
||||
);
|
||||
return;
|
||||
}
|
||||
dlog(`idle for ${Math.floor(idle / 1000)}s — shutting down`);
|
||||
gracefulShutdown(0);
|
||||
}
|
||||
|
||||
// ─── Handlers ─────────────────────────────────────────────────────
|
||||
|
||||
function handleHealth(): Response {
|
||||
return Response.json({
|
||||
ok: true,
|
||||
version: VERSION,
|
||||
uptime: Math.floor((Date.now() - startTime) / 1000),
|
||||
boards: boards.size,
|
||||
activeBoards: nonDoneCount(),
|
||||
});
|
||||
}
|
||||
|
||||
function handleIndex(): Response {
|
||||
const sorted = [...boards.values()].sort((a, b) => b.publishedAt - a.publishedAt);
|
||||
const rows = sorted
|
||||
.map((b) => {
|
||||
const ts = new Date(b.publishedAt).toISOString();
|
||||
const titleSuffix = b.title ? ` — ${escapeHtml(b.title)}` : "";
|
||||
return `<li><a href="/boards/${b.id}/">${b.id}</a> <span class="state state-${b.state}">${b.state}</span> <time>${ts}</time>${titleSuffix}</li>`;
|
||||
})
|
||||
.join("\n");
|
||||
const empty = `<p class="empty">No boards yet. Run <code>$D compare --serve</code> to publish one.</p>`;
|
||||
const list = sorted.length === 0 ? empty : `<ul>\n${rows}\n</ul>`;
|
||||
const html = `<!DOCTYPE html><html lang="en"><head>
|
||||
<meta charset="utf-8"><title>gstack design boards</title><style>
|
||||
body{font:14px/1.5 -apple-system,system-ui,sans-serif;max-width:720px;margin:32px auto;padding:0 16px;color:#1a1a1a}
|
||||
h1{font-size:20px;margin-bottom:4px}
|
||||
.meta{color:#666;margin-bottom:24px;font-size:13px}
|
||||
ul{padding:0;list-style:none}
|
||||
li{padding:10px 0;border-bottom:1px solid #eee;display:flex;align-items:center;gap:12px;flex-wrap:wrap}
|
||||
a{color:#0070f3;text-decoration:none;font-family:ui-monospace,monospace}
|
||||
a:hover{text-decoration:underline}
|
||||
.state{font-size:11px;padding:2px 8px;border-radius:10px;background:#eef;color:#335}
|
||||
.state-done{background:#efe;color:#353}
|
||||
.state-regenerating{background:#ffe;color:#553}
|
||||
time{color:#888;font-size:12px}
|
||||
.empty{color:#888;font-style:italic}
|
||||
code{font-family:ui-monospace,monospace;background:#f5f5f5;padding:2px 6px;border-radius:3px}
|
||||
</style></head><body>
|
||||
<h1>gstack design boards</h1>
|
||||
<p class="meta">daemon up ${Math.floor((Date.now() - startTime) / 1000)}s · ${boards.size} board(s) · ${nonDoneCount()} active</p>
|
||||
${list}
|
||||
</body></html>`;
|
||||
return new Response(html, { headers: { "Content-Type": "text/html; charset=utf-8" } });
|
||||
}
|
||||
|
||||
async function handlePublish(req: Request, origin: string): Promise<Response> {
|
||||
let body: any;
|
||||
try {
|
||||
body = await req.json();
|
||||
} catch {
|
||||
return Response.json({ error: "Invalid JSON" }, { status: 400 });
|
||||
}
|
||||
if (!body || typeof body !== "object") {
|
||||
return Response.json({ error: "Expected JSON object" }, { status: 400 });
|
||||
}
|
||||
const htmlPath = typeof body.html === "string" ? body.html : "";
|
||||
if (!htmlPath) return Response.json({ error: "Missing 'html' field" }, { status: 400 });
|
||||
if (!fs.existsSync(htmlPath)) {
|
||||
return Response.json({ error: `HTML file not found: ${htmlPath}` }, { status: 400 });
|
||||
}
|
||||
let resolvedHtml: string;
|
||||
let sourceDir: string;
|
||||
try {
|
||||
resolvedHtml = fs.realpathSync(path.resolve(htmlPath));
|
||||
sourceDir = fs.realpathSync(path.dirname(resolvedHtml));
|
||||
} catch (e: any) {
|
||||
return Response.json({ error: `Cannot resolve path: ${e.message}` }, { status: 400 });
|
||||
}
|
||||
if (!fs.statSync(resolvedHtml).isFile()) {
|
||||
return Response.json(
|
||||
{ error: `'html' must be a file, not a directory: ${htmlPath}` },
|
||||
{ status: 400 },
|
||||
);
|
||||
}
|
||||
|
||||
// sourceDir comes from realpath(html), not from the body — Codex finding:
|
||||
// body-supplied sourceDir is a local trust boundary the daemon shouldn't cross.
|
||||
const existing = findActiveBoardForSourceDir(sourceDir);
|
||||
if (existing) {
|
||||
return Response.json(
|
||||
{
|
||||
error: "Source directory already in use by an active board",
|
||||
existing: {
|
||||
id: existing.id,
|
||||
url: `${origin}/boards/${existing.id}/`,
|
||||
state: existing.state,
|
||||
},
|
||||
},
|
||||
{ status: 409 },
|
||||
);
|
||||
}
|
||||
if (nonDoneCount() >= MAX_BOARDS) {
|
||||
return Response.json(
|
||||
{
|
||||
error: `Cannot publish: ${MAX_BOARDS} non-done boards already exist. Submit or close some first.`,
|
||||
},
|
||||
{ status: 503 },
|
||||
);
|
||||
}
|
||||
|
||||
const id = newBoardId();
|
||||
const htmlContent = fs.readFileSync(resolvedHtml, "utf-8");
|
||||
const now = Date.now();
|
||||
const board: Board = {
|
||||
id,
|
||||
htmlContent,
|
||||
sourceDir,
|
||||
allowedDir: sourceDir,
|
||||
state: "serving",
|
||||
publishedAt: now,
|
||||
lastTouched: now,
|
||||
publisherPid: typeof body.publisherPid === "number" ? body.publisherPid : 0,
|
||||
title: typeof body.title === "string" ? body.title : undefined,
|
||||
};
|
||||
boards.set(id, board);
|
||||
evictUntilUnderCap();
|
||||
markMeaningfulActivity();
|
||||
dlog(`published board ${id} sourceDir=${sourceDir} pid=${board.publisherPid}`);
|
||||
return Response.json({
|
||||
id,
|
||||
url: `${origin}/boards/${id}/`,
|
||||
sourceDir,
|
||||
});
|
||||
}
|
||||
|
||||
function handleBoardGet(board: Board): Response {
|
||||
board.lastTouched = Date.now();
|
||||
// No __GSTACK_SERVER_URL injection — board JS uses relative URLs that
|
||||
// resolve against /boards/<id>/ (the trailing slash is load-bearing here;
|
||||
// the 301 from the bare /boards/<id> form ensures it).
|
||||
return new Response(board.htmlContent, {
|
||||
headers: { "Content-Type": "text/html; charset=utf-8" },
|
||||
});
|
||||
}
|
||||
|
||||
function handleBoardProgress(board: Board): Response {
|
||||
// NOT meaningful activity — bare progress polling shouldn't keep the
|
||||
// daemon alive forever (Codex finding on idle-immortality).
|
||||
board.lastTouched = Date.now();
|
||||
return Response.json({ status: board.state });
|
||||
}
|
||||
|
||||
async function handleBoardFeedback(board: Board, req: Request): Promise<Response> {
|
||||
let body: any;
|
||||
try {
|
||||
body = await req.json();
|
||||
} catch {
|
||||
return Response.json({ error: "Invalid JSON" }, { status: 400 });
|
||||
}
|
||||
if (!body || typeof body !== "object") {
|
||||
return Response.json({ error: "Expected JSON object" }, { status: 400 });
|
||||
}
|
||||
const isSubmit = body.regenerated === false;
|
||||
const isRegen = body.regenerated === true;
|
||||
|
||||
// Augment with boardId + publishedAt so multi-board agents can disambiguate
|
||||
// which board produced a given feedback.json.
|
||||
const augmented = {
|
||||
...body,
|
||||
boardId: board.id,
|
||||
publishedAt: new Date(board.publishedAt).toISOString(),
|
||||
};
|
||||
|
||||
const feedbackFile = isSubmit ? "feedback.json" : "feedback-pending.json";
|
||||
const feedbackPath = path.join(board.sourceDir, feedbackFile);
|
||||
try {
|
||||
fs.writeFileSync(feedbackPath, JSON.stringify(augmented, null, 2));
|
||||
} catch (e: any) {
|
||||
dlog(`feedback write failed for ${board.id}: ${e.message}`);
|
||||
return Response.json(
|
||||
{ error: `Cannot write ${feedbackFile}: ${e.message}` },
|
||||
{ status: 500 },
|
||||
);
|
||||
}
|
||||
|
||||
board.lastTouched = Date.now();
|
||||
markMeaningfulActivity();
|
||||
|
||||
if (isSubmit) {
|
||||
board.state = "done";
|
||||
dlog(`board ${board.id} submitted → ${feedbackPath}`);
|
||||
return Response.json({ received: true, action: "submitted" });
|
||||
}
|
||||
if (isRegen) {
|
||||
board.state = "regenerating";
|
||||
dlog(`board ${board.id} regenerate → ${feedbackPath}`);
|
||||
return Response.json({ received: true, action: "regenerate" });
|
||||
}
|
||||
return Response.json({ received: true, action: "unknown" });
|
||||
}
|
||||
|
||||
async function handleBoardReload(board: Board, req: Request): Promise<Response> {
|
||||
let body: any;
|
||||
try {
|
||||
body = await req.json();
|
||||
} catch {
|
||||
return Response.json({ error: "Invalid JSON" }, { status: 400 });
|
||||
}
|
||||
const newHtmlPath = typeof body?.html === "string" ? body.html : "";
|
||||
if (!newHtmlPath || !fs.existsSync(newHtmlPath)) {
|
||||
return Response.json({ error: `HTML file not found: ${newHtmlPath}` }, { status: 400 });
|
||||
}
|
||||
const resolvedReload = fs.realpathSync(path.resolve(newHtmlPath));
|
||||
if (!resolvedReload.startsWith(board.allowedDir + path.sep)) {
|
||||
return Response.json(
|
||||
{ error: `Path must be within: ${board.allowedDir}` },
|
||||
{ status: 403 },
|
||||
);
|
||||
}
|
||||
if (!fs.statSync(resolvedReload).isFile()) {
|
||||
return Response.json(
|
||||
{ error: `Path must be a file, not a directory: ${newHtmlPath}` },
|
||||
{ status: 400 },
|
||||
);
|
||||
}
|
||||
board.htmlContent = fs.readFileSync(resolvedReload, "utf-8");
|
||||
board.state = "serving";
|
||||
board.lastTouched = Date.now();
|
||||
markMeaningfulActivity();
|
||||
dlog(`board ${board.id} reloaded from ${resolvedReload}`);
|
||||
return Response.json({ reloaded: true });
|
||||
}
|
||||
|
||||
function boardExpiredHtml(id: string): string {
|
||||
return `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><title>Board expired — gstack</title>
|
||||
<style>body{font:14px/1.5 -apple-system,system-ui,sans-serif;max-width:600px;margin:80px auto;padding:0 20px;color:#1a1a1a;text-align:center}
|
||||
h1{font-size:20px}.id{font-family:ui-monospace,monospace;color:#888;font-size:13px}
|
||||
a{color:#0070f3;text-decoration:none}a:hover{text-decoration:underline}</style></head><body>
|
||||
<h1>Board expired</h1>
|
||||
<p>Board <span class="id">${escapeHtml(id)}</span> is no longer hosted by this daemon (evicted or the daemon restarted).</p>
|
||||
<p><a href="/">← see active boards</a></p>
|
||||
</body></html>`;
|
||||
}
|
||||
|
||||
// ─── Router ──────────────────────────────────────────────────────
|
||||
|
||||
const BOARD_RE = /^\/boards\/([A-Za-z0-9_-]+)(\/.*)?$/;
|
||||
|
||||
export async function fetchHandler(req: Request): Promise<Response> {
|
||||
const url = new URL(req.url);
|
||||
const origin = url.origin;
|
||||
|
||||
if (req.method === "GET" && url.pathname === "/health") return handleHealth();
|
||||
if (req.method === "GET" && url.pathname === "/") return handleIndex();
|
||||
if (req.method === "POST" && url.pathname === "/api/boards") return handlePublish(req, origin);
|
||||
|
||||
if (req.method === "POST" && url.pathname === "/shutdown") {
|
||||
if (hasActiveBoards()) {
|
||||
return Response.json(
|
||||
{
|
||||
error: "Refusing /shutdown: daemon has active boards. Submit or close them first.",
|
||||
activeBoards: nonDoneCount(),
|
||||
},
|
||||
{ status: 409 },
|
||||
);
|
||||
}
|
||||
setTimeout(() => gracefulShutdown(0), 50);
|
||||
return Response.json({ shuttingDown: true });
|
||||
}
|
||||
|
||||
const m = url.pathname.match(BOARD_RE);
|
||||
if (m) {
|
||||
const id = m[1]!;
|
||||
const subpath = m[2] || "";
|
||||
const board = boards.get(id);
|
||||
if (!board) {
|
||||
return new Response(boardExpiredHtml(id), {
|
||||
status: 404,
|
||||
headers: { "Content-Type": "text/html; charset=utf-8" },
|
||||
});
|
||||
}
|
||||
// Bare /boards/<id> → 301 to /boards/<id>/ so relative URLs in board JS
|
||||
// resolve against the right base (./api/feedback → /boards/<id>/api/feedback).
|
||||
if (req.method === "GET" && subpath === "") {
|
||||
return new Response(null, {
|
||||
status: 301,
|
||||
headers: { Location: `/boards/${id}/` },
|
||||
});
|
||||
}
|
||||
if (req.method === "GET" && subpath === "/") return handleBoardGet(board);
|
||||
if (req.method === "GET" && subpath === "/api/progress") return handleBoardProgress(board);
|
||||
if (req.method === "POST" && subpath === "/api/feedback") {
|
||||
return withBoardMutex(id, () => handleBoardFeedback(board, req));
|
||||
}
|
||||
if (req.method === "POST" && subpath === "/api/reload") {
|
||||
return withBoardMutex(id, () => handleBoardReload(board, req));
|
||||
}
|
||||
}
|
||||
|
||||
return new Response("Not found", { status: 404 });
|
||||
}
|
||||
|
||||
// ─── Startup ─────────────────────────────────────────────────────
|
||||
|
||||
export function start(): { port: number } {
|
||||
const portArg = process.env.DESIGN_DAEMON_PORT;
|
||||
const port = portArg ? parseInt(portArg, 10) : 0;
|
||||
serverRef = Bun.serve({
|
||||
port,
|
||||
hostname: "127.0.0.1",
|
||||
fetch: fetchHandler,
|
||||
});
|
||||
const actualPort = serverRef.port;
|
||||
const state: DaemonState = {
|
||||
pid: process.pid,
|
||||
port: actualPort,
|
||||
startedAt: new Date().toISOString(),
|
||||
version: VERSION,
|
||||
serverPath: process.argv[1] || "",
|
||||
cmdlineMarker: CMDLINE_MARKER,
|
||||
};
|
||||
writeStateFile(state);
|
||||
dlog(`DAEMON_STARTED port=${actualPort} pid=${process.pid} version=${VERSION}`);
|
||||
// Stdout line the spawning CLI parses to learn the port quickly.
|
||||
console.log(`DAEMON_STARTED port=${actualPort}`);
|
||||
|
||||
idleInterval = setInterval(idleCheckTick, IDLE_CHECK_INTERVAL_MS);
|
||||
|
||||
process.on("SIGTERM", () => {
|
||||
void gracefulShutdown(0);
|
||||
});
|
||||
process.on("SIGINT", () => {
|
||||
void gracefulShutdown(0);
|
||||
});
|
||||
process.on("uncaughtException", (e) => {
|
||||
dlog(`uncaughtException: ${(e as Error).stack || (e as Error).message}`);
|
||||
void gracefulShutdown(1);
|
||||
});
|
||||
|
||||
return { port: actualPort };
|
||||
}
|
||||
|
||||
if (import.meta.main) {
|
||||
start();
|
||||
}
|
||||
|
||||
// Exported for tests. Keep this small and stable.
|
||||
export const __testInternals__ = {
|
||||
boards,
|
||||
fetchHandler,
|
||||
idleCheckTick,
|
||||
markMeaningfulActivity,
|
||||
resetForTest: (): void => {
|
||||
boards.clear();
|
||||
boardMutex.clear();
|
||||
lastMeaningfulActivity = Date.now();
|
||||
idleExtensions = 0;
|
||||
shuttingDown = false;
|
||||
},
|
||||
};
|
||||
Reference in New Issue
Block a user