@codyswann/lisa 4.70.4 → 4.71.0

package/all/copy-overwrite/scripts/lib/npm-update-gate.mjs

@@ -0,0 +1,300 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/**
+ * @file npm-update-gate.mjs
+ * @description API transport has authority only over the raw object that passed ordinary hooks.
+ * @module npm-updater
+ */
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import {
+  FILES,
+  OBJECT,
+  required,
+  validateProposal,
+  validateRawCommit,
+} from "./npm-update-contract.mjs";
+import {
+  candidateEnvironment,
+  runProcess,
+  withPrivateRoot,
+} from "./npm-update-process.mjs";
+import { baseline } from "./npm-update-prepare.mjs";
+import { sha256 } from "./github-attestation-verifier.mjs";
+import {
+  createHostedGate,
+  assertHostedGate,
+  remainingGateTime,
+} from "./npm-update-hosted-gate.mjs";
+import {
+  originalHookInstallation,
+  runGateStreams,
+} from "./npm-update-gate-hooks.mjs";
+import {
+  installGateProof,
+  validateGateProof,
+} from "./npm-update-gate-proof.mjs";
+import { GitHub } from "./npm-update-github.mjs";
+import {
+  destinationSnapshot,
+  ordinaryGateReceipt,
+} from "./npm-update-publication.mjs";
+import { executeCanonicalHelper } from "./npm-update-controller-factory.mjs";
+
+const BOT = "github-actions[bot]";
+const MAIL = "41898282+github-actions[bot]@users.noreply.github.com";
+
+/** Ref transport is closed and complete; publish exactly one new branch. */
+export function refTransport(branch, commit, refs) {
+  required(
+    /^lisa\/npm-[a-f0-9]{64}$/.test(branch) && OBJECT.test(commit),
+    "invalid publication ref"
+  );
+  const expected = `refs/heads/${branch} ${commit} refs/heads/${branch} ${"0".repeat(40)}\n`;
+  required(
+    refs === expected,
+    "omitted, foreign, duplicate or changed pushed ref"
+  );
+  return expected;
+}
+
+/** Ordinary Git retains literal argv/stdin and receives no provider credential. */
+function git(cwd, env, args, input, deadline) {
+  return runProcess("git", args, {
+    cwd,
+    env,
+    input,
+    timeout: deadline === undefined ? 1_800_000 : remainingGateTime(deadline),
+    maximum: 3_145_728,
+  });
+}
+
+/** Preview writes owned Git objects without executing repository or npm code. */
+export async function descriptorFor({
+  cwd,
+  proposal,
+  policy,
+  automation,
+  allocation,
+  runId,
+  runAttempt,
+  epoch,
+}) {
+  validateProposal(proposal, policy);
+  required(
+    /^[1-9]\d*$/.test(runId) &&
+      /^[1-9]\d*$/.test(runAttempt) &&
+      Number.isSafeInteger(epoch) &&
+      epoch > 0,
+    "invalid actual Actions identity/time"
+  );
+  return withPrivateRoot(async (root, env) => {
+    await baseline(cwd, env, proposal);
+    const staged = { ...env, GIT_INDEX_FILE: join(root, "index") };
+    await git(cwd, staged, ["read-tree", proposal.parent]);
+    for (const file of FILES) {
+      const blob = (
+        await git(
+          cwd,
+          staged,
+          ["hash-object", "-w", "--stdin"],
+          proposal.files[file]
+        )
+      ).stdout
+        .toString()
+        .trim();
+      await git(cwd, staged, [
+        "update-index",
+        "--add",
+        "--cacheinfo",
+        `100644,${blob},${file}`,
+      ]);
+    }
+    const tree = (await git(cwd, staged, ["write-tree"])).stdout
+      .toString()
+      .trim();
+    const identity = `${BOT} <${MAIL}> ${epoch} +0000`;
+    const message = `chore(deps): update selected npm dependencies\n\nWork-Item: ${allocation.workItem}\nAutomation-Provenance: actions/${runId}/attempts/${runAttempt}\n`;
+    const descriptor = {
+      version: 1,
+      parent: proposal.parent,
+      tree,
+      author: identity,
+      committer: identity,
+      files: proposal.hashes,
+      messageSha256: sha256(message),
+      updates: proposal.updates,
+      proposalKey: proposal.bindingKey,
+      policySha256: sha256(canonicalJson(automation)),
+      queue: policy.repository,
+      workItem: allocation.workItem,
+      claimCommentId: allocation.claimCommentId,
+      claimSha256: allocation.claimSha256,
+      runId,
+      runAttempt,
+    };
+    return { descriptor, message, epoch };
+  });
+}
+
+/** Staging retains the ordinary link/branch commands and refuses foreign checkout bytes first. */
+async function stageProposal(context, env) {
+  const { cwd, proposal } = context;
+  const command = args => git(cwd, env, args, undefined, context.deadline);
+  await baseline(cwd, env, proposal);
+  const parent = (await command(["rev-parse", "HEAD"])).stdout
+    .toString()
+    .trim();
+  required(parent === proposal.parent, "gate baseline differs");
+  required(
+    !(await command(["status", "--porcelain"])).stdout.toString().trim(),
+    "gate requires a fresh owned checkout"
+  );
+  const branch = `lisa/npm-${proposal.key}`;
+  await command(["checkout", "-b", branch]);
+  await executeCanonicalHelper(context, "stage-read", "link");
+  await executeCanonicalHelper(context, "stage-read", "attach-branch");
+  for (const file of FILES)
+    writeFileSync(join(cwd, file), proposal.files[file]);
+  await command(["add", "--", ...FILES]);
+  return branch;
+}
+
+/** Normal commit output is accepted only after exact raw object, diff and full-range readback. */
+async function committedProposal(
+  { cwd, proposal, preview, deadline },
+  env,
+  message
+) {
+  const command = args => git(cwd, env, args, undefined, deadline);
+  const committed = await command([
+    "commit",
+    "--cleanup=verbatim",
+    "--file",
+    message,
+  ]);
+  const head = (await command(["rev-parse", "HEAD"])).stdout.toString().trim();
+  const raw = (await command(["cat-file", "commit", head])).stdout;
+  const parsed = validateRawCommit(raw, preview.descriptor, cwd);
+  required(parsed.sha === head, "actual raw commit SHA differs");
+  const changed = (
+    await command(["diff", "--name-only", proposal.parent, head])
+  ).stdout
+    .toString()
+    .trim()
+    .split("\n")
+    .sort();
+  required(
+    changed.join("\n") === FILES.join("\n"),
+    "committed diff includes foreign paths"
+  );
+  const ranges = (
+    await command(["rev-list", `${proposal.parent}..${head}`])
+  ).stdout
+    .toString()
+    .trim()
+    .split("\n");
+  required(
+    ranges.length === 1 && ranges[0] === head,
+    "previous or omitted commit in publication range"
+  );
+  return { committed, head, raw, ranges };
+}
+
+/** Legacy transport retains exact original stdin and refuses any gate-induced checkout change. */
+async function pushProposal(context, env, branch, object) {
+  const {
+    cwd,
+    proposal,
+    policy,
+    config,
+    token,
+    allocation,
+    hookInstallation,
+    deadline,
+  } = context;
+  const { head } = object;
+  const api = new GitHub(config.automationProvenance, token);
+  const destination = await destinationSnapshot(
+    api,
+    proposal,
+    allocation,
+    head
+  );
+  const command = args => git(cwd, env, args, undefined, deadline);
+  const hook = await originalHookInstallation(cwd, command, hookInstallation);
+  const remote = `https://github.com/${policy.repository}.git`;
+  const streams = await runGateStreams(
+    branch,
+    head,
+    proposal.parent,
+    destination.expectedBranchHead,
+    refs =>
+      runProcess(hook.path, ["origin", remote], {
+        cwd,
+        env: {
+          ...env,
+          LISA_NPM_HOOK_ROLE: refs.includes(` ${proposal.parent}\n`)
+            ? "audit"
+            : "destination",
+        },
+        input: refs,
+        timeout: remainingGateTime(deadline),
+        maximum: 8_388_608,
+      })
+  );
+  required(
+    !(await command(["status", "--porcelain"])).stdout.toString().trim(),
+    "ordinary gates changed checkout bytes"
+  );
+  return ordinaryGateReceipt(
+    context,
+    object,
+    hook,
+    streams,
+    destination,
+    remote
+  );
+}
+
+/** Ordinary commit and original pre-push receive destination/stdin and all ranges. */
+export async function gateProposal(context) {
+  const scoped = { ...context, deadline: Date.now() + 1_800_000 };
+  const { proposal, policy, token, preview } = context;
+  validateProposal(proposal, policy);
+  assertHostedGate(context);
+  validateGateProof(context);
+  required(
+    typeof token === "string" && token.length > 0,
+    "readonly gate token is absent"
+  );
+  return withPrivateRoot(async root => {
+    const env = {
+      ...candidateEnvironment(root),
+      GIT_AUTHOR_NAME: BOT,
+      GIT_AUTHOR_EMAIL: MAIL,
+      GIT_COMMITTER_NAME: BOT,
+      GIT_COMMITTER_EMAIL: MAIL,
+      GIT_AUTHOR_DATE: `${preview.epoch} +0000`,
+      GIT_COMMITTER_DATE: `${preview.epoch} +0000`,
+    };
+    const branch = await stageProposal(scoped, env);
+    const message = await installGateProof(context, root, args =>
+      git(context.cwd, env, args, undefined, scoped.deadline)
+    );
+    const hosted = await createHostedGate(scoped, root, env);
+    try {
+      const gated = { ...scoped, hookInstallation: hosted.installation };
+      const object = await committedProposal(
+        gated,
+        { ...hosted.env, LISA_NPM_HOOK_ROLE: "commit" },
+        message
+      );
+      return await pushProposal(gated, hosted.env, branch, object);
+    } finally {
+      await hosted.close();
+    }
+  });
+}

