vibe-coding-master 0.8.13 → 0.9.0

package/scripts/harness-tools/watch-job

@@ -1,258 +1,333 @@
-#!/usr/bin/env python3
-"""Watch one VCM long-running validation job in the foreground.
-
-Usage:
-  .ai/tools/watch-job <job-id> [--window <duration>] [--interval <duration>]
-
-watch-job renews the job supervision lease while it runs. When the watch
-window elapses and the job is still running, it exits 125 WITHOUT stopping
-the job and grants a bounded handoff for the next watcher; call watch-job
-again immediately in the same turn. The job ceiling itself is enforced by
-the run-long-check worker, not by watch-job.
-
-Exit codes:
-  0    success
-  1    failed
-  124  timeout (job hit its ceiling and was killed by the worker)
-  125  still running; call watch-job again now
-  4    orphaned or stale (job lost supervision and was killed, or its worker died)
-  2    usage error or unknown job id
-"""
-import argparse
-import json
-import os
-import sys
-import time
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-
-MAX_WINDOW_SECONDS = 8 * 60
-DEFAULT_WINDOW = "8m"
-STATUS_WAIT_SECONDS = 10
-DEFAULT_NEXT_WATCH_HANDOFF_GRACE_SECONDS = 5 * 60
-TERMINAL_EXIT_CODES = {
-    "success": 0,
-    "failed": 1,
-    "timeout": 124,
-    "orphaned": 4,
-    "stale": 4,
+#!/usr/bin/env node
+"use strict";
+// Watch one VCM long-running validation job in the foreground.
+//
+// Usage:
+//   .ai/tools/watch-job <job-id> [--window <duration>] [--interval <duration>]
+//
+// watch-job renews the job supervision lease while it runs. When the watch
+// window elapses and the job is still running, it exits 125 WITHOUT stopping
+// the job and grants a bounded handoff for the next watcher; call watch-job
+// again immediately in the same turn. The job ceiling itself is enforced by
+// the run-long-check worker, not by watch-job.
+//
+// Exit codes:
+//   0    success
+//   1    failed
+//   124  timeout (job hit its ceiling and was killed by the worker)
+//   125  still running; call watch-job again now
+//   4    orphaned or stale (job lost supervision and was killed, or its worker died)
+//   2    usage error or unknown job id
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const MAX_WINDOW_SECONDS = 8 * 60;
+const DEFAULT_WINDOW = "8m";
+const STATUS_WAIT_SECONDS = 10;
+const DEFAULT_NEXT_WATCH_HANDOFF_GRACE_SECONDS = 5 * 60;
+const TERMINAL_EXIT_CODES = { success: 0, failed: 1, timeout: 124, orphaned: 4, stale: 4 };
+const USAGE = "usage: watch-job [-h] [--window WINDOW] [--interval INTERVAL] job_id";
+
+function rootDir() {
+  return path.resolve(path.dirname(fs.realpathSync(__filename)), "..", "..");
 }
 
+function parseNumber(value) {
+  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(value)) {
+    throw new Error("could not convert string to float: '" + value + "'");
+  }
+  return Number(value);
+}
 
