@agentsdance/codejury 0.1.0

package/lib/repository.js

@@ -0,0 +1,185 @@
+// Bind a PR URL to the checkout that jury is about to read and modify.
+//
+// A URL is not just a label. Letting it name one repository while every git
+// command runs in another can review, commit, and push unrelated code under the
+// PR's name. Keep this check independent of a hosting CLI so it also works for
+// self-hosted GitHub and GitLab instances.
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const run = promisify(execFile);
+
+function normalized(host, pathname) {
+  const path = pathname
+    .replace(/^\/+|\/+$/g, "")
+    .replace(/\.git$/i, "");
+  if (!host || !path) return null;
+  return { host: host.toLowerCase(), path, display: `${host.toLowerCase()}/${path}` };
+}
+
+/** Repository identity carried by a GitHub or GitLab-style PR URL. */
+export function repositoryFromPrUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+
+  const parts = url.pathname.split("/").filter(Boolean);
+  const marker = parts.findIndex((p) => p === "pull" || p === "merge_requests");
+  if (marker < 2 || !/^\d+$/.test(parts[marker + 1] ?? "")) return null;
+
+  const repo = parts.slice(0, marker);
+  // Canonical GitLab links use /group/project/-/merge_requests/123.
+  if (repo.at(-1) === "-") repo.pop();
+  if (repo.length < 2) return null;
+  return normalized(url.hostname, repo.join("/"));
+}
+
+/** Repository identity carried by an HTTPS, SSH URL, or scp-style git remote. */
+export function repositoryFromRemote(value) {
+  const remote = String(value ?? "").trim();
+  const scp = remote.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
+  if (scp && !/^[a-z][a-z\d+.-]*:\/\//i.test(remote)) {
+    return normalized(scp[1], scp[2]);
+  }
+
+  try {
+    const url = new URL(remote);
+    return normalized(url.hostname, url.pathname);
+  } catch {
+    return null;
+  }
+}
+
+/** Refuse to let a PR URL label operations in an unrelated local checkout. */
+export function assertPrCheckout(prUrl, remoteUrl, dir) {
+  const target = repositoryFromPrUrl(prUrl);
+  if (!target) {
+    throw new Error(`cannot identify a pull request repository from "${prUrl}"`);
+  }
+
+  const checkout = repositoryFromRemote(remoteUrl);
+  if (!checkout) {
+    throw new Error(
+      `PR targets ${target.display}, but ${dir} has no identifiable origin — ` +
+      `run from that repository or pass --dir /path/to/its/checkout`,
+    );
+  }
+
+  if (checkout.host !== target.host || checkout.path !== target.path) {
+    throw new Error(
+      `PR targets ${target.display}, but ${dir} is ${checkout.display} — ` +
+      `run from the target repository or pass --dir /path/to/${target.path.split("/").at(-1)}`,
+    );
+  }
+}
+
+function githubNumber(prUrl) {
+  try {
+    const parts = new URL(prUrl).pathname.split("/").filter(Boolean);
+    const marker = parts.indexOf("pull");
+    return marker >= 0 && /^\d+$/.test(parts[marker + 1] ?? "") ? parts[marker + 1] : null;
+  } catch {
+    return null;
+  }
+}
+
+function remoteForRepository(origin, repoPath) {
+  const scp = String(origin).match(/^((?:[^@/\s]+@)?[^:/\s]+):(.+)$/);
+  if (scp && !/^[a-z][a-z\d+.-]*:\/\//i.test(origin)) return `${scp[1]}:${repoPath}.git`;
+  const url = new URL(origin);
+  url.pathname = `/${repoPath}.git`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+
+/**
+ * Resolve a GitHub PR to an isolated checkout of its exact head.
+ *
+ * The checkout is a clone rather than a mutation of the caller's repository:
+ * running `jury <url>` from master (or from an unrelated repo) must not switch
+ * that working tree out from under the user. The returned cleanup is owned by
+ * the CLI and runs after the review finishes or fails.
+ */
+export async function resolvePrCheckout(prUrl, {
+  allowPush = true,
+  exec = run,
+  makeTemp = mkdtemp,
+  remove = (dir) => rm(dir, { recursive: true, force: true }),
+} = {}) {
+  const target = repositoryFromPrUrl(prUrl);
+  const number = githubNumber(prUrl);
+  if (!target || !number) {
+    throw new Error(
+      `cannot resolve the PR head from "${prUrl}" automatically — ` +
+      "run from its checked-out branch with --dir, or use a GitHub pull request URL",
+    );
+  }
+
+  let details;
+  try {
+    const { stdout } = await exec("gh", [
+      "pr", "view", prUrl, "--json",
+      "title,body,state,baseRefName,headRefName,headRefOid,headRepository",
+    ]);
+    details = JSON.parse(stdout);
+  } catch (err) {
+    throw new Error(
+      `could not resolve ${target.display} pull request #${number}: ${String(err.message).split("\n")[0]} — ` +
+      "check gh authentication, or check out the PR and pass --dir",
+    );
+  }
+
+  const headRepo = details.headRepository?.nameWithOwner;
+  if (!details.headRefOid || !details.headRefName || !details.baseRefName || !headRepo) {
+    throw new Error(`pull request #${number} does not expose a usable head branch`);
+  }
+  if (allowPush && details.state !== "OPEN") {
+    throw new Error(
+      `pull request #${number} is ${String(details.state).toLowerCase()} — ` +
+      "use --no-push for a read-only review",
+    );
+  }
+
+  const worktree = await makeTemp(path.join(tmpdir(), `jury-pr-${number}-`));
+  try {
+    await exec("gh", ["repo", "clone", target.display, worktree, "--", "--quiet"]);
+    await exec("git", ["fetch", "--quiet", "origin", `refs/pull/${number}/head`], { cwd: worktree });
+    await exec("git", ["checkout", "--quiet", "-b", `jury-pr-${number}`, "FETCH_HEAD"], { cwd: worktree });
+
+    const { stdout: actual } = await exec("git", ["rev-parse", "HEAD"], { cwd: worktree });
+    if (actual.trim() !== details.headRefOid) {
+      throw new Error(
+        `resolved PR head ${details.headRefOid.slice(0, 12)}, but checked out ${actual.trim().slice(0, 12)}`,
+      );
+    }
+
+    const { stdout: origin } = await exec("git", ["remote", "get-url", "origin"], { cwd: worktree });
+    let pushRemote = "origin";
+    if (headRepo !== target.path) {
+      pushRemote = "pr-head";
+      await exec("git", ["remote", "add", pushRemote, remoteForRepository(origin.trim(), headRepo)], { cwd: worktree });
+    }
+
+    return {
+      worktree,
+      title: details.title || undefined,
+      summary: details.body ? details.body.replace(/\r/g, "").trim().slice(0, 4000) : undefined,
+      state: details.state,
+      trunk: details.baseRefName,
+      branch: details.headRefName,
+      sha: details.headRefOid,
+      pushTarget: { remote: pushRemote, branch: details.headRefName },
+      cleanup: () => remove(worktree),
+    };
+  } catch (err) {
+    await remove(worktree);
+    throw err;
+  }
+}

package/lib/server.js

@@ -0,0 +1,224 @@
+// The console server. Serves web/ and the runs found on disk.
+import http from "node:http";
+import { readFile, stat, open } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { listRuns, runsDir, readEvents, foldEvents } from "./store.js";
+import { conversation } from "./loop.js";
+import { watch } from "node:fs";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const webRoot = path.join(here, "..", "web");
+
+const TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+};
+
+export async function serve({ port = 3080, cwd = process.cwd(), onLog = console.log } = {}) {
+  const base = runsDir(cwd);
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, "http://localhost");
+    res.setHeader("Cache-Control", "no-store");
+
+    try {
+      if (url.pathname === "/api/run" || url.pathname === "/api/runs") {
+        // Read per request. A run is written while the console is already up,
+        // so anything resolved once at boot would never be picked up.
+        const { runs, skipped } = await listRuns(base);
+        for (const s of skipped) onLog(`skipped ${s.dir}: ${s.reason}`);
+        if (runs.length === 0) return json(res, 404, { error: "no runs yet" });
+        return json(res, 200, runs.length === 1 ? runs[0] : { targets: runs });
+      }
+
+      // The conversation, folded per reviewer. Same event log the timeline
+      // reads — a thread is derived, never stored, so a replayed run shows the
+      // exact exchange that happened rather than a summary written afterwards.
+      if (url.pathname === "/api/conversation") {
+        const slug = path.basename(url.searchParams.get("run") ?? "");
+        if (!slug) return json(res, 400, { error: "run is required" });
+        const events = await readEvents(path.join(base, slug));
+        return json(res, 200, { slug, threads: conversation(events) });
+      }
+
+      // Live stream. Polling was fine for a finished run and useless for a
+      // live one: a reviewer talks for twenty minutes and the console has
+      // nothing to show until it exits. Here every appended event is pushed as
+      // it lands, so the conversation appears at the speed it is spoken.
+      if (url.pathname === "/api/stream") {
+        const slug = path.basename(url.searchParams.get("run") ?? "");
+        if (!slug) return json(res, 400, { error: "run is required" });
+        return stream(res, path.join(base, slug), slug, onLog);
+      }
+
+      // Verbatim artifacts: the prompt a reviewer was given, the stream it
+      // produced. Both names are validated against the run directory rather
+      // than trusted, since they arrive from the query string.
+      if (url.pathname === "/api/raw") {
+        const slug = path.basename(url.searchParams.get("run") ?? "");
+        const name = path.basename(url.searchParams.get("file") ?? "");
+        if (!slug || !name) return json(res, 400, { error: "run and file are required" });
+        const file = path.join(base, slug, name);
+        if (!file.startsWith(path.join(base, slug) + path.sep)) {
+          return json(res, 403, { error: "forbidden" });
+        }
+        const body = await readFile(file, "utf8");
+        res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+        return res.end(body);
+      }
+
+      if (url.pathname === "/api/health") {
+        const { runs, skipped } = await listRuns(base);
+        // assets carries index.html's mtime so an open page can notice the page
+        // itself changed and reload, instead of silently serving a stale build.
+        let assets = "";
+        try {
+          assets = String((await stat(path.join(webRoot, "index.html"))).mtimeMs);
+        } catch { /* embedded/missing is fine */ }
+        return json(res, 200, {
+          ok: true, runs: runs.length, skipped: skipped.length, dir: base, assets,
+        });
+      }
+
+      // static
+      const rel = url.pathname === "/" ? "index.html" : url.pathname.replace(/^\/+/, "");
+      const file = path.join(webRoot, rel);
+      if (!file.startsWith(webRoot)) return json(res, 403, { error: "forbidden" });
+      const body = await readFile(file);
+      res.writeHead(200, { "Content-Type": TYPES[path.extname(file)] ?? "application/octet-stream" });
+      res.end(body);
+    } catch (err) {
+      if (err.code === "ENOENT") return json(res, 404, { error: "not found" });
+      json(res, 500, { error: err.message });
+    }
+  });
+
+  const bound = await listen(server, port, onLog);
+  return { server, port: bound, url: `http://127.0.0.1:${bound}` };
+}
+
+function json(res, code, body) {
+  res.writeHead(code, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+
+// Walk forward rather than dying on "address already in use".
+function listen(server, port, onLog) {
+  return new Promise((resolve, reject) => {
+    let p = port;
+    const attempt = () => {
+      server.once("error", (err) => {
+        if (err.code === "EADDRINUSE" && p < port + 20) {
+          onLog(`port ${p} busy, trying ${p + 1}`);
+          p += 1;
+          attempt();
+        } else reject(err);
+      });
+      server.listen(p, "127.0.0.1", () => resolve(p));
+    };
+    attempt();
+  });
+}
+
+/**
+ * Server-sent events over the run's append-only log.
+ *
+ * The log is the transport. Nothing here holds run state: on connect the whole
+ * file is replayed so a page opened mid-run catches up, then fs.watch drives
+ * incremental reads from the last byte offset. Because the log only ever grows,
+ * "what is new" is a file length comparison rather than a diff.
+ */
+async function stream(res, dir, slug, onLog) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream; charset=utf-8",
+    "Cache-Control": "no-cache, no-transform",
+    Connection: "keep-alive",
+    // The console is same-origin, but a proxy that buffers would defeat the
+    // entire point of streaming.
+    "X-Accel-Buffering": "no",
+  });
+
+  const file = path.join(dir, "events.ndjson");
+  let offset = 0;
+  let closed = false;
+  let reading = false;
+  let again = false;
+
+  const send = (event, data) => {
+    if (closed) return;
+    res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+  };
+
+  // Reads are serialised: fs.watch fires several times for one append, and two
+  // concurrent readers would both start from the same offset and emit the same
+  // lines twice.
+  const pump = async () => {
+    if (closed) return;
+    if (reading) { again = true; return; }
+    reading = true;
+    try {
+      const { size } = await stat(file).catch(() => ({ size: 0 }));
+      if (size > offset) {
+        const fh = await open(file, "r");
+        try {
+          const len = size - offset;
+          const buf = Buffer.alloc(len);
+          await fh.read(buf, 0, len, offset);
+          const text = buf.toString("utf8");
+          // A partial final line means an append landed mid-write. Leave it in
+          // the stream and pick it up on the next pump rather than emitting
+          // half an event.
+          const cut = text.lastIndexOf("\n");
+          if (cut >= 0) {
+            offset += Buffer.byteLength(text.slice(0, cut + 1), "utf8");
+            for (const line of text.slice(0, cut).split("\n")) {
+              if (!line.trim()) continue;
+              try { send("event", JSON.parse(line)); } catch { /* torn line */ }
+            }
+          }
+        } finally {
+          await fh.close().catch(() => {});
+        }
+      } else if (size < offset) {
+        // Truncated or replaced underneath us — restart rather than serve
+        // nonsense from a stale offset.
+        offset = 0;
+        again = true;
+      }
+    } catch (err) {
+      onLog?.(`stream ${slug}: ${err.message}`);
+    } finally {
+      reading = false;
+      if (again && !closed) { again = false; await pump(); }
+    }
+  };
+
+  await pump();
+  send("ready", { slug });
+
+  let watcher = null;
+  try {
+    watcher = watch(dir, () => { pump(); });
+  } catch { /* fall back to the interval alone */ }
+  // fs.watch is unreliable on some filesystems (and silent on network mounts),
+  // so a slow poll backs it up. It is a safety net, not the mechanism.
+  const poll = setInterval(pump, 1000);
+  // Comment frames keep intermediaries from reaping an idle connection during
+  // a long agent turn.
+  const beat = setInterval(() => { if (!closed) res.write(": ping\n\n"); }, 15000);
+
+  const done = () => {
+    if (closed) return;
+    closed = true;
+    clearInterval(poll);
+    clearInterval(beat);
+    watcher?.close();
+    res.end();
+  };
+  res.on("close", done);
+  res.on("error", done);
+}