package/all/copy-overwrite/scripts/lib/npm-update-gh-dispatch.mjs

@@ -0,0 +1,182 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Credentialed native GH runs only for immutable controller-selected canonical requests. */
+import { realpathSync, lstatSync } from "node:fs";
+import { join } from "node:path";
+import { required, keys } from "./npm-update-contract.mjs";
+import { binaryDigest } from "./npm-update-isolation.mjs";
+import { isProviderTransport } from "./npm-update-worker-environment.mjs";
+import {
+  createGhRequests,
+  createGhState,
+  prepareGhRequest,
+  observeGhResponse,
+} from "./npm-update-gh-requests.mjs";
+
+const OPTIONS = new Set([
+  "cwd",
+  "encoding",
+  "env",
+  "input",
+  "timeout",
+  "maxBuffer",
+  "killSignal",
+]);
+
+export function validateGhProfile(profile) {
+  keys(profile, [
+    "version",
+    "deadline",
+    "cwd",
+    "home",
+    "nativeGh",
+    "subject",
+    "invocation",
+  ]);
+  keys(profile.nativeGh, ["path", "sha256"]);
+  keys(profile.invocation, ["entry", "args", "cwd"]);
+  const home = lstatSync(profile.home);
+  required(
+    profile.version === 1 &&
+      Number.isSafeInteger(profile.deadline) &&
+      profile.deadline > Date.now() &&
+      profile.deadline <= Date.now() + 1_800_000 &&
+      profile.cwd === realpathSync(profile.cwd) &&
+      profile.home === realpathSync(profile.home) &&
+      home.isDirectory() &&
+      !home.isSymbolicLink() &&
+      home.uid === process.getuid() &&
+      (home.mode & 0o077) === 0,
+    "invalid private native GH phase context"
+  );
+  required(
+    typeof profile.invocation.entry === "string" &&
+      profile.invocation.entry.startsWith("/") &&
+      profile.invocation.cwd === profile.cwd &&
+      Array.isArray(profile.invocation.args) &&
+      profile.invocation.args.length > 0 &&
+      profile.invocation.args.length <= 512 &&
+      profile.invocation.args.every(
+        value =>
+          typeof value === "string" &&
+          !value.includes("\0") &&
+          Buffer.byteLength(value) <= 65536
+      ) &&
+      Buffer.byteLength(JSON.stringify(profile.invocation.args)) <= 262144,
+    "invalid immutable GH caller tuple"
+  );
+  checkedNative(profile.nativeGh);
+  createGhRequests(profile.subject);
+  return JSON.parse(JSON.stringify(profile));
+}
+
+function checkedNative(identity) {
+  const stat = lstatSync(identity.path);
+  required(
+    stat.isFile() &&
+      !stat.isSymbolicLink() &&
+      identity.path === realpathSync(identity.path) &&
+      /^[a-f0-9]{64}$/.test(identity.sha256) &&
+      binaryDigest(identity.path) === identity.sha256,
+    "native GH identity changed"
+  );
+}
+
+/** Caller options keep their original limits; no alternate transport or subprocess authority is accepted. */
+function nativeOptions(profile, options, token) {
+  required(
+    options &&
+      typeof options === "object" &&
+      !Array.isArray(options) &&
+      Object.keys(options).every(name => OPTIONS.has(name)),
+    "unsupported native GH subprocess option"
+  );
+  required(
+    (options.cwd ?? profile.cwd) === profile.cwd &&
+      options.encoding === "utf8" &&
+      options.input === undefined &&
+      (options.killSignal === undefined || options.killSignal === "SIGKILL"),
+    "native GH cwd/stdin/encoding differs"
+  );
+  const timeout = options.timeout ?? 30_000;
+  const maximum = options.maxBuffer ?? 1_048_576;
+  required(
+    Number.isSafeInteger(timeout) &&
+      timeout > 0 &&
+      timeout <= 120_000 &&
+      Number.isSafeInteger(maximum) &&
+      maximum > 0 &&
+      maximum <= 3_145_728,
+    "native GH original capture bounds differ"
+  );
+  const environment = options.env ?? {};
+  required(
+    typeof environment === "object" &&
+      !Array.isArray(environment) &&
+      Object.values(environment).every(
+        value =>
+          value === undefined ||
+          (typeof value === "string" && !value.includes("\0"))
+      ) &&
+      (!environment.GH_TOKEN || environment.GH_TOKEN === token) &&
+      !environment.GITHUB_TOKEN,
+    "native GH caller token or environment differs"
+  );
+  required(
+    Object.entries(environment).every(
+      ([name, value]) => !value || !isProviderTransport(name)
+    ) &&
+      (!environment.GH_HOST || environment.GH_HOST === "github.com") &&
+      (!environment.GITHUB_API_URL ||
+        environment.GITHUB_API_URL === "https://api.github.com") &&
+      (!environment.GITHUB_SERVER_URL ||
+        environment.GITHUB_SERVER_URL === "https://github.com"),
+    "native GH transport environment override refused"
+  );
+  const remaining = profile.deadline - Date.now();
+  required(remaining > 0, "native GH phase expired");
+  return {
+    cwd: profile.cwd,
+    encoding: "utf8",
+    timeout: Math.min(timeout, remaining),
+    maxBuffer: maximum,
+    killSignal: "SIGKILL",
+    env: {
+      PATH: "/usr/bin:/bin",
+      HOME: profile.home,
+      LANG: "C.UTF-8",
+      GH_HOST: "github.com",
+      GH_TOKEN: token,
+      GH_CONFIG_DIR: join(profile.home, "gh-config"),
+    },
+  };
+}
+
+/** Saved ORIGINAL.spawnSync is supplied by trusted instrumentation, never serialized as a recipe. */
+export function createGhDispatcher(suppliedProfile, token) {
+  required(
+    typeof token === "string" && token.length > 0 && !/[\0\r\n]/.test(token),
+    "native GH token is absent or invalid"
+  );
+  const profile = validateGhProfile(suppliedProfile);
+  const scope = createGhRequests(profile.subject);
+  const state = createGhState(scope);
+  return (method, command, args, options, nativeSpawnSync) => {
+    required(
+      method === "spawnSync" &&
+        (command === "gh" || command === profile.nativeGh.path),
+      "unqualified native GH invocation"
+    );
+    checkedNative(profile.nativeGh);
+    const actualOptions = nativeOptions(profile, options, token);
+    const request = prepareGhRequest(scope, state, args);
+    const result = nativeSpawnSync(
+      profile.nativeGh.path,
+      [...args],
+      actualOptions
+    );
+    observeGhResponse(scope, state, request, result);
+    return result;
+  };
+}