-def root_dir() -> Path:
-    return Path(__file__).resolve().parents[2]
-
-
-def parse_duration(value: str) -> float:
-    value = value.strip().lower()
-    if value.endswith("ms"):
-        return float(value[:-2]) / 1000
-    if value.endswith("s"):
-        return float(value[:-1])
-    if value.endswith("m"):
-        return float(value[:-1]) * 60
-    if value.endswith("h"):
-        return float(value[:-1]) * 3600
-    return float(value)
-
-
-def read_optional_json(path: Path) -> dict | None:
-    try:
-        return json.loads(path.read_text())
-    except (OSError, ValueError):
-        return None
-
-
-def write_json(path: Path, data: dict) -> None:
-    tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n")
-    tmp.replace(path)
-
-
-def env_seconds(name: str, default: float) -> float:
-    raw = os.environ.get(name)
-    if not raw:
-        return default
-    try:
-        return max(1.0, float(raw))
-    except ValueError:
-        return default
-
-
-def clear_handoff(handoff_path: Path) -> None:
-    try:
-        handoff_path.unlink()
-    except FileNotFoundError:
-        pass
-
-
-def begin_handoff(handoff_path: Path, grace_seconds: float) -> str:
-    now = datetime.now(timezone.utc)
-    due_at = (now + timedelta(seconds=grace_seconds)).isoformat().replace("+00:00", "Z")
-    write_json(
-        handoff_path,
-        {
-            "createdAt": now.isoformat().replace("+00:00", "Z"),
-            "nextWatchDueAt": due_at,
-        },
-    )
-    return due_at
-
-
-def renew_lease(lease_path: Path) -> None:
-    try:
-        lease_path.touch()
-    except OSError:
-        pass
-
-
-def tail(path: Path, lines: int = 40, max_bytes: int = 65536) -> str:
-    try:
-        size = path.stat().st_size
-    except OSError:
-        return ""
-    try:
-        with path.open("rb") as handle:
-            handle.seek(max(0, size - max_bytes))
-            data = handle.read(max_bytes)
-    except OSError:
-        return ""
-    text = data.decode("utf-8", errors="replace")
-    return "\n".join(text.splitlines()[-lines:])
-
-
-def elapsed_seconds(status: dict) -> float | None:
-    started_at = status.get("startedAt")
-    if not started_at:
-        return None
-    from datetime import datetime, timezone
-
-    try:
-        started = datetime.fromisoformat(str(started_at).replace("Z", "+00:00"))
-    except ValueError:
-        return None
-    return round((datetime.now(timezone.utc) - started).total_seconds(), 3)
+function parseDuration(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized.endsWith("ms")) {
+    return parseNumber(normalized.slice(0, -2)) / 1000;
+  }
+  if (normalized.endsWith("s")) {
+    return parseNumber(normalized.slice(0, -1));
+  }
+  if (normalized.endsWith("m")) {
+    return parseNumber(normalized.slice(0, -1)) * 60;
+  }
+  if (normalized.endsWith("h")) {
+    return parseNumber(normalized.slice(0, -1)) * 3600;
+  }
+  return parseNumber(normalized);
+}
 
+function sortKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeys);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortKeys(value[key])]));
+  }
+  return value;
+}
 
-def print_summary(job_id: str, status: dict, directory: Path) -> None:
-    state = status.get("status")
-    print(f"job: {job_id}")
-    print(f"status: {state}")
-    print(f"exitCode: {status.get('exitCode')}")
-    print(f"durationSeconds: {status.get('durationSeconds')}")
-    if state == "timeout":
-        print(f"timeoutSeconds: {status.get('timeoutSeconds')}")
-        print(f"processStopResult: {status.get('processStopResult')}")
-    if state == "orphaned":
-        print(f"orphanReason: {status.get('orphanReason')}")
-        print(f"lastWatchedAt: {status.get('lastWatchedAt')}")
-        if status.get("nextWatchDueAt"):
-            print(f"nextWatchDueAt: {status.get('nextWatchDueAt')}")
-        print(f"processStopResult: {status.get('processStopResult')}")
-    if state == "stale":
-        print(f"staleReason: {status.get('staleReason')}")
+function readOptionalJson(target) {
+  try {
+    return JSON.parse(fs.readFileSync(target, "utf8"));
+  } catch {
+    return null;
+  }
+}
 
-    if state in {"failed", "timeout", "orphaned", "stale"}:
-        stdout_tail = tail(directory / "stdout.log")
-        stderr_tail = tail(directory / "stderr.log")
-        if stdout_tail:
-            print("\nstdout tail:")
-            print(stdout_tail)
-        if stderr_tail:
-            print("\nstderr tail:")
-            print(stderr_tail)
+function writeJson(target, data) {
+  const temporary = target + ".tmp";
+  fs.writeFileSync(temporary, JSON.stringify(sortKeys(data), null, 2) + "\n");
+  fs.renameSync(temporary, target);
+}
 
+function envSeconds(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) {
+    return fallback;
+  }
+  try {
+    return Math.max(1, parseNumber(raw));
+  } catch {
+    return fallback;
+  }
+}
 
