carbonless-review 0.2.0 → 0.3.0-rc.10

package/dist/build-info.json

@@ -1,4 +1,4 @@
 {
-	"version": "0.2.0",
-	"commit": "f159e7d32a535e53cb2dd9d801429b580852bce4"
+	"version": "0.3.0-rc.10",
+	"commit": "4010c8c698544e8e1e9d385657fe1180dbfd8410"
 }

package/dist/client.js

@@ -7,6 +7,7 @@ import { parsePrArg, resolvePrRef } from "./server/gh.js";
 import { stateDir } from "./server/paths.js";
 import { parseHead } from "./server/pinnedHead.js";
 import { accessKey, readLiveServerState, } from "./server/serverState.js";
+import { parseTraceparent } from "./server/trace.js";
 import { BUILD, mismatchMessage, sameBuild, VERSION_HEADER, } from "./server/version.js";
 /**
  * `crb <pr>`, the thin client: finds this machine's `crb serve` through
@@ -148,6 +149,10 @@ export async function runClient(req, deps = {}) {
             headers: {
                 "content-type": "application/json",
                 [VERSION_HEADER]: JSON.stringify(build),
+                // The server's span of this open goes under the caller's (a test's).
+                ...(parseTraceparent(process.env.TRACEPARENT)
+                    ? { traceparent: process.env.TRACEPARENT }
+                    : {}),
                 ...(await authHeaders(server)),
             },
             body: JSON.stringify({

package/dist/server/agent/checkout.js

@@ -69,10 +69,15 @@ export async function createCheckout(cacheClone, reviewId, head) {
         },
     };
 }
+/**
+ * What a review's agent dir keeps across servers (see join.ts): the spawn
+ * flag, a joined session, and a leftover `acp-off` (ignored, never deleted).
+ */
+const KEEP = new Set(["acp-on", "acp-off", "joined.json"]);
 /**
  * Removes `<agentsDir>/<review id>` dirs not in `live` whose claim is free
- * or names a dead pid (left by a server that stopped). Other names are
- * left alone.
+ * or names a dead pid (left by a server that stopped), all but their
+ * `acp-on`, `acp-off` and `joined.json`. Other names are left alone.
  */
 export async function sweepStaleCheckouts(live) {
     let names;
@@ -89,7 +94,17 @@ export async function sweepStaleCheckouts(live) {
         const claim = await readClaim(dir);
         if (claim && pidAlive(claim.pid))
             return;
-        await rm(dir, { recursive: true, force: true });
+        // A joined session and the spawn flag outlive a server
+        // (join.ts): only they stay.
+        const entries = await readdir(dir).catch(() => []);
+        const kept = entries.filter((e) => KEEP.has(e));
+        if (kept.length === 0) {
+            await rm(dir, { recursive: true, force: true });
+            return;
+        }
+        await Promise.all(entries
+            .filter((e) => !KEEP.has(e))
+            .map((e) => rm(join(dir, e), { recursive: true, force: true })));
     }));
 }
 //# sourceMappingURL=checkout.js.map

package/dist/server/agent/claim.js

@@ -126,4 +126,59 @@ async function readText(path) {
         return null;
     }
 }
