@codyswann/lisa 4.70.4 → 4.71.1

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

@@ -0,0 +1,235 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Trusted allocation retains origin bytes and renews only current recovery authority. */
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { required, keys, validateProposal } from "./npm-update-contract.mjs";
+import { writeJson, replaceJson } from "./npm-update-process.mjs";
+import { descriptorFor } from "./npm-update-gate.mjs";
+import { authorizeAllocation } from "./npm-update-leaf.mjs";
+export { authorizeAllocation } from "./npm-update-leaf.mjs";
+import { destinationSnapshot } from "./npm-update-publication.mjs";
+export { destinationSnapshot } from "./npm-update-publication.mjs";
+import { persistCheckpoint, recoveryRecord } from "./npm-update-recovery.mjs";
+export { recoveryRecord } from "./npm-update-recovery.mjs";
+import { verifyCurrentProvider } from "./github-attestation-verifier.mjs";
+import { verifyHistoricalProvider } from "./github-attestation-provider.mjs";
+import {
+  verifyHistoricalDescriptor,
+  predictedCommit,
+} from "./github-attestation-recovery.mjs";
+
+/** Serialize only original public filing data, never live operator comments. */
+function publicAllocation(allocation) {
+  const fields = [
+    "number",
+    "workItem",
+    "claimCommentId",
+    "claimSha256",
+    "draft",
+    "evidence",
+    "quality",
+  ];
+  return Object.fromEntries(fields.map(key => [key, allocation[key]]));
+}
+
+/** Restored public bytes are recomputed and officially verified before renewal. */
+async function restoredOrigin(
+  cwd,
+  output,
+  proposal,
+  allocation,
+  policy,
+  config
+) {
+  const origin = allocation.origin;
+  const preview = origin.payload.preview;
+  keys(preview, ["descriptor", "message", "epoch"]);
+  const recomputed = await descriptorFor({
+    cwd,
+    proposal,
+    policy,
+    automation: config.automationProvenance,
+    allocation,
+    runId: preview.descriptor.runId,
+    runAttempt: preview.descriptor.runAttempt,
+    epoch: preview.epoch,
+  });
+  required(
+    canonicalJson(preview) === canonicalJson(recomputed),
+    "restored original artifact differs"
+  );
+  const paths = {
+    descriptor: join(output, "descriptor.json"),
+    bundle: join(output, "bundle.json"),
+  };
+  writeJson(paths.descriptor, preview.descriptor);
+  required(
+    Buffer.byteLength(origin.payload.bundle) <= 1_048_576,
+    "origin bundle exceeds bound"
+  );
+  writeFileSync(paths.bundle, origin.payload.bundle, {
+    mode: 0o600,
+    flag: "wx",
+  });
+  const historical = verifyHistoricalProvider(
+    config.automationProvenance,
+    preview.descriptor
+  );
+  verifyHistoricalDescriptor(
+    config.automationProvenance,
+    preview.descriptor,
+    paths,
+    origin.digest,
+    historical.run,
+    historical.claim
+  );
+  return preview;
+}
+
+/** Restore the immutable origin before renewing its separately signed current authority. */
+async function recoveryPreview({
+  api,
+  cwd,
+  output,
+  proposal,
+  allocation,
+  original,
+  policy,
+  config,
+  issue,
+}) {
+  const preview = await restoredOrigin(
+    cwd,
+    output,
+    proposal,
+    allocation,
+    policy,
+    config
+  );
+  if (!allocation.origin.complete) {
+    verifyCurrentProvider(api.policy, {
+      ...preview.descriptor,
+      runId: process.env.GITHUB_RUN_ID,
+      runAttempt: process.env.GITHUB_RUN_ATTEMPT,
+    });
+    await persistCheckpoint(
+      api,
+      original.number,
+      allocation.origin.payload,
+      allocation.origin.digest,
+      () => authorizeAllocation(api, proposal, original, policy, config)
+    );
+  }
+  const commit = predictedCommit(
+    preview.descriptor,
+    Buffer.from(preview.message)
+  );
+  const snapshot = await destinationSnapshot(api, proposal, original, commit);
+  writeJson(
+    join(output, "recovery.json"),
+    recoveryRecord(
+      proposal,
+      original,
+      preview,
+      policy,
+      config.automationProvenance,
+      issue,
+      snapshot
+    )
+  );
+  return preview;
+}
+
+/** Public draft storage precedes the first immutable descriptor and prospective commit. */
+async function originPreview({
+  api,
+  cwd,
+  output,
+  proposal,
+  original,
+  policy,
+  config,
+}) {
+  await persistCheckpoint(
+    api,
+    original.number,
+    { version: 1, proposal, allocation: original, preview: null, bundle: "" },
+    proposal.key,
+    () => authorizeAllocation(api, proposal, original, policy, config)
+  );
+  const preview = await descriptorFor({
+    cwd,
+    proposal,
+    policy,
+    automation: config.automationProvenance,
+    allocation: original,
+    runId: process.env.GITHUB_RUN_ID,
+    runAttempt: process.env.GITHUB_RUN_ATTEMPT,
+    epoch: Math.floor(Date.now() / 1000),
+  });
+  const commit = predictedCommit(
+    preview.descriptor,
+    Buffer.from(preview.message)
+  );
+  writeJson(
+    join(output, "destination.json"),
+    await destinationSnapshot(api, proposal, original, commit)
+  );
+  writeJson(join(output, "descriptor.json"), preview.descriptor);
+  return preview;
+}
+
+/** Origin creation or recovery preparation occurs only in the trusted allocator. */
+export async function prepareAuthorization({
+  api,
+  cwd,
+  output,
+  proposal: suppliedProposal,
+  allocation,
+  policy,
+  config,
+}) {
+  let proposal = suppliedProposal;
+  if (allocation.status === "stale-outstanding")
+    return { mode: allocation.status, allocation };
+  const restored =
+    allocation.origin?.payload.proposal ??
+    allocation.originalProposal ??
+    proposal;
+  validateProposal(restored, policy);
+  if (canonicalJson(restored) !== canonicalJson(proposal))
+    replaceJson(join(output, "proposal.json"), restored);
+  proposal = restored;
+  const original = publicAllocation(allocation);
+  const issue = await authorizeAllocation(
+    api,
+    proposal,
+    original,
+    policy,
+    config
+  );
+  const inputs = {
+    api,
+    cwd,
+    output,
+    proposal,
+    allocation,
+    original,
+    policy,
+    config,
+    issue,
+  };
+  const preview = allocation.origin
+    ? await recoveryPreview(inputs)
+    : await originPreview(inputs);
+  writeJson(join(output, "preview.json"), preview);
+  writeJson(join(output, "allocation.json"), original);
+  const mode = allocation.origin ? "recovery" : "origin";
+  writeJson(join(output, "authorization.json"), { mode });
+  return { mode, allocation: original };
+}
+
+export { finalizeAuthorization } from "./npm-update-recovery.mjs";

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