-def print_progress(job_id: str, status: dict, directory: Path, window: float, next_watch_due_at: str) -> None:
-    print(f"job: {job_id}")
-    print("status: still-running")
-    print(f"jobStatus: {status.get('status')}")
-    elapsed = elapsed_seconds(status)
-    if elapsed is not None:
-        print(f"elapsedSeconds: {elapsed}")
-        ceiling = status.get("timeoutSeconds")
-        if isinstance(ceiling, (int, float)):
-            print(f"ceilingRemainingSeconds: {max(0, round(ceiling - elapsed))}")
-    print(f"watchWindowSeconds: {int(window)}")
-    print(f"nextWatchDueAt: {next_watch_due_at}")
-    stdout_tail = tail(directory / "stdout.log", lines=5)
-    if stdout_tail:
-        print("\nstdout tail:")
-        print(stdout_tail)
-    print("\njob still running - call .ai/tools/watch-job again now; do not end the turn.")
+function sleepSeconds(seconds) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.max(0, seconds * 1000));
+}
 
+function clearHandoff(handoffPath) {
+  fs.rmSync(handoffPath, { force: true });
+}
 
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        description="Watch a file-backed long-running validation job."
-    )
-    parser.add_argument("job_id")
-    parser.add_argument("--window", default=DEFAULT_WINDOW)
-    parser.add_argument("--interval", default="1s")
-    parser.add_argument("--timeout", dest="legacy_timeout", default=None, help=argparse.SUPPRESS)
-    args = parser.parse_args()
+function beginHandoff(handoffPath, graceSeconds) {
+  const now = new Date();
+  const dueAt = new Date(now.getTime() + graceSeconds * 1000).toISOString();
+  writeJson(handoffPath, { createdAt: now.toISOString(), nextWatchDueAt: dueAt });
+  return dueAt;
+}
 
-    if args.legacy_timeout is not None:
-        print(
-            "error: watch-job no longer takes --timeout; the job ceiling is set by"
-            " run-long-check --timeout. Use --window (max 8m) and call watch-job"
-            " repeatedly until it reports a terminal result.",
-            file=sys.stderr,
-        )
-        return 2
+function renewLease(leasePath) {
+  try {
+    const now = new Date();
+    try {
+      fs.utimesSync(leasePath, now, now);
+    } catch {
+      fs.closeSync(fs.openSync(leasePath, "a"));
+    }
+  } catch {
+    // A lease that cannot be renewed lets the worker reap the job.
+  }
+}
 
-    try:
-        window = parse_duration(args.window)
-        interval = parse_duration(args.interval)
-    except ValueError as exc:
-        print(f"error: invalid duration: {exc}", file=sys.stderr)
-        return 2
-    if window <= 0 or interval <= 0:
-        print("error: window and interval must be positive", file=sys.stderr)
-        return 2
-    if window > MAX_WINDOW_SECONDS:
-        print("error: window exceeds maximum 8m; call watch-job repeatedly instead", file=sys.stderr)
-        return 2
+function tail(target, lines = 40, maxBytes = 65536) {
+  let size;
+  try {
+    size = fs.statSync(target).size;
+  } catch {
+    return "";
+  }
+  let data;
+  try {
+    const descriptor = fs.openSync(target, "r");
+    const length = Math.min(size, maxBytes);
+    data = Buffer.alloc(length);
+    fs.readSync(descriptor, data, 0, length, Math.max(0, size - maxBytes));
+    fs.closeSync(descriptor);
+  } catch {
+    return "";
+  }
+  return data.toString("utf8").split(/\r\n|\n|\r/).filter((line, index, all) => index < all.length - 1 || line !== "").slice(-lines).join("\n");
+}
 
-    directory = root_dir() / ".ai/vcm/jobs" / args.job_id
-    status_path = directory / "status.json"
-    lease_path = directory / "lease"
-    handoff_path = directory / "watch-handoff.json"
-    handoff_grace = env_seconds(
-        "VCM_JOB_NEXT_WATCH_HANDOFF_GRACE_SECONDS",
-        DEFAULT_NEXT_WATCH_HANDOFF_GRACE_SECONDS,
-    )
+// Matches the Python repr used in earlier tool output for status values.
+function display(value) {
+  if (value === null || value === undefined) {
+    return "None";
+  }
+  if (value === true) {
+    return "True";
+  }
+  if (value === false) {
+    return "False";
+  }
+  return String(value);
+}
 
