agent-dealer 1.2.10 → 1.2.12

package/bundle/server/dist/adapters/base-conflict-probe.test.js

@@ -0,0 +1,102 @@
+// packages/server/src/adapters/base-conflict-probe.test.ts
+//
+// NOT-355: the pre-publish base-conflict probe against real git — two branches
+// editing the same line of one file report `conflict` with that path; non-
+// overlapping edits report `clean`; neither touches the working tree or any ref.
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-probe-home-"));
+const { probeBaseConflict } = await import("./git-worktree.js");
+let repo;
+function git(cwd, ...args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
+}
+function commitFile(file, content, message) {
+    fs.writeFileSync(path.join(repo, file), content);
+    git(repo, "add", file);
+    git(repo, "commit", "-q", "-m", message);
+    return git(repo, "rev-parse", "HEAD");
+}
+before(() => {
+    repo = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-probe-repo-"));
+    git(repo, "init", "-q", "-b", "main");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "Test");
+    commitFile("shared.txt", "line one\nline two\nline three\n", "init");
+    commitFile("other.txt", "other\n", "other");
+});
+after(() => fs.rmSync(repo, { recursive: true, force: true }));
+/** Branch `name` off the init commits and give both it and a fresh `base-<name>` one edit each. */
+function divergedPair(name, feature, base) {
+    git(repo, "checkout", "-q", "-b", `base-${name}`, "main");
+    commitFile(base[0], base[1], `base ${name}`);
+    git(repo, "checkout", "-q", "-b", name, "main");
+    commitFile(feature[0], feature[1], `feature ${name}`);
+    return `base-${name}`;
+}
+test("NOT-355: the same line edited on both sides reports conflict with that path, and changes nothing", async () => {
+    const baseRef = divergedPair("same-line", ["shared.txt", "line one\nfeature edit\nline three\n"], ["shared.txt", "line one\nbase edit\nline three\n"]);
+    const headBefore = git(repo, "rev-parse", "HEAD");
+    const refsBefore = git(repo, "for-each-ref");
+    const probe = await probeBaseConflict({ worktreePath: repo, baseRef });
+    assert.deepEqual(probe, { state: "conflict", files: ["shared.txt"] });
+    assert.equal(git(repo, "rev-parse", "HEAD"), headBefore, "HEAD unchanged");
+    assert.equal(git(repo, "for-each-ref"), refsBefore, "no ref moved");
+    assert.equal(git(repo, "status", "--porcelain"), "", "working tree untouched");
+});
+test("NOT-355: non-overlapping edits report clean", async () => {
+    const baseRef = divergedPair("disjoint", ["shared.txt", "line one\nline two\nfeature edit\n"], ["other.txt", "other, edited on base\n"]);
+    const probe = await probeBaseConflict({ worktreePath: repo, baseRef });
+    assert.deepEqual(probe, { state: "clean" });
+    assert.equal(git(repo, "status", "--porcelain"), "");
+});
+test("NOT-355: a git without merge-tree --write-tree is skipped (fail open)", async () => {
+    const calls = [];
+    const probe = await probeBaseConflict({
+        worktreePath: repo,
+        baseRef: "main",
+        exec: async (args) => {
+            calls.push(args);
+            throw Object.assign(new Error("git merge-tree failed"), {
+                code: 129,
+                stdout: "",
+                stderr: "error: unknown option `write-tree'\nusage: git merge-tree <base-tree> <branch1> <branch2>",
+            });
+        },
+    });
+    assert.equal(probe.state, "skipped");
+    assert.match(probe.reason, /not supported/);
+    assert.deepEqual(calls, [["merge-tree", "--write-tree", "--name-only", "--no-messages", "main", "HEAD"]]);
+});
+test("NOT-355: any other merge-tree failure is an error, never skipped (fail open) or conflict", async () => {
+    const badRef = await probeBaseConflict({ worktreePath: repo, baseRef: "no-such-ref" });
+    assert.equal(badRef.state, "error");
+    assert.match(badRef.reason, /no-such-ref/);
+    // A usage-looking stderr without exit 129, or a 129 without the usage dump, is not "unsupported".
+    for (const failure of [
+        { code: 128, stderr: "usage: git merge-tree [--write-tree] [<options>] <branch1> <branch2>" },
+        { code: 129, stderr: "fatal: something else entirely" },
+        { code: 1, stderr: "" }, // conflict exit with no conflicted paths
+        { code: "ENOENT", stderr: "" }, // git missing / spawn failure
+    ]) {
+        const probe = await probeBaseConflict({
+            worktreePath: repo,
+            baseRef: "main",
+            exec: async () => {
+                throw Object.assign(new Error("git merge-tree failed"), { stdout: "", ...failure });
+            },
+        });
+        assert.equal(probe.state, "error", `exit ${failure.code} must not fail open`);
+    }
+});
+test("NOT-355: headRef probes a branch from the repo itself (no worktree checkout)", async () => {
+    const baseRef = divergedPair("by-ref", ["shared.txt", "line one\nby-ref feature\nline three\n"], ["shared.txt", "line one\nby-ref base\nline three\n"]);
+    git(repo, "checkout", "-q", "main");
+    const probe = await probeBaseConflict({ worktreePath: repo, baseRef, headRef: "by-ref" });
+    assert.deepEqual(probe, { state: "conflict", files: ["shared.txt"] });
+    assert.deepEqual(await probeBaseConflict({ worktreePath: repo, baseRef: "main", headRef: "by-ref" }), { state: "clean" });
+});