@@ -0,0 +1,92 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Bounded native socket transport supplies a fixed recipe ID, never executable authority or credentials. */
+import { createConnection } from "node:net";
+import { lstatSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { required, keys } from "./npm-update-contract.mjs";
+
+function brokerPath(context, recipe) {
+  keys(context, ["root", "path", "deadline"]);
+  const root = lstatSync(context.root);
+  const socket = lstatSync(context.path);
+  required(
+    root.isDirectory() &&
+      !root.isSymbolicLink() &&
+      realpathSync(context.root) === context.root &&
+      root.uid === process.getuid() &&
+      (root.mode & 0o077) === 0 &&
+      context.path === join(context.root, "controller.sock") &&
+      socket.isSocket() &&
+      socket.uid === process.getuid() &&
+      (socket.mode & 0o077) === 0,
+    "broker pathname ownership differs"
+  );
+  required(
+    typeof recipe === "string" &&
+      /^[a-zA-Z0-9-]{1,128}$/.test(recipe) &&
+      Number.isSafeInteger(context.deadline) &&
+      context.deadline > Date.now() &&
+      context.deadline <= Date.now() + 1_800_000,
+    "invalid broker request or lifetime"
+  );
+  return context.path;
+}
+
+function nativeResult(bytes) {
+  const text = new TextDecoder("utf8", { fatal: true }).decode(bytes);
+  const result = JSON.parse(text);
+  required(text === `${JSON.stringify(result)}\n`, "ambiguous broker response");
+  required(result.ok === true, "controller request refused");
+  keys(result, ["ok", "code", "stdout", "stderr"]);
+  required(
+    Number.isInteger(result.code) &&
+      result.code >= 0 &&
+      result.code <= 255 &&
+      [result.stdout, result.stderr].every(
+        value =>
+          typeof value === "string" && /^[A-Za-z0-9+/]*={0,2}$/.test(value)
+      ),
+    "invalid broker native result"
+  );
+  const stdout = Buffer.from(result.stdout, "base64");
+  const stderr = Buffer.from(result.stderr, "base64");
+  required(
+    stdout.toString("base64") === result.stdout &&
+      stderr.toString("base64") === result.stderr &&
+      stdout.length + stderr.length <= 8_388_608,
+    "broker capture differs or exceeds bound"
+  );
+  return { code: result.code, stdout, stderr };
+}
+
+/** The server's immutable recipe owns full stdin and all subprocess options. */
+export async function invokeControllerRecipe(context, recipe) {
+  const path = brokerPath(context, recipe);
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(path);
+    const chunks = [];
+    let size = 0;
+    const timer = setTimeout(
+      () => socket.destroy(new Error("controller phase expired")),
+      context.deadline - Date.now()
+    );
+    socket.on("connect", () => socket.end(`${JSON.stringify({ recipe })}\n`));
+    socket.on("data", chunk => {
+      size += chunk.length;
+      if (size > 11_185_000)
+        socket.destroy(new Error("broker response exceeds capture bound"));
+      else chunks.push(chunk);
+    });
+    socket.on("error", reject);
+    socket.on("close", () => clearTimeout(timer));
+    socket.on("end", () => {
+      try {
+        resolve(nativeResult(Buffer.concat(chunks)));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}

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

@@ -0,0 +1,241 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Bounded public checkpoint storage is data only, never provenance authority. */
+import { TextDecoder } from "node:util";
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { keys, required } from "./npm-update-contract.mjs";
+import { sha256 } from "./github-attestation-verifier.mjs";
+
+const MAXIMUM = 4_194_304;
+const CHUNK = 16_384;
+const PREFIX = "[lisa-npm-checkpoint]";
+const HEX = /^[a-f0-9]{64}$/;
+
+/** Closed public payloads contain no bearer token or executable extension field. */
+function payloadBytes(payload) {
+  keys(payload, ["version", "proposal", "allocation", "preview", "bundle"]);
+  required(
+    payload.version === 1 && typeof payload.bundle === "string",
+    "invalid public checkpoint payload"
+  );
+  const bytes = Buffer.from(`${canonicalJson(payload)}\n`);
+  required(bytes.length <= MAXIMUM, "checkpoint payload exceeds bound");
+  required(
+    !/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/.test(
+      payload.bundle
+    ),
+    "bearer JWT cannot be retained"
+  );
+  return bytes;
+}
+
+/** Numbered digest-checked chunks precede one exact completion manifest. */
+export function checkpointComments(payload, originDigest) {
+  required(
+    typeof originDigest === "string" && HEX.test(originDigest),
+    "invalid checkpoint origin"
+  );
+  const bytes = payloadBytes(payload);
+  const count = Math.ceil(bytes.length / CHUNK);
+  required(count > 0 && count <= 256, "checkpoint chunk count exceeds bound");
+  const chunks = Array.from({ length: count }, (_, index) =>
+    bytes.subarray(index * CHUNK, (index + 1) * CHUNK)
+  );
+  const manifest = {
+    version: 1,
+    originDescriptorSha256: originDigest,
+    payloadSha256: sha256(bytes),
+    bytes: bytes.length,
+    chunks: chunks.map((chunk, index) => ({ index, sha256: sha256(chunk) })),
+  };
+  return [
+    ...chunks.map(
+      (chunk, index) =>
+        `${PREFIX} v1 ${originDigest} chunk ${index}/${count} ${sha256(chunk)}\n${chunk.toString("base64")}`
+    ),
+    `${PREFIX} v1 ${originDigest} complete\n${canonicalJson(manifest)}`,
+  ];
+}
+
+/** A strict marker locates data only; signatures are still required separately. */
+function relevant(comments, digest) {
+  required(
+    Array.isArray(comments) && comments.length <= 2000,
+    "checkpoint comment inventory exceeds bound"
+  );
+  return comments
+    .filter(
+      comment =>
+        typeof comment.body === "string" &&
+        comment.body.startsWith(`${PREFIX} v1 ${digest} `)
+    )
+    .map(comment => {
+      required(
+        Buffer.byteLength(comment.body) <= 24_576,
+        "checkpoint comment exceeds bound"
+      );
+      return comment.body;
+    });
+}
+
+/** The unique completion record independently bounds the declared aggregate. */
+function completionManifest(body, digest) {
+  const text = body.split("\n").slice(1).join("\n");
+  const manifest = JSON.parse(text);
+  keys(manifest, [
+    "version",
+    "originDescriptorSha256",
+    "payloadSha256",
+    "bytes",
+    "chunks",
+  ]);
+  required(
+    canonicalJson(manifest) === text &&
+      manifest.version === 1 &&
+      manifest.originDescriptorSha256 === digest &&
+      HEX.test(manifest.payloadSha256),
+    "checkpoint manifest differs"
+  );
+  required(
+    Number.isSafeInteger(manifest.bytes) &&
+      manifest.bytes > 0 &&
+      manifest.bytes <= MAXIMUM &&
+      Array.isArray(manifest.chunks) &&
+      manifest.chunks.length > 0 &&
+      manifest.chunks.length <= 256,
+    "checkpoint manifest bounds differ"
+  );
+  return manifest;
+}
+
+/** Each numbered chunk is canonical, bounded and byte-bound before aggregation. */
+function decodedChunks(bodies, digest, manifest) {
+  const chunks = new Map();
+  for (const body of bodies) {
+    const match =
+      /^\[lisa-npm-checkpoint\] v1 ([a-f0-9]{64}) chunk (0|[1-9]\d*)\/([1-9]\d*) ([a-f0-9]{64})\n([A-Za-z0-9+/]+=*)$/.exec(
+        body
+      );
+    required(
+      match &&
+        match[1] === digest &&
+        Number(match[3]) === manifest.chunks.length,
+      "checkpoint chunk shape differs"
+    );
+    const index = Number(match[2]);
+    const bytes = Buffer.from(match[5], "base64");
+    required(
+      index < manifest.chunks.length &&
+        bytes.length <= CHUNK &&
+        bytes.toString("base64") === match[5] &&
+        sha256(bytes) === match[4],
+      "checkpoint chunk bytes differ"
+    );
+    required(
+      !chunks.has(index) || chunks.get(index).equals(bytes),
+      "differing duplicate checkpoint chunk"
+    );
+    chunks.set(index, bytes);
+  }
+  return chunks;
+}
+
+/** Decode bounded canonical public storage; this function never authorizes recovery. */
+export function decodeCheckpoint(comments, digest) {
+  required(
+    typeof digest === "string" && HEX.test(digest),
+    "invalid checkpoint digest"
+  );
+  const bodies = relevant(comments, digest);
+  if (!bodies.length) return undefined;
+  const complete = bodies.filter(body =>
+    body.startsWith(`${PREFIX} v1 ${digest} complete\n`)
+  );
+  required(complete.length === 1, "checkpoint incomplete or ambiguous");
+  const manifest = completionManifest(complete[0], digest);
+  const chunks = decodedChunks(
+    bodies.filter(body => body !== complete[0]),
+    digest,
+    manifest
+  );
+  const ordered = manifest.chunks.map((entry, index) => {
+    keys(entry, ["index", "sha256"]);
+    const chunk = chunks.get(index);
+    required(
+      entry.index === index && chunk && sha256(chunk) === entry.sha256,
+      "checkpoint missing or reordered chunk"
+    );
+    return chunk;
+  });
+  const bytes = Buffer.concat(ordered);
+  required(
+    bytes.length === manifest.bytes && sha256(bytes) === manifest.payloadSha256,
+    "checkpoint aggregate differs"
+  );
+  const payload = JSON.parse(
+    new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes)
+  );
+  required(
+    payloadBytes(payload).equals(bytes),
+    "checkpoint is noncanonical or duplicate-keyed"
+  );
+  return payload;
+}
+
+/** Readback before completion prevents a stored marker blessing missing bytes. */
+export async function persistCheckpoint(
+  api,
+  number,
+  payload,
+  digest,
+  authorize
+) {
+  const bodies = checkpointComments(payload, digest);
+  const endpoint = `repos/${api.policy.repository}/issues/${number}/comments`;
+  const issueUrl = `https://api.github.com/repos/${api.policy.repository}/issues/${number}`;
+  for (const body of bodies) {
+    await authorize();
+    const existing = await api.list(endpoint);
+    const matches = existing.filter(comment => comment.body === body);
+    if (body.startsWith(`${PREFIX} v1 ${digest} complete\n`)) {
+      const projected = matches.length ? existing : [...existing, { body }];
+      required(
+        canonicalJson(decodeCheckpoint(projected, digest)) ===
+          canonicalJson(payload),
+        "checkpoint chunks must read back before completion"
+      );
+    }
+    required(matches.length <= 1, "duplicate checkpoint write state");
+    if (!matches.length) {
+      const created = await api.request(endpoint, "POST", { body });
+      required(
+        created.issue_url === issueUrl,
+        "checkpoint write scope differs"
+      );
+      required(
+        created.body === body &&
+          Number.isSafeInteger(created.id) &&
+          created.id > 0,
+        "checkpoint write readback differs"
+      );
+      const read = await api.request(
+        `repos/${api.policy.repository}/issues/comments/${created.id}`
+      );
+      required(
+        read.issue_url === issueUrl,
+        "checkpoint immediate readback scope differs"
+      );
+      required(
+        read.id === created.id && read.body === body,
+        "checkpoint immediate readback differs"
+      );
+    }
+  }
+  const restored = decodeCheckpoint(await api.list(endpoint), digest);
+  required(
+    canonicalJson(restored) === canonicalJson(payload),
+    "durable complete checkpoint differs"
+  );
+  return { originDescriptorSha256: digest, complete: true };
+}