package/all/copy-overwrite/scripts/lib/npm-update-gh-grants.mjs

@@ -0,0 +1,156 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Native successful responses grant only one exact canonical successor request. */
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { required } from "./npm-update-contract.mjs";
+import {
+  githubHierarchyArgs,
+  backlinkBody,
+  partitionBacklinks,
+  githubBacklinkComments,
+} from "../lisa-work-item.mjs";
+const key = args => canonicalJson(args);
+const ID = /^[1-9]\d*$/;
+
+export function recoveryPage(subject, page) {
+  const head = encodeURIComponent(
+    `${subject.repository.split("/")[0]}:${subject.branch}`
+  );
+  return [
+    "api",
+    "--hostname",
+    "github.com",
+    `repos/${subject.repository}/pulls?state=all&head=${head}&per_page=100&page=${page}`,
+  ];
+}
+
+export function createGhState(scope) {
+  return {
+    grants: new Map(
+      scope.records
+        .filter(record => record.kind !== "plain")
+        .map(record => [key(record.args), record])
+    ),
+    requests: 0,
+  };
+}
+
+/** Consume every successor before native dispatch, including a repeated response cursor. */
+export function prepareGhRequest(scope, state, args) {
+  required(
+    Array.isArray(args) &&
+      args.every(value => typeof value === "string" && !value.includes("\0")),
+    "invalid literal GH request"
+  );
+  const serialized = key(args);
+  const record =
+    scope.records.find(
+      value => value.kind === "plain" && key(value.args) === serialized
+    ) ?? state.grants.get(serialized);
+  required(
+    record && state.requests < 1024,
+    "unqualified or exhausted GH request"
+  );
+  if (record.kind !== "plain") state.grants.delete(serialized);
+  state.requests++;
+  return record;
+}
+
+/** Primitive and file coercions in gh's typed -F grammar are never accepted as cursors. */
+function cursorValue(value) {
+  required(
+    typeof value === "string" &&
+      value.length > 0 &&
+      Buffer.byteLength(value) <= 1024 &&
+      !/[\0\n\r]/.test(value) &&
+      !value.startsWith("@") &&
+      !/^(?:true|false|null|-?\d+(?:\.\d+)?)$/.test(value),
+    "invalid typed GH hierarchy cursor"
+  );
+  return value;
+}
+
+/** Only an actual successful bounded response can grant the next exact request. */
+export function observeGhResponse(scope, state, request, result) {
+  if (
+    request.kind === "plain" ||
+    request.kind === "write" ||
+    result.error ||
+    result.signal ||
+    result.status !== 0
+  )
+    return;
+  required(
+    typeof result.stdout === "string" &&
+      Buffer.byteLength(result.stdout) <= 3_145_728,
+    "unbounded GH response grant"
+  );
+  const value = JSON.parse(result.stdout);
+  let successor;
+  if (request.kind === "hierarchy") {
+    const page = value.data?.repository?.issue?.subIssues;
+    required(
+      Array.isArray(page?.nodes) &&
+        page.nodes.length <= 100 &&
+        typeof page.pageInfo?.hasNextPage === "boolean",
+      "invalid GH hierarchy grant"
+    );
+    if (page.pageInfo.hasNextPage)
+      successor = {
+        kind: "hierarchy",
+        args: githubHierarchyArgs(
+          { repository: scope.subject.tracker },
+          scope.subject.issue,
+          cursorValue(page.pageInfo.endCursor)
+        ),
+      };
+  } else if (request.kind === "recovery-page") {
+    required(
+      Array.isArray(value) && value.length <= 100,
+      "invalid GH recovery page grant"
+    );
+    if (value.length === 100) {
+      required(request.page < 20, "incomplete GH recovery pages");
+      successor = {
+        kind: "recovery-page",
+        page: request.page + 1,
+        args: recoveryPage(scope.subject, request.page + 1),
+      };
+    }
+  } else if (request.kind === "comments")
+    successor = backlinkRequest(scope.subject, githubBacklinkComments(value));
+  if (successor) state.grants.set(key(successor.args), successor);
+}
+
+/** Canonical marker partitioning keeps every other PR's comment outside writer authority. */
+function backlinkRequest(subject, comments) {
+  required(
+    subject.phase === "publication-backlink" &&
+      subject.pr &&
+      Array.isArray(comments) &&
+      comments.length <= 10000,
+    "invalid GH backlink response"
+  );
+  const { mine } = partitionBacklinks(
+    comments,
+    subject.pr.url,
+    comment => comment?.body
+  );
+  const body = backlinkBody(subject.pr.url);
+  if (mine?.body === body) return null;
+  required(
+    !mine ||
+      ((typeof mine.id === "string" || Number.isSafeInteger(mine.id)) &&
+        ID.test(String(mine.id))),
+    "invalid GH backlink comment ID"
+  );
+  const method = mine ? "PATCH" : "POST";
+  const endpoint = mine
+    ? `repos/${subject.tracker}/issues/comments/${mine.id}`
+    : `repos/${subject.tracker}/issues/${subject.issue}/comments`;
+  return {
+    kind: "write",
+    args: ["api", "--method", method, endpoint, "--field", `body=${body}`],
+  };
+}