@kungfu-tech/buildchain 3.0.6 → 3.0.7-alpha.1

package/packages/core/dev-delivery-warrant.js

@@ -69,6 +69,7 @@ function normalizeCandidate(input, expected) {
     closureRoot: exactRoot(input.closureRoot, "closureRoot"),
     dependencyRoot: exactRoot(input.dependencyRoot, "dependencyRoot"),
     toolchainRoot: exactRoot(input.toolchainRoot, "toolchainRoot"),
+    ...(Object.hasOwn(input, "sourceWorkflowRunId") ? { sourceWorkflowRunId: nonNegativeInteger(input.sourceWorkflowRunId, "candidate sourceWorkflowRunId", 0) } : {}),
     priority: priority(input.priority),
     enqueuedAt: timestamp(input.enqueuedAt, "candidate enqueuedAt"),
     updatedAt: timestamp(input.updatedAt || input.enqueuedAt, "candidate updatedAt"),
@@ -178,6 +179,7 @@ function submissionReceipt({ before, after, candidate, action, now }) {
     closureRoot: candidate.closureRoot,
     dependencyRoot: candidate.dependencyRoot,
     toolchainRoot: candidate.toolchainRoot,
+    sourceWorkflowRunId: candidate.sourceWorkflowRunId,
     deliveryClass: candidate.deliveryClass,
     priority: candidate.priority,
     retainedEnqueuedAt: candidate.enqueuedAt,
@@ -223,7 +225,12 @@ export function submitDevDeliveryCandidate(queueInput, input, { now = new Date()
           selected = existing;
         } else {
           if (before.activeWarrant?.candidateId === existing.candidateId) {
-            throw new Error("selected candidate sourceHead cannot change before terminal Warrant closeout");
+            if (existing.sourceHead !== attemptedCandidate.sourceHead) {
+              throw new Error("selected candidate sourceHead cannot change before terminal Warrant closeout");
+            }
+            action = "active-warrant-retained-noop";
+            selected = existing;
+            return { candidate: selected, action };
           }
           const headChanged = existing.sourceHead !== attemptedCandidate.sourceHead;
           existing.sourceHead = attemptedCandidate.sourceHead;
@@ -309,7 +316,7 @@ export function selectDevDeliveryWarrant(queueInput, { now = new Date().toISOStr
       candidateId: queue.activeWarrant.candidateId,
       fencingToken: queue.activeWarrant.fencingToken,
       leaseGeneration: queue.activeWarrant.generation,
-      expectedOldStateRoot: queue.stateRoot,
+      expectedOldStateRoot: recoveryReceipt?.expectedOldStateRoot || queue.stateRoot,
       nextStateRoot: queue.stateRoot,
       nextAction: "Continue the active delivery attempt; later candidates remain visibly queued.",
     };
@@ -363,6 +370,7 @@ export function selectDevDeliveryWarrant(queueInput, { now = new Date().toISOStr
         closureRoot: candidate.closureRoot,
         dependencyRoot: candidate.dependencyRoot,
         toolchainRoot: candidate.toolchainRoot,
+        sourceWorkflowRunId: candidate.sourceWorkflowRunId,
         deliveryClass: candidate.deliveryClass,
         generation: next.fencingCounter,
         expectedOldStateRoot: before.stateRoot,
@@ -397,6 +405,7 @@ export function selectDevDeliveryWarrant(queueInput, { now = new Date().toISOStr
     closureRoot: transaction.result.candidate.closureRoot,
     dependencyRoot: transaction.result.candidate.dependencyRoot,
     toolchainRoot: transaction.result.candidate.toolchainRoot,
+    sourceWorkflowRunId: transaction.result.candidate.sourceWorkflowRunId,
     deliveryClass: transaction.result.candidate.deliveryClass,
     queueAgeSeconds: selected.priority.ageSeconds,
     basePriority: selected.priority.basePriority,
@@ -404,7 +413,7 @@ export function selectDevDeliveryWarrant(queueInput, { now = new Date().toISOStr
     effectivePriority: selected.priority.score,
     fencingToken: transaction.result.warrant.fencingToken,
     leaseGeneration: transaction.result.warrant.generation,
-    expectedOldStateRoot: transaction.expectedOldStateRoot,
+    expectedOldStateRoot: recoveryReceipt?.expectedOldStateRoot || transaction.expectedOldStateRoot,
     nextStateRoot: transaction.after.stateRoot,
     nextAction: transaction.result.warrant.nextAction,
   };
@@ -417,12 +426,12 @@ export function selectDevDeliveryWarrant(queueInput, { now = new Date().toISOStr
   };
 }
 
-function assertWarrantMutation(queue, warrant, now) {
+function assertWarrantMutation(queue, warrant, now, { allowExpired = false } = {}) {
   if (!queue.activeWarrant) throw new Error("no active Delivery Warrant");
   if (text(warrant?.fencingToken) !== queue.activeWarrant.fencingToken) throw new Error("stale fencing token");
   if (Number(warrant?.generation) !== queue.activeWarrant.generation) throw new Error("stale lease generation");
   if (text(warrant?.candidateId) !== queue.activeWarrant.candidateId) throw new Error("Warrant candidate mismatch");
-  if (Date.parse(queue.activeWarrant.expiresAt) <= Date.parse(now)) throw new Error("Delivery Warrant lease expired");
+  if (!allowExpired && Date.parse(queue.activeWarrant.expiresAt) <= Date.parse(now)) throw new Error("Delivery Warrant lease expired");
 }
 
 export function heartbeatDevDeliveryWarrant(queueInput, warrant, { now = new Date().toISOString(), leaseSeconds } = {}) {
@@ -517,7 +526,7 @@ export function closeDevDeliveryWarrant(queueInput, warrant, { outcome, evidence
   const transaction = transition(
     queueInput,
     (queue, before) => {
-      assertWarrantMutation(before, warrant, currentTime);
+      assertWarrantMutation(before, warrant, currentTime, { allowExpired: true });
       const active = clone(queue.activeWarrant);
       const candidate = queue.candidates.find((entry) => entry.candidateId === active.candidateId);
       candidate.status = normalizedOutcome;

package/packages/core/diagnostics.js

@@ -84,10 +84,14 @@ function fileStats(cwd, entries = []) {
   });
 }
 
-function commandVersion(command, args = ["--version"], cwd = process.cwd()) {
+const TOOL_VERSION_PROBE_CWD = path.parse(process.execPath).root;
+
+function commandVersion(command, args = ["--version"]) {
   try {
     return execFileSync(command, args, {
-      cwd,
+      // Package managers may walk every parent even for --version. Keep this
+      // bounded instead of scanning an arbitrary consumer or shared temp root.
+      cwd: TOOL_VERSION_PROBE_CWD,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 5000,
@@ -493,7 +497,8 @@ export function collectRunnerDiagnostics() {
 }
 
 export function collectToolDiagnostics({ cwd = process.cwd(), tools = ["node", "pnpm", "npm", "git", "cmake", "ninja", "ccache", "sccache"] } = {}) {
-  return Object.fromEntries(tools.map((tool) => [tool, { version: commandVersion(tool, ["--version"], cwd) }]));
+  void cwd;
+  return Object.fromEntries(tools.map((tool) => [tool, { version: commandVersion(tool) }]));
 }
 
 function parseJsonDiagnostics(value = "") {

package/packages/core/engineering-housekeeper-github-client.js

@@ -0,0 +1,222 @@
+function requiredString(value, field) {
+  const normalized = String(value || "").trim();
+  if (!normalized) throw new Error(`${field} is required`);
+  return normalized;
+}
+
+function normalizeRepository(value) {
+  const normalized = requiredString(value?.fullName || value, "repository");
+  const match = normalized.match(/^([^/\s]+)\/([^/\s]+)$/);
+  if (!match) throw new Error(`repository must be owner/repo, got: ${normalized}`);
+  return { owner: match[1], repo: match[2], fullName: normalized };
+}
+
+function refPath(name) {
+  return String(name)
+    .split("/")
+    .map((part) => encodeURIComponent(part))
+    .join("/");
+}
+
+function parseLinkHeader(value) {
+  const links = {};
+  for (const part of String(value || "").split(",")) {
+    const match = part.match(/<([^>]+)>;\s*rel="([^"]+)"/);
+    if (match) links[match[2]] = match[1];
+  }
+  return links;
+}
+
+function branchHeadOid(branch) {
+  return String(
+    branch?.commit?.sha || branch?.object?.sha || branch?.headOid || "",
+  ).toLowerCase();
+}
+
+export class GitHubHousekeeperProviderError extends Error {
+  constructor(message, { operation = "github", status = 0, cause } = {}) {
+    super(message, { cause });
+    this.name = "GitHubHousekeeperProviderError";
+    this.operation = operation;
+    this.status = status;
+  }
+}
+
+function providerError(error, operation) {
+  if (error instanceof GitHubHousekeeperProviderError) return error;
+  return new GitHubHousekeeperProviderError(
+    `${operation} failed: ${error?.message || String(error)}`,
+    { operation, cause: error },
+  );
+}
+
+export class GitHubHousekeeperClient {
+  constructor({
+    token,
+    apiUrl = "https://api.github.com",
+    fetchImpl = globalThis.fetch,
+  } = {}) {
+    if (typeof fetchImpl !== "function") throw new Error("fetch is required");
+    this.token = requiredString(token, "GitHub token");
+    this.apiUrl = String(apiUrl).replace(/\/+$/, "");
+    this.fetch = fetchImpl;
+  }
+
+  async request(method, requestPath, { body } = {}) {
+    const url = requestPath.startsWith("http")
+      ? requestPath
+      : `${this.apiUrl}${requestPath}`;
+    if (new URL(url).origin !== new URL(this.apiUrl).origin) {
+      throw new GitHubHousekeeperProviderError(
+        `GitHub pagination cannot leave API origin: ${new URL(url).origin}`,
+        { operation: `${method} ${requestPath}` },
+      );
+    }
+    let response;
+    try {
+      response = await this.fetch(url, {
+        method,
+        headers: {
+          accept: "application/vnd.github+json",
+          authorization: `Bearer ${this.token}`,
+          "content-type": "application/json",
+          "x-github-api-version": "2022-11-28",
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+      });
+    } catch (error) {
+      throw providerError(error, `${method} ${requestPath}`);
+    }
+    const text = await response.text();
+    let data = null;
+    try {
+      data = text ? JSON.parse(text) : null;
+    } catch (error) {
+      throw new GitHubHousekeeperProviderError(
+        `${method} ${requestPath} returned invalid JSON`,
+        {
+          operation: `${method} ${requestPath}`,
+          status: response.status,
+          cause: error,
+        },
+      );
+    }
+    if (!response.ok) {
+      throw new GitHubHousekeeperProviderError(
+        `${method} ${requestPath} failed with ${response.status}: ${data?.message || text}`,
+        { operation: `${method} ${requestPath}`, status: response.status },
+      );
+    }
+    return { data, response };
+  }
+
+  async paginate(requestPath, { maxPages = 1000 } = {}) {
+    const items = [];
+    const visited = new Set();
+    let next = requestPath;
+    while (next) {
+      if (visited.has(next)) {
+        throw new GitHubHousekeeperProviderError(
+          "GitHub pagination cycle detected",
+          { operation: `GET ${requestPath}` },
+        );
+      }
+      if (visited.size >= maxPages) {
+        throw new GitHubHousekeeperProviderError(
+          `GitHub pagination exceeded ${maxPages} pages`,
+          { operation: `GET ${requestPath}` },
+        );
+      }
+      visited.add(next);
+      const { data, response } = await this.request("GET", next);
+      if (!Array.isArray(data)) {
+        throw new GitHubHousekeeperProviderError(
+          "GitHub paginated response must be an array",
+          { operation: `GET ${next}` },
+        );
+      }
+      items.push(...data);
+      next = parseLinkHeader(response.headers.get("link")).next || "";
+    }
+    return items;
+  }
+
+  async getRepository(repository) {
+    const coordinate = normalizeRepository(repository);
+    return (
+      await this.request("GET", `/repos/${coordinate.owner}/${coordinate.repo}`)
+    ).data;
+  }
+
+  async listBranches(repository) {
+    const coordinate = normalizeRepository(repository);
+    return this.paginate(
+      `/repos/${coordinate.owner}/${coordinate.repo}/branches?per_page=100`,
+    );
+  }
+
+  async listOpenPullRequests(repository) {
+    const coordinate = normalizeRepository(repository);
+    return this.paginate(
+      `/repos/${coordinate.owner}/${coordinate.repo}/pulls?state=open&sort=updated&direction=asc&per_page=100`,
+    );
+  }
+
+  async getBranch(repository, name) {
+    const coordinate = normalizeRepository(repository);
+    return (
+      await this.request(
+        "GET",
+        `/repos/${coordinate.owner}/${coordinate.repo}/branches/${refPath(name)}`,
+      )
+    ).data;
+  }
+
+  async getPullRequest(repository, number) {
+    const coordinate = normalizeRepository(repository);
+    return (
+      await this.request(
+        "GET",
+        `/repos/${coordinate.owner}/${coordinate.repo}/pulls/${number}`,
+      )
+    ).data;
+  }
+
+  async compareCommits(repository, baseOid, headOid) {
+    const coordinate = normalizeRepository(repository);
+    return (
+      await this.request(
+        "GET",
+        `/repos/${coordinate.owner}/${coordinate.repo}/compare/${baseOid}...${headOid}`,
+      )
+    ).data;
+  }
+
+  async deleteBranch(repository, name, { expectedHeadOid } = {}) {
+    const coordinate = normalizeRepository(repository);
+    const currentHeadOid = branchHeadOid(
+      await this.getBranch(coordinate.fullName, name),
+    );
+    if (!expectedHeadOid || currentHeadOid !== expectedHeadOid) {
+      throw new GitHubHousekeeperProviderError(
+        `branch ${name} changed before delete`,
+        { operation: `delete-ref ${name}`, status: 409 },
+      );
+    }
+    await this.request(
+      "DELETE",
+      `/repos/${coordinate.owner}/${coordinate.repo}/git/refs/heads/${refPath(name)}`,
+    );
+  }
+
+  async addLabels(repository, number, labels) {
+    const coordinate = normalizeRepository(repository);
+    return (
+      await this.request(
+        "POST",
+        `/repos/${coordinate.owner}/${coordinate.repo}/issues/${number}/labels`,
+        { body: { labels } },
+      )
+    ).data;
+  }
+}