+/**
+ * A review's claim as one server shares it between its ACP runner and its
+ * joined session (the spec: "the existing claim also covers a joined
+ * session"): taken on the first hold, released when the last user drops.
+ */
+export class ReviewClaim {
+    dir;
+    self;
+    #users = new Set();
+    #release = null;
+    /** One take at a time (two users holding at once take once). */
+    #taking = null;
+    /** A release under way: a hold waits for it (else it sees its own claim as another's). */
+    #releasing = null;
+    constructor(dir, self) {
+        this.dir = dir;
+        this.self = self;
+    }
+    /** Whether this server holds the claim (for any user). */
+    held() {
+        return this.#release !== null;
+    }
+    /** Holds the claim for `user`; `{ ok: false, holder }` when another server has it. */
+    async hold(user) {
+        while (this.#releasing && !this.#release)
+            await this.#releasing;
+        if (!this.#release) {
+            this.#taking ??= takeClaim(this.dir, this.self()).finally(() => {
+                this.#taking = null;
+            });
+            const taken = await this.#taking;
+            if (!taken.ok)
+                return taken;
+            this.#release ??= taken.release;
+        }
+        this.#users.add(user);
+        return { ok: true, release: () => this.drop(user) };
+    }
+    /** `user` lets go; the claim is released once nobody holds it. */
+    async drop(user) {
+        this.#users.delete(user);
+        if (this.#users.size > 0 || !this.#release)
+            return;
+        const release = this.#release;
+        this.#release = null;
+        const releasing = release()
+            .catch(() => { })
+            .finally(() => {
+            if (this.#releasing === releasing)
+                this.#releasing = null;
+        });
+        this.#releasing = releasing;
+        await releasing;
+    }
+}
 //# sourceMappingURL=claim.js.map

package/dist/server/agent/githubJoin.js

@@ -0,0 +1,92 @@
+const OID = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
+/** The GitHub threads a conversation can still belong to: listed, with an id, not deleted. */
+export function liveGithubThreads(threads) {
+    const live = new Map();
+    for (const t of threads) {
+        if (t.id !== "" && t.unavailable !== "deleted")
+            live.set(t.id, t);
+    }
+    return live;
+}
+/**
+ * The folds as the page and the runner see them: a live thread
+ * conversation is resolved exactly when its GitHub thread is (its own
+ * agent-thread-resolved events count for nothing); one whose GitHub
+ * thread is gone (not listed, or deleted) is an orphan: a span thread on
+ * its recorded lines, resolved by its own events. Span threads pass
+ * through unchanged.
+ */
+export function joinGithub(folds, threads) {
+    const live = liveGithubThreads(threads);
+    return folds.map((f) => {
+        if (f.anchor.subject !== "thread")
+            return f;
+        const rt = live.get(f.anchor.thread);
+        if (rt)
+            return { ...f, resolved: rt.resolved };
+        return { ...f, anchor: orphanAnchor(f.anchor), orphaned: true };
+    });
+}
+/**
+ * The folds joined with the threads `read` gives, read only when a thread
+ * conversation is among them. When GitHub can't be read, thread
+ * conversations stay live (where their thread is), flagged
+ * `githubUnknown`, with their own stored `resolved`: never a made-up one.
+ */
+export async function joinRead(folds, read) {
+    if (!folds.some((f) => f.anchor.subject === "thread"))
+        return folds;
+    const threads = await read().catch(() => null);
+    if (threads)
+        return joinGithub(folds, threads);
+    return folds.map((f) => f.anchor.subject === "thread" ? { ...f, githubUnknown: true } : f);
+}
+/** The span anchor an orphan falls back to: line anchor on the recorded lines at `commit`, else a file anchor. */
+export function orphanAnchor(a) {
+    const { path, commit, side, line } = a;
+    if (commit === "" || side === undefined || line === undefined) {
+        return { subject: "file", path, commit };
+    }
+    // A start on another side, or none: as recorded, else the one line.
+    const start = a.startSide !== undefined && a.startLine !== undefined
+        ? { startSide: a.startSide, startLine: a.startLine }
+        : { startSide: side, startLine: line };
+    return { subject: "line", path, commit, side, line, ...start };
+}
+/**
+ * left/right of a view, from the session's patch sets and `base` (the
+ * snapshot's merge base): the right is the viewed patch set's head or the
+ * viewed head; the left is the compared-from patch set's head, or for the
+ * base branch the viewed patch set's merge base (a head's patch set's, else
+ * `base`). Null for a patch set that isn't one, or a head that isn't an OID.
+ */
+export function resolveView(view, patchsets, base) {
+    const ps = (n) => patchsets.find((p) => p.number === n);
+    let right;
+    let mergeBase;
+    if ("patchset" in view.target) {
+        const target = ps(view.target.patchset);
+        if (!target)
+            return null;
+        right = target.head;
+        mergeBase = target.mergeBase;
+    }
+    else {
+        const head = view.target.head;
+        if (!OID.test(head))
+            return null;
+        right = head;
+        mergeBase = patchsets.find((p) => p.head === head)?.mergeBase ?? base;
+    }
+    let left;
+    if ("branch" in view.from)
+        left = mergeBase;
+    else {
+        const from = ps(view.from.patchset);
+        if (!from)
+            return null;
+        left = from.head;
+    }
+    return { target: view.target, from: view.from, left, right };
+}
+//# sourceMappingURL=githubJoin.js.map