-    found_deadline = time.time() + STATUS_WAIT_SECONDS
-    while not status_path.is_file():
-        if time.time() >= found_deadline:
-            print(f"error: unknown job id: {args.job_id} (no {status_path})", file=sys.stderr)
-            return 2
-        time.sleep(0.2)
+function elapsedSeconds(status) {
+  if (!status.startedAt) {
+    return null;
+  }
+  const started = Date.parse(String(status.startedAt));
+  return Number.isNaN(started) ? null : Math.round(Date.now() - started) / 1000;
+}
 
-    renew_lease(lease_path)
-    clear_handoff(handoff_path)
+function printSummary(jobId, status, directory) {
+  const state = status.status;
+  const lines = [
+    "job: " + jobId,
+    "status: " + display(state),
+    "exitCode: " + display(status.exitCode),
+    "durationSeconds: " + display(status.durationSeconds)
+  ];
+  if (state === "timeout") {
+    lines.push("timeoutSeconds: " + display(status.timeoutSeconds));
+    lines.push("processStopResult: " + display(status.processStopResult));
+  }
+  if (state === "orphaned") {
+    lines.push("orphanReason: " + display(status.orphanReason));
+    lines.push("lastWatchedAt: " + display(status.lastWatchedAt));
+    if (status.nextWatchDueAt) {
+      lines.push("nextWatchDueAt: " + status.nextWatchDueAt);
+    }
+    lines.push("processStopResult: " + display(status.processStopResult));
+  }
+  if (state === "stale") {
+    lines.push("staleReason: " + display(status.staleReason));
+  }
+  if (["failed", "timeout", "orphaned", "stale"].includes(state)) {
+    const stdoutTail = tail(path.join(directory, "stdout.log"));
+    const stderrTail = tail(path.join(directory, "stderr.log"));
+    if (stdoutTail) {
+      lines.push("\nstdout tail:", stdoutTail);
+    }
+    if (stderrTail) {
+      lines.push("\nstderr tail:", stderrTail);
+    }
+  }
+  process.stdout.write(lines.join("\n") + "\n");
+}
 
-    deadline = time.time() + window
-    last_status: dict = {}
-    while True:
-        renew_lease(lease_path)
-        status = read_optional_json(status_path)
-        if status:
-            last_status = status
-            state = status.get("status")
-            if state in TERMINAL_EXIT_CODES:
-                clear_handoff(handoff_path)
-                print_summary(args.job_id, status, directory)
-                return TERMINAL_EXIT_CODES[state]
+function printProgress(jobId, status, directory, windowSeconds, nextWatchDueAt) {
+  const lines = ["job: " + jobId, "status: still-running", "jobStatus: " + display(status.status)];
+  const elapsed = elapsedSeconds(status);
+  if (elapsed !== null) {
+    lines.push("elapsedSeconds: " + elapsed);
+    if (typeof status.timeoutSeconds === "number") {
+      lines.push("ceilingRemainingSeconds: " + Math.max(0, Math.round(status.timeoutSeconds - elapsed)));
+    }
+  }
+  lines.push("watchWindowSeconds: " + Math.trunc(windowSeconds));
+  lines.push("nextWatchDueAt: " + nextWatchDueAt);
+  const stdoutTail = tail(path.join(directory, "stdout.log"), 5);
+  if (stdoutTail) {
+    lines.push("\nstdout tail:", stdoutTail);
+  }
+  lines.push("\njob still running - call .ai/tools/watch-job again now; do not end the turn.");
+  process.stdout.write(lines.join("\n") + "\n");
+}
 
-        if time.time() >= deadline:
-            next_watch_due_at = begin_handoff(handoff_path, handoff_grace)
-            print_progress(args.job_id, last_status, directory, window, next_watch_due_at)
-            return 125
+function usageError(message) {
+  process.stderr.write(USAGE + "\nwatch-job: error: " + message + "\n");
+  process.exit(2);
+}
 