package/bundle/server/dist/adapters/git-worktree.js

@@ -18,10 +18,23 @@ import { withRepoLock } from "../runners/process-registry.js";
  * Kept inside the repo (not `$AGENT_DEALER_HOME`) so `agent-deck use` grants cover the
  * worker cwd and `bind_workspace` to that path can succeed. */
 export const WORKTREES_DIR_NAME = ".agent-dealer-worktrees";
-const run = promisify(execFile);
-async function git(cwd, args) {
+const execFileAsync = promisify(execFile);
+const gitCommandObservers = new Set();
+/** Registers `observer` for every adapter `git` invocation; returns the unsubscribe. */
+export function observeGitCommands(observer) {
+    gitCommandObservers.add(observer);
+    return () => {
+        gitCommandObservers.delete(observer);
+    };
+}
+function run(file, args, opts) {
+    for (const observer of gitCommandObservers)
+        observer(args, opts.cwd);
+    return execFileAsync(file, args, { ...opts, encoding: "utf8" });
+}
+async function git(cwd, args, timeout) {
     try {
-        return await run("git", args, { cwd });
+        return await run("git", args, timeout === undefined ? { cwd } : { cwd, timeout });
     }
     catch (err) {
         const e = err;
@@ -581,11 +594,12 @@ export async function pushLeaseToSha(opts) {
 /**
  * NOT-221: read origin's live tip for a branch without touching local refs — shown on
  * the still-open action after a lease push fails, so the operator sees what moved.
- * Null when the branch cannot be resolved remotely (deleted, renamed, or unreachable).
+ * Null when the branch cannot be resolved remotely (deleted, renamed, unreachable, or
+ * — when `timeoutMs` is given — the read stalled past that bound).
  */
 export async function readRemoteTip(opts) {
     try {
-        const { stdout } = await git(opts.cwd, ["ls-remote", "origin", `refs/heads/${opts.branch}`]);
+        const { stdout } = await git(opts.cwd, ["ls-remote", "origin", `refs/heads/${opts.branch}`], opts.timeoutMs);
         const sha = stdout.trim().split(/\s+/)[0];
         return sha && /^[0-9a-f]{40}$/i.test(sha) ? sha : null;
     }
@@ -598,6 +612,47 @@ export async function commitsAhead(opts) {
     const { stdout } = await git(opts.worktreePath, ["rev-list", "--count", `${opts.baseRef}..HEAD`]);
     return Number(stdout.trim());
 }
+const defaultProbeGitExec = (args, opts) => run("git", args, { cwd: opts.cwd });
+/** git < 2.38 rejects `--write-tree` with exit 129 and the old usage dump. */
+const MERGE_TREE_UNSUPPORTED = /unknown option|usage: git merge-tree/i;
+/**
+ * NOT-355: `git merge-tree --write-tree --name-only --no-messages <baseRef> <headRef>`
+ * — a pure in-object-store merge. Exit 0 is clean; exit 1 is a conflict whose stdout
+ * is the (partial) tree OID followed by one conflicted path per line. Never a merge
+ * commit, never a rebase, never a working-tree change.
+ */
+export async function probeBaseConflict(opts) {
+    const exec = opts.exec ?? defaultProbeGitExec;
+    const args = ["merge-tree", "--write-tree", "--name-only", "--no-messages", opts.baseRef, opts.headRef ?? "HEAD"];
+    try {
+        await exec(args, { cwd: opts.worktreePath });
+        return { state: "clean" };
+    }
+    catch (err) {
+        const e = err;
+        const stdout = typeof e.stdout === "string" ? e.stdout : "";
+        const stderr = typeof e.stderr === "string" ? e.stderr : "";
+        if (e.code === 1) {
+            const files = [
+                ...new Set(stdout
+                    .split("\n")
+                    .slice(1)
+                    .map((line) => line.trim())
+                    .filter((line) => line.length > 0)),
+            ];
+            if (files.length > 0)
+                return { state: "conflict", files };
+            return {
+                state: "error",
+                reason: `git merge-tree exited 1 without naming a conflicted path${stderr.trim() ? `: ${stderr.trim()}` : ""}`,
+            };
+        }
+        if (e.code === 129 && MERGE_TREE_UNSUPPORTED.test(stderr)) {
+            return { state: "skipped", reason: "git merge-tree --write-tree is not supported by the installed git" };
+        }
+        return { state: "error", reason: `git merge-tree failed: ${stderr.trim() || e.message || String(err)}` };
+    }
+}
 /** `commitsAhead` between two arbitrary refs — no worktree, no HEAD (see `pushBranchRef`). */
 export async function countCommitsBetween(opts) {
     const { stdout } = await git(opts.repo, ["rev-list", "--count", `${opts.base}..${opts.head}`]);

package/bundle/server/dist/adapters/git-worktree.test.js

@@ -11,7 +11,7 @@ import path from "node:path";
 // against findWorktreeForBranch/resolveDeveloperWorktree would fail.
 const home = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "dealer-wt-home-")));
 process.env.AGENT_DEALER_HOME = home;
-const { branchExists, createRoleWorktree, safeRemoveWorktree, fetchFreshBase, inspectLeftoverWorktree, isWorktreeClean, withRepoLock, pushBranch, pushWithLease, commitsAhead, findWorktreeForBranch, resolveDeveloperWorktree, worktreesRoot, WORKTREES_DIR_NAME, } = await import("./git-worktree.js");
+const { branchExists, createRoleWorktree, safeRemoveWorktree, fetchFreshBase, readRemoteTip, inspectLeftoverWorktree, isWorktreeClean, withRepoLock, pushBranch, pushWithLease, commitsAhead, findWorktreeForBranch, resolveDeveloperWorktree, worktreesRoot, WORKTREES_DIR_NAME, } = await import("./git-worktree.js");
 let repo;
 let remote;
 function git(cwd, ...args) {
@@ -1508,3 +1508,15 @@ test("NOT-197: fetchFreshBase uses the local base as-is when the repo has no ori
         fs.rmSync(bare, { recursive: true, force: true });
     }
 });
+test("NOT-356: readRemoteTip honours timeoutMs and returns null for a stalled remote", async () => {
+    const repo = fs.mkdtempSync(path.join(home, "stalled-remote-"));
+    const git = (...args) => execFileSync("git", args, { cwd: repo, stdio: "ignore" });
+    git("init", "-q");
+    // An `ext::` remote whose helper never answers stands in for a hung network read.
+    git("config", "protocol.ext.allow", "always");
+    git("remote", "add", "origin", "ext::sh -c 'sleep 30'");
+    const started = Date.now();
+    const tip = await readRemoteTip({ cwd: repo, branch: "any", timeoutMs: 300 });
+    assert.equal(tip, null);
+    assert.ok(Date.now() - started < 10_000, "the stalled ls-remote was not cut off by the timeout");
+});