gsd-pi 2.78.1-dev.d8826a445 → 2.78.1-dev.eccf86e27

package/src/resources/extensions/gsd/tests/auto-workers.test.ts

@@ -0,0 +1,105 @@
+// gsd-2 + Auto-mode worker registry tests (Phase B coordination)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { openDatabase, closeDatabase } from "../gsd-db.ts";
+import { _getAdapter } from "../gsd-db.ts";
+import {
+  registerAutoWorker,
+  heartbeatAutoWorker,
+  markWorkerCrashed,
+  markWorkerStopping,
+  getActiveAutoWorkers,
+  getAutoWorker,
+} from "../db/auto-workers.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-auto-workers-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("registerAutoWorker creates a row with active status and heartbeat", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  assert.match(id, /^auto-/, "worker_id has expected prefix");
+
+  const row = getAutoWorker(id);
+  assert.ok(row, "row exists");
+  assert.equal(row!.status, "active");
+  assert.equal(row!.project_root_realpath, base);
+  assert.equal(row!.pid, process.pid);
+});
+
+test("heartbeatAutoWorker updates last_heartbeat_at", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  const initial = getAutoWorker(id)!;
+  await new Promise(r => setTimeout(r, 10));
+  heartbeatAutoWorker(id);
+  const after = getAutoWorker(id)!;
+  const initialTs = Date.parse(initial.last_heartbeat_at);
+  const afterTs = Date.parse(after.last_heartbeat_at);
+  assert.ok(Number.isFinite(initialTs), "initial heartbeat parses");
+  assert.ok(Number.isFinite(afterTs), "updated heartbeat parses");
+  assert.ok(afterTs > initialTs, "heartbeat advanced");
+});
+
+test("markWorkerStopping flips status to stopping", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  markWorkerStopping(id);
+  const row = getAutoWorker(id)!;
+  assert.equal(row.status, "stopping");
+});
+
+test("markWorkerCrashed flips status to crashed", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  markWorkerCrashed(id);
+  const row = getAutoWorker(id)!;
+  assert.equal(row.status, "crashed");
+});
+
+test("getActiveAutoWorkers filters by status and TTL", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const a = registerAutoWorker({ projectRootRealpath: base });
+  const b = registerAutoWorker({ projectRootRealpath: base });
+
+  const active = getActiveAutoWorkers();
+  assert.equal(active.length, 2);
+  assert.ok(active.find(w => w.worker_id === a));
+  assert.ok(active.find(w => w.worker_id === b));
+
+  _getAdapter()!.prepare(
+    `UPDATE workers SET last_heartbeat_at = '1970-01-01T00:00:00.000Z' WHERE worker_id = :worker_id`,
+  ).run({ ":worker_id": a });
+
+  const after = getActiveAutoWorkers();
+  assert.equal(after.length, 1);
+  assert.equal(after[0].worker_id, b);
+});

package/src/resources/extensions/gsd/tests/command-queue.test.ts

@@ -0,0 +1,141 @@
+// gsd-2 + Command queue tests (Phase B coordination — IPC inbox + broadcast NULL semantics)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { openDatabase, closeDatabase } from "../gsd-db.ts";
+import {
+  enqueueCommand,
+  claimNextCommand,
+  completeCommand,
+  getCommand,
+} from "../db/command-queue.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-cmd-q-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("enqueue + claim + complete round-trip for targeted command", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = enqueueCommand({
+    targetWorker: "worker-A",
+    command: "cancel",
+    args: { reason: "user-request" },
+  });
+  assert.ok(id > 0);
+
+  const claimed = claimNextCommand("worker-A");
+  assert.ok(claimed);
+  assert.equal(claimed!.id, id);
+  assert.equal(claimed!.command, "cancel");
+  assert.equal(claimed!.claimed_by, "worker-A");
+  assert.ok(claimed!.claimed_at);
+
+  completeCommand(id, "worker-A", { acknowledged: true });
+  const final = getCommand(id);
+  assert.ok(final!.completed_at);
+  assert.equal(final!.result_json, JSON.stringify({ acknowledged: true }));
+});
+
+test("targeted command is invisible to other workers", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  enqueueCommand({ targetWorker: "worker-A", command: "for-A" });
+  const wrong = claimNextCommand("worker-B");
+  assert.equal(wrong, null, "worker-B sees nothing for worker-A");
+
+  const right = claimNextCommand("worker-A");
+  assert.ok(right);
+  assert.equal(right!.command, "for-A");
+});
+
+test("broadcast command (target=null) is visible to ANY worker, claimed exactly once", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  enqueueCommand({ targetWorker: null, command: "broadcast-cancel" });
+
+  const a = claimNextCommand("worker-A");
+  assert.ok(a, "first poller wins");
+  assert.equal(a!.command, "broadcast-cancel");
+
+  // Second poller (different worker) sees nothing — broadcast is single-delivery
+  const b = claimNextCommand("worker-B");
+  assert.equal(b, null);
+});
+
+test("oldest-first ordering across mixed targeted + broadcast queue", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  enqueueCommand({ targetWorker: null, command: "first" });
+  enqueueCommand({ targetWorker: "worker-A", command: "second" });
+  enqueueCommand({ targetWorker: null, command: "third" });
+
+  const c1 = claimNextCommand("worker-A")!;
+  const c2 = claimNextCommand("worker-A")!;
+  const c3 = claimNextCommand("worker-A")!;
+  assert.equal(c1.command, "first");
+  assert.equal(c2.command, "second");
+  assert.equal(c3.command, "third");
+  assert.equal(claimNextCommand("worker-A"), null);
+});
+
+test("completeCommand is idempotent — second call does not overwrite", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = enqueueCommand({ targetWorker: "w", command: "x" });
+  claimNextCommand("w");
+  completeCommand(id, "w", { result: 1 });
+  completeCommand(id, "w", { result: 2 }); // second call should no-op
+  const row = getCommand(id)!;
+  assert.equal(row.result_json, JSON.stringify({ result: 1 }));
+});
+
+test("completed commands cannot be reclaimed or completed by a different worker", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = enqueueCommand({ targetWorker: "worker-A", command: "x" });
+  const claimed = claimNextCommand("worker-A");
+  assert.ok(claimed);
+
+  completeCommand(id, "worker-A", { result: 1 });
+  completeCommand(id, "worker-B", { result: 2 });
+
+  assert.equal(claimNextCommand("worker-A"), null);
+  const row = getCommand(id)!;
+  assert.equal(row.result_json, JSON.stringify({ result: 1 }));
+});
+
+test("completeCommand does not complete an unclaimed command", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = enqueueCommand({ targetWorker: "w", command: "x" });
+  completeCommand(id, "w", { result: 1 });
+  const row = getCommand(id)!;
+  assert.equal(row.completed_at, null);
+  assert.equal(row.result_json, null);
+});