-        time.sleep(interval)
+function parseArgs(argv) {
+  const args = { jobId: undefined, window: DEFAULT_WINDOW, interval: "1s", legacyTimeout: undefined };
+  const optionNames = { "--window": "window", "--interval": "interval", "--timeout": "legacyTimeout" };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "-h" || argument === "--help") {
+      process.stdout.write(USAGE + "\n\nWatch a file-backed long-running validation job.\n");
+      process.exit(0);
+    }
+    const separator = argument.indexOf("=");
+    const name = argument.startsWith("--") && separator >= 0 ? argument.slice(0, separator) : argument;
+    if (optionNames[name]) {
+      let value;
+      if (separator >= 0 && argument.startsWith("--")) {
+        value = argument.slice(separator + 1);
+      } else {
+        if (index + 1 >= argv.length) {
+          usageError("argument " + name + ": expected one argument");
+        }
+        index += 1;
+        value = argv[index];
+      }
+      args[optionNames[name]] = value;
+      continue;
+    }
+    if (argument.startsWith("--") || args.jobId !== undefined) {
+      usageError("unrecognized arguments: " + argument);
+    }
+    args.jobId = argument;
+  }
+  if (args.jobId === undefined) {
+    usageError("the following arguments are required: job_id");
+  }
+  return args;
+}
 
+function main(argv) {
+  const args = parseArgs(argv);
+  if (args.legacyTimeout !== undefined) {
+    process.stderr.write(
+      "error: watch-job no longer takes --timeout; the job ceiling is set by"
+      + " run-long-check --timeout. Use --window (max 8m) and call watch-job"
+      + " repeatedly until it reports a terminal result.\n"
+    );
+    return 2;
+  }
+
+  let windowSeconds;
+  let intervalSeconds;
+  try {
+    windowSeconds = parseDuration(args.window);
+    intervalSeconds = parseDuration(args.interval);
+  } catch (error) {
+    process.stderr.write("error: invalid duration: " + error.message + "\n");
+    return 2;
+  }
+  if (windowSeconds <= 0 || intervalSeconds <= 0) {
+    process.stderr.write("error: window and interval must be positive\n");
+    return 2;
+  }
+  if (windowSeconds > MAX_WINDOW_SECONDS) {
+    process.stderr.write("error: window exceeds maximum 8m; call watch-job repeatedly instead\n");
+    return 2;
+  }
+
+  const directory = path.join(rootDir(), ".ai/vcm/jobs", args.jobId);
+  const statusPath = path.join(directory, "status.json");
+  const leasePath = path.join(directory, "lease");
+  const handoffPath = path.join(directory, "watch-handoff.json");
+  const handoffGrace = envSeconds("VCM_JOB_NEXT_WATCH_HANDOFF_GRACE_SECONDS", DEFAULT_NEXT_WATCH_HANDOFF_GRACE_SECONDS);
+
+  const foundDeadline = Date.now() + STATUS_WAIT_SECONDS * 1000;
+  while (!fs.existsSync(statusPath) || !fs.statSync(statusPath).isFile()) {
+    if (Date.now() >= foundDeadline) {
+      process.stderr.write("error: unknown job id: " + args.jobId + " (no " + statusPath + ")\n");
+      return 2;
+    }
+    sleepSeconds(0.2);
+  }
+
+  renewLease(leasePath);
+  clearHandoff(handoffPath);
+
+  const deadline = Date.now() + windowSeconds * 1000;
+  let lastStatus = {};
+  while (true) {
+    renewLease(leasePath);
+    const status = readOptionalJson(statusPath);
+    if (status) {
+      lastStatus = status;
+      if (Object.hasOwn(TERMINAL_EXIT_CODES, status.status)) {
+        clearHandoff(handoffPath);
+        printSummary(args.jobId, status, directory);
+        return TERMINAL_EXIT_CODES[status.status];
+      }
+    }
+
+    if (Date.now() >= deadline) {
+      const nextWatchDueAt = beginHandoff(handoffPath, handoffGrace);
+      printProgress(args.jobId, lastStatus, directory, windowSeconds, nextWatchDueAt);
+      return 125;
+    }
+
+    sleepSeconds(intervalSeconds);
+  }
+}
 
-if __name__ == "__main__":
-    raise SystemExit(main())
+process.exitCode = main(process.argv.slice(2));