@a9n-shoji/rvw 0.2.2 → 0.2.3

package/skills/rvw-watch-comments/scripts/watch-driver.mjs

@@ -1,6 +1,16 @@
 #!/usr/bin/env node
 
+import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
+import {
+  chmodSync,
+  linkSync,
+  lstatSync,
+  readFileSync,
+  realpathSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { fileURLToPath } from "node:url";
@@ -10,9 +20,13 @@ const EXIT_WATCH = 20;
 const EXIT_SEQUENCE = 21;
 const EXIT_INGEST = 22;
 const EXIT_AUTO_ACK = 23;
+const EXIT_ALREADY_RUNNING = 24;
+const DEFAULT_MAX_IN_FLIGHT = 1;
+const DEFAULT_AUTO_ACK_POLL_MS = 250;
 const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 const stateScript = path.join(scriptDirectory, "watch-state.mjs");
 const autoAckScript = path.join(scriptDirectory, "auto-ack.mjs");
+const DRIVER_LOCK_SUFFIX = ".watch-driver.lock";
 
 class DriverError extends Error {
   constructor(message, exitCode, details = null) {
@@ -25,12 +39,27 @@ class DriverError extends Error {
 function parseArguments(values) {
   let state = null;
   let autoAck = false;
+  let maxInFlight = DEFAULT_MAX_IN_FLIGHT;
+  let maxInFlightProvided = false;
   for (let index = 0; index < values.length; index += 1) {
     const value = values[index];
     if (value === "--auto-ack") {
       autoAck = true;
       continue;
     }
+    if (value === "--max-in-flight") {
+      const next = values[index + 1];
+      if (!next || next.startsWith("--")) {
+        throw new DriverError("--max-in-flight requires an integer", EXIT_WATCH);
+      }
+      maxInFlight = Number(next);
+      maxInFlightProvided = true;
+      if (!Number.isSafeInteger(maxInFlight) || maxInFlight < 1 || maxInFlight > 64) {
+        throw new DriverError("--max-in-flight must be an integer from 1 through 64", EXIT_WATCH);
+      }
+      index += 1;
+      continue;
+    }
     if (value === "--state") {
       const next = values[index + 1];
       if (!next || next.startsWith("--")) {
@@ -47,7 +76,10 @@ function parseArguments(values) {
     throw new DriverError(`Unexpected argument: ${value}`, EXIT_WATCH);
   }
   if (!state) throw new DriverError("Pass the task state database path", EXIT_WATCH);
-  return { state: path.resolve(state), autoAck };
+  if (!autoAck && maxInFlightProvided) {
+    throw new DriverError("--max-in-flight requires --auto-ack", EXIT_WATCH);
+  }
+  return { state: path.resolve(state), autoAck, maxInFlight };
 }
 
 async function runNodeScript(script, args, input) {
@@ -86,12 +118,108 @@ function write(value) {
   process.stdout.write(`${JSON.stringify(value)}\n`);
 }
 
-async function dispatchAutoAck(state, pullRequest) {
-  const pending = await stateCommand(state, "list");
-  if (!pending.pending.some((batch) => batch.pullRequest === pullRequest)) {
-    write({ ok: true, type: "queued", pullRequest, reason: "batch-not-yet-eligible" });
-    return;
+function fileIdentity(filePath) {
+  try {
+    const stat = lstatSync(filePath);
+    return { dev: stat.dev, ino: stat.ino };
+  } catch {
+    return null;
+  }
+}
+
+function unlinkIfOwned(filePath, identity) {
+  const current = fileIdentity(filePath);
+  if (!identity || !current || current.dev !== identity.dev || current.ino !== identity.ino) return;
+  try {
+    unlinkSync(filePath);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+
+function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+
+function lockOwner(lockPath) {
+  try {
+    const value = JSON.parse(readFileSync(lockPath, "utf8"));
+    return Number.isInteger(value?.pid) && value.pid > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function acquireDriverLock(state) {
+  const canonicalState = realpathSync(state);
+  const lockPath = `${canonicalState}${DRIVER_LOCK_SUFFIX}`;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const stagingPath = `${lockPath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(
+        stagingPath,
+        `${JSON.stringify({ pid: process.pid, state: canonicalState, startedAt: new Date().toISOString() })}\n`,
+        { flag: "wx", mode: 0o600 },
+      );
+      chmodSync(stagingPath, 0o600);
+      linkSync(stagingPath, lockPath);
+    } catch (error) {
+      try {
+        unlinkSync(stagingPath);
+      } catch (unlinkError) {
+        if (unlinkError.code !== "ENOENT") throw unlinkError;
+      }
+      if (error.code !== "EEXIST") throw error;
+      const observedIdentity = fileIdentity(lockPath);
+      const owner = lockOwner(lockPath);
+      // Preserve unreadable locks rather than risking two live drivers.
+      if (!owner || processIsAlive(owner.pid)) {
+        throw new DriverError(
+          "Another watch-driver process already owns this task state",
+          EXIT_ALREADY_RUNNING,
+          {
+            state: canonicalState,
+            lockPath,
+            ownerPid: owner?.pid ?? null,
+          },
+        );
+      }
+      unlinkIfOwned(lockPath, observedIdentity);
+      continue;
+    }
+    try {
+      const identity = fileIdentity(lockPath);
+      if (!identity) throw new Error("Could not verify the watch-driver owner lock");
+      unlinkSync(stagingPath);
+      return { identity, path: lockPath };
+    } catch (error) {
+      const stagingIdentity = fileIdentity(stagingPath);
+      unlinkIfOwned(lockPath, stagingIdentity);
+      try {
+        unlinkSync(stagingPath);
+      } catch (unlinkError) {
+        if (unlinkError.code !== "ENOENT") throw unlinkError;
+      }
+      throw error;
+    }
   }
+  throw new DriverError("Could not acquire the watch-driver owner lock", EXIT_ALREADY_RUNNING, {
+    state: canonicalState,
+    lockPath,
+  });
+}
+
+function releaseDriverLock(lock) {
+  unlinkIfOwned(lock.path, lock.identity);
+}
+
+async function dispatchAutoAck(state, pullRequest) {
   const result = await runNodeScript(autoAckScript, [
     "--state",
     state,
@@ -104,14 +232,21 @@ async function dispatchAutoAck(state, pullRequest) {
   write({ ...result.json, type: "batch-acknowledged" });
 }
 
-async function dispatchPendingAutoAcks(state) {
-  const pending = await stateCommand(state, "list");
-  for (const batch of pending.pending) {
+async function dispatchPendingAutoAcks(state, maxInFlight) {
+  const work = await stateCommand(state, "list");
+  const inFlight = Number(work.inFlight);
+  if (!Number.isSafeInteger(inFlight) || inFlight < 0 || !Array.isArray(work.pending)) {
+    throw new DriverError("watch-state list returned invalid work capacity", EXIT_INGEST, work);
+  }
+  let available = Math.max(0, maxInFlight - inFlight);
+  for (const batch of work.pending) {
+    if (available === 0) break;
     await dispatchAutoAck(state, batch.pullRequest);
+    available -= 1;
   }
 }
 
-async function processFrame(state, frame, autoAck, pullRequests) {
+async function processFrame(state, frame, autoAck, maxInFlight) {
   if (!frame || typeof frame !== "object" || typeof frame.type !== "string") {
     throw new DriverError("Invalid RFC 7464 frame", EXIT_SEQUENCE, frame);
   }
@@ -127,10 +262,10 @@ async function processFrame(state, frame, autoAck, pullRequests) {
       databaseId: frame.databaseId,
       anchoredAtCurrent: frame.anchoredAtCurrent,
       autoAck,
+      maxInFlight: autoAck ? maxInFlight : null,
     });
   } else if (frame.type === "comment-posted" && ingested.status === "queued") {
-    if (autoAck) pullRequests.add(frame.event.pullRequestUrl);
-    else {
+    if (!autoAck) {
       write({
         ok: true,
         type: "pending",
@@ -142,7 +277,16 @@ async function processFrame(state, frame, autoAck, pullRequests) {
   }
 }
 
-async function runWatchOnce(state, autoAck, stopping) {
+function autoAckPollMilliseconds() {
+  const configured = Number(
+    process.env.RVW_WATCH_AUTO_ACK_POLL_MS ?? String(DEFAULT_AUTO_ACK_POLL_MS),
+  );
+  return Number.isSafeInteger(configured) && configured >= 10 && configured <= 60_000
+    ? configured
+    : DEFAULT_AUTO_ACK_POLL_MS;
+}
+
+async function runWatchOnce(state, autoAck, maxInFlight, stopping) {
   const current = await stateCommand(state, "status");
   const args = ["comment", "watch"];
   if (current.cursor) args.push("--after", current.cursor);
@@ -160,6 +304,25 @@ async function runWatchOnce(state, autoAck, stopping) {
     child.once("close", (code, signal) => resolve({ code, signal }));
   });
   child.stdin.end();
+  let autoAckPump = null;
+  let autoAckError = null;
+  const pumpAutoAcks = async () => {
+    if (!autoAck || stopping.requested) return;
+    if (autoAckPump) return autoAckPump;
+    autoAckPump = dispatchPendingAutoAcks(state, maxInFlight);
+    try {
+      await autoAckPump;
+    } catch (error) {
+      autoAckError ??= error;
+      child.kill("SIGTERM");
+      throw error;
+    } finally {
+      autoAckPump = null;
+    }
+  };
+  const autoAckTimer = autoAck
+    ? setInterval(() => void pumpAutoAcks().catch(() => undefined), autoAckPollMilliseconds())
+    : null;
   const decoder = new StringDecoder("utf8");
   let buffered = "";
   let readySeen = false;
@@ -169,7 +332,6 @@ async function runWatchOnce(state, autoAck, stopping) {
       buffered += decoder.write(chunk);
       const lines = buffered.split("\n");
       buffered = lines.pop() ?? "";
-      const pullRequests = new Set();
       for (const rawLine of lines) {
         if (!rawLine) continue;
         if (!rawLine.startsWith("\u001e")) {
@@ -183,9 +345,9 @@ async function runWatchOnce(state, autoAck, stopping) {
         }
         readySeen ||= frame.type === "ready";
         stoppedSeen ||= frame.type === "stopped";
-        await processFrame(state, frame, autoAck, pullRequests);
+        await processFrame(state, frame, autoAck, maxInFlight);
       }
-      for (const pullRequest of pullRequests) await dispatchAutoAck(state, pullRequest);
+      await pumpAutoAcks();
     }
     buffered += decoder.end();
     if (buffered.trim()) {
@@ -196,6 +358,8 @@ async function runWatchOnce(state, autoAck, stopping) {
       );
     }
     const status = await statusPromise;
+    if (autoAckPump) await autoAckPump.catch(() => undefined);
+    if (autoAckError) throw autoAckError;
     stopping.child = null;
     return { ...status, stderr, readySeen, stoppedSeen };
   } catch (error) {
@@ -203,6 +367,8 @@ async function runWatchOnce(state, autoAck, stopping) {
     await statusPromise.catch(() => undefined);
     stopping.child = null;
     throw error;
+  } finally {
+    if (autoAckTimer) clearInterval(autoAckTimer);
   }
 }
 
@@ -217,42 +383,51 @@ function delay(milliseconds) {
 }
 
 async function main() {
-  const { state, autoAck } = parseArguments(process.argv.slice(2));
-  const stopping = { requested: false, child: null };
-  const stop = () => {
-    stopping.requested = true;
-    stopping.child?.kill("SIGTERM");
-  };
-  process.once("SIGINT", stop);
-  process.once("SIGTERM", stop);
-  const maxRestarts = Number(process.env.RVW_WATCH_DRIVER_MAX_RESTARTS ?? "5");
-  let restarts = 0;
+  const { state, autoAck, maxInFlight } = parseArguments(process.argv.slice(2));
+  const driverLock = acquireDriverLock(state);
   try {
-    while (!stopping.requested) {
-      const startedAt = Date.now();
-      if (autoAck) await dispatchPendingAutoAcks(state);
-      const result = await runWatchOnce(state, autoAck, stopping);
-      if (stopping.requested) return;
-      if (Date.now() - startedAt >= 30_000) restarts = 0;
-      restarts += 1;
-      if (restarts > maxRestarts) {
-        throw new DriverError("rvw comment watch exceeded its reconnect limit", EXIT_WATCH, result);
+    const stopping = { requested: false, child: null };
+    const stop = () => {
+      stopping.requested = true;
+      stopping.child?.kill("SIGTERM");
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    const maxRestarts = Number(process.env.RVW_WATCH_DRIVER_MAX_RESTARTS ?? "5");
+    let restarts = 0;
+    try {
+      while (!stopping.requested) {
+        const startedAt = Date.now();
+        if (autoAck) await dispatchPendingAutoAcks(state, maxInFlight);
+        const result = await runWatchOnce(state, autoAck, maxInFlight, stopping);
+        if (stopping.requested) return;
+        if (Date.now() - startedAt >= 30_000) restarts = 0;
+        restarts += 1;
+        if (restarts > maxRestarts) {
+          throw new DriverError(
+            "rvw comment watch exceeded its reconnect limit",
+            EXIT_WATCH,
+            result,
+          );
+        }
+        const delayMs = retryDelay(restarts);
+        write({
+          ok: true,
+          type: "reconnecting",
+          attempt: restarts,
+          delayMs,
+          lastExitCode: result.code,
+          lastSignal: result.signal,
+          readySeen: result.readySeen,
+        });
+        await delay(delayMs);
       }
-      const delayMs = retryDelay(restarts);
-      write({
-        ok: true,
-        type: "reconnecting",
-        attempt: restarts,
-        delayMs,
-        lastExitCode: result.code,
-        lastSignal: result.signal,
-        readySeen: result.readySeen,
-      });
-      await delay(delayMs);
+    } finally {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
     }
   } finally {
-    process.off("SIGINT", stop);
-    process.off("SIGTERM", stop);
+    releaseDriverLock(driverLock);
   }
 }
 

package/skills/rvw-watch-comments/scripts/watch-state.mjs

@@ -68,7 +68,8 @@ function openState(statePath, create) {
     fail(`State database does not exist: ${absolute}`);
   }
   const database = new DatabaseSync(absolute);
-  database.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
+  database.exec("PRAGMA busy_timeout = 5000;");
+  database.exec("PRAGMA journal_mode = WAL;");
   database.exec(`
     CREATE TABLE IF NOT EXISTS meta (
       key TEXT PRIMARY KEY,
@@ -455,6 +456,16 @@ function listPending(database) {
     });
 }
 
+function listWork(database) {
+  const inFlight = database
+    .prepare("SELECT count(*) AS count FROM batches WHERE status = 'in_flight'")
+    .get();
+  return {
+    inFlight: Number(inFlight.count),
+    pending: listPending(database),
+  };
+}
+
 async function waitForPending(database, options) {
   const intervalMs = positiveIntegerOption(options, "interval-ms", 250);
   const follow = options.follow === true;
@@ -822,7 +833,7 @@ async function main() {
       return;
     }
     if (command === "list") {
-      write({ ok: true, pending: listPending(database) });
+      write({ ok: true, ...listWork(database) });
       return;
     }
     if (command === "wait") {