package/src/resources/extensions/gsd/tests/crash-recovery-via-db.test.ts

@@ -0,0 +1,203 @@
+// gsd-2 + Crash recovery via DB (Phase C pt 2 — auto.lock migration)
+//
+// auto.lock file IO is gone. readCrashLock now synthesizes a LockData
+// from the workers + unit_dispatches + runtime_kv tables. These tests
+// verify the synthesis end-to-end: register a worker, simulate it going
+// stale (heartbeat lapsed), and confirm readCrashLock returns the
+// correct LockData with PID, started_at, unit details, and session
+// file derived from the DB.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  _getAdapter,
+} from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import { recordDispatchClaim } from "../db/unit-dispatches.ts";
+import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.ts";
+import {
+  writeLock,
+  readCrashLock,
+  clearLock,
+  isLockProcessAlive,
+} from "../crash-recovery.ts";
+import { normalizeRealPath } from "../paths.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-crash-recovery-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+/** Force a worker's last_heartbeat_at into the past so the stale-detector picks it up. */
+function expireWorker(workerId: string): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE workers SET last_heartbeat_at = '1970-01-01T00:00:00.000Z' WHERE worker_id = :w`,
+  ).run({ ":w": workerId });
+}
+
+function setWorkerPid(workerId: string, pid: number): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE workers SET pid = :pid WHERE worker_id = :w`,
+  ).run({ ":pid": pid, ":w": workerId });
+}
+
+test("readCrashLock returns null when no workers exist", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  assert.equal(readCrashLock(base), null);
+});
+
+test("readCrashLock returns null when only fresh (un-expired) workers exist", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  // Heartbeat is fresh — not stale yet.
+  assert.equal(readCrashLock(base), null);
+});
+
+test("readCrashLock ignores a stale heartbeat when the worker PID is still alive", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  expireWorker(workerId);
+
+  assert.equal(readCrashLock(base), null);
+});
+
+test("readCrashLock synthesizes LockData from a stale dead worker (no dispatches yet)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock, "stale worker surfaced as a crash lock");
+  assert.equal(lock!.pid, 99999);
+  // Bootstrap default — no dispatches recorded
+  assert.equal(lock!.unitType, "starting");
+  assert.equal(lock!.unitId, "bootstrap");
+  assert.ok(lock!.startedAt, "startedAt populated from workers.started_at");
+});
+
+test("readCrashLock includes the most recent dispatch as unitType/unitId", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+  recordDispatchClaim({
+    traceId: "t1", workerId, milestoneLeaseToken: lease.token,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "M001/S01",
+  });
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock);
+  assert.equal(lock!.unitType, "plan-slice");
+  assert.equal(lock!.unitId, "M001/S01");
+});
+
+test("readCrashLock surfaces sessionFile from runtime_kv", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  setRuntimeKv("worker", workerId, "session_file", "/tmp/pi-session-abc.jsonl");
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock);
+  assert.equal(lock!.sessionFile, "/tmp/pi-session-abc.jsonl");
+});
+
+test("isLockProcessAlive returns true for the current process", () => {
+  const lock = {
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+  };
+  assert.equal(isLockProcessAlive(lock), true);
+});
+
+test("isLockProcessAlive returns false for a dead PID", () => {
+  // PID 99999 is essentially guaranteed dead on a fresh test box.
+  const lock = {
+    pid: 99999,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+  };
+  assert.equal(isLockProcessAlive(lock), false);
+});
+
+test("writeLock stores the session_file in runtime_kv (worker scope)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+
+  writeLock(base, "plan-slice", "M001/S01", "/tmp/session-xyz.jsonl");
+
+  // Verify the value was written for the live worker.
+  const stored = getRuntimeKv<string>("worker", workerId, "session_file");
+  assert.equal(stored, "/tmp/session-xyz.jsonl");
+
+  // Confirm a stale read picks it up via readCrashLock.
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+  const lock = readCrashLock(base);
+  assert.ok(lock);
+  assert.equal(lock!.sessionFile, "/tmp/session-xyz.jsonl");
+});
+
+test("clearLock removes the session_file row for the active worker", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+
+  writeLock(base, "plan-slice", "M001/S01", "/tmp/session-xyz.jsonl");
+  assert.equal(getRuntimeKv("worker", workerId, "session_file"), "/tmp/session-xyz.jsonl");
+
+  // clearLock operates on the active worker (this process) — must run
+  // BEFORE expiring the heartbeat, mirroring stopAuto's order: clearLock
+  // → markWorkerStopping → done.
+  clearLock(base);
+  assert.equal(getRuntimeKv("worker", workerId, "session_file"), null,
+    "session_file row deleted by clearLock");
+});