@codyswann/lisa 4.70.4 → 4.71.1

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

@@ -0,0 +1,221 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Controller-derived literal GH requests narrow canonical parsing without replacing it. */
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { required, keys } from "./npm-update-contract.mjs";
+import {
+  githubIssueViewArgs,
+  githubHierarchyArgs,
+  pullRequestViewArgs,
+  githubBacklinkListArgs,
+} from "../lisa-work-item.mjs";
+import {
+  officialArguments,
+  PROPOSAL_PREDICATE,
+  RECOVERY_PREDICATE,
+} from "./github-attestation-verifier.mjs";
+const BACKLINK_PHASE = "publication-backlink";
+const STAGE_PHASE = "stage-read";
+const PHASES = [
+  STAGE_PHASE,
+  "hook-read",
+  BACKLINK_PHASE,
+  "publication-validate-pr",
+];
+const ID = /^[1-9]\d*$/;
+const REPO = /^[A-Za-z0-9][A-Za-z0-9-]{0,38}\/[A-Za-z0-9_.-]{1,100}$/;
+const decimal = value => typeof value === "string" && ID.test(value);
+const key = args => canonicalJson(args);
+const api = endpoint => ["api", "--hostname", "github.com", endpoint];
+import { recoveryPage } from "./npm-update-gh-grants.mjs";
+
+/** Actual trusted allocation/config/proof bytes choose subject; requests cannot choose these fields. */
+function checkedSubject(subject) {
+  keys(subject, [
+    "phase",
+    "repository",
+    "tracker",
+    "issue",
+    "branch",
+    "parent",
+    "origin",
+    "claim",
+    "recovery",
+    "maintainer",
+    "pr",
+    "proofs",
+  ]);
+  required(
+    PHASES.includes(subject.phase) &&
+      REPO.test(subject.repository) &&
+      REPO.test(subject.tracker) &&
+      ![subject.repository, subject.tracker].some(value =>
+        [".", ".."].includes(value.split("/")[1])
+      ) &&
+      decimal(subject.issue) &&
+      decimal(subject.claim) &&
+      /^lisa\/npm-[a-f0-9]{64}$/.test(subject.branch) &&
+      /^[a-f0-9]{40}$/.test(subject.parent),
+    "invalid closed GH subject"
+  );
+  keys(subject.origin, ["runId", "runAttempt"]);
+  required(
+    decimal(subject.origin.runId) && decimal(subject.origin.runAttempt),
+    "invalid GH run identity"
+  );
+  if (subject.pr !== null) keys(subject.pr, ["number", "url"]);
+  required(
+    subject.pr === null ||
+      (decimal(subject.pr.number) &&
+        subject.pr.url ===
+          `https://github.com/${subject.repository}/pull/${subject.pr.number}`),
+    "invalid GH PR identity"
+  );
+  required(
+    /^[A-Za-z0-9][A-Za-z0-9-]{0,38}$/.test(subject.maintainer) &&
+      Array.isArray(subject.proofs) &&
+      subject.proofs.length <= 2 &&
+      (subject.phase !== STAGE_PHASE || subject.proofs.length === 0),
+    "invalid GH phase proof scope"
+  );
+  if (subject.recovery !== null) {
+    keys(subject.recovery, ["runId", "runAttempt", "branch"]);
+    required(
+      decimal(subject.recovery.runId) &&
+        decimal(subject.recovery.runAttempt) &&
+        subject.recovery.branch === subject.branch,
+      "invalid GH recovery identity"
+    );
+  }
+}
+
+/** Read families use the same literal constructors as the canonical shipped callers. */
+function ordinaryRequests(subject) {
+  const records = [
+    { kind: "plain", args: ["--version"] },
+    {
+      kind: "plain",
+      args: githubIssueViewArgs(subject.tracker, subject.issue),
+    },
+    {
+      kind: "hierarchy",
+      args: githubHierarchyArgs(
+        { repository: subject.tracker },
+        subject.issue,
+        null
+      ),
+    },
+  ];
+  if (subject.phase !== STAGE_PHASE)
+    records.push({
+      kind: "plain",
+      args: pullRequestViewArgs(
+        subject.pr?.number,
+        subject.branch,
+        subject.repository
+      ),
+    });
+  if (subject.phase === BACKLINK_PHASE)
+    records.push({
+      kind: "comments",
+      args: githubBacklinkListArgs(subject.tracker, subject.issue),
+    });
+  return records;
+}
+
+/** Only hook verification receives attestation/provider reads; stage has no premature proof scope. */
+function proofRequests(subject) {
+  if (subject.phase !== "hook-read") return [];
+  const repository = subject.repository;
+  const endpoints = [
+    `repos/${repository}`,
+    `repos/${repository}/git/ref/heads/main`,
+    `repos/${repository}/actions/runs/${subject.origin.runId}/attempts/${subject.origin.runAttempt}`,
+    `repos/${subject.tracker}/issues/comments/${subject.claim}`,
+  ];
+  if (subject.recovery)
+    endpoints.push(
+      `repos/${repository}/actions/runs/${subject.recovery.runId}/attempts/${subject.recovery.runAttempt}`,
+      `repos/${repository}/issues/${subject.issue}`,
+      `repos/${repository}/git/matching-refs/heads/${subject.branch}`
+    );
+  const records = endpoints.map(endpoint => ({
+    kind: "plain",
+    args: api(endpoint),
+  }));
+  if (subject.recovery)
+    records.push(
+      { kind: "recovery-page", page: 1, args: recoveryPage(subject, 1) },
+      {
+        kind: "plain",
+        args: [
+          "api",
+          "--hostname",
+          "github.com",
+          "--include",
+          `repos/${repository}/assignees/${subject.maintainer}`,
+        ],
+      }
+    );
+  for (const proof of subject.proofs)
+    records.push(proofRequest(subject, proof));
+  return records;
+}
+
+function proofRequest(subject, proof) {
+  keys(proof, [
+    "file",
+    "bundle",
+    "predicate",
+    "signerWorkflow",
+    "signerDigest",
+  ]);
+  required(
+    [proof.file, proof.bundle].every(
+      value =>
+        typeof value === "string" &&
+        value.startsWith("/") &&
+        !/[\0\n]/.test(value)
+    ) &&
+      [PROPOSAL_PREDICATE, RECOVERY_PREDICATE].includes(proof.predicate) &&
+      /^[a-f0-9]{40}$/.test(proof.signerDigest) &&
+      /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/\.github\/workflows\/[A-Za-z0-9_.-]+\.ya?ml$/.test(
+        proof.signerWorkflow
+      ),
+    "invalid fixed GH proof request"
+  );
+  return {
+    kind: "plain",
+    args: officialArguments(
+      {
+        repository: subject.repository,
+        signerWorkflow: proof.signerWorkflow,
+        signerDigest: proof.signerDigest,
+      },
+      subject,
+      proof.file,
+      proof.bundle,
+      proof.predicate
+    ),
+  };
+}
+
+/** This finite subject catalogue grants no native execution or credentials. */
+export function createGhRequests(subject) {
+  checkedSubject(subject);
+  const snapshot = JSON.parse(JSON.stringify(subject));
+  const records = [...ordinaryRequests(snapshot), ...proofRequests(snapshot)];
+  required(
+    records.length <= 64 &&
+      new Set(records.map(record => key(record.args))).size === records.length,
+    "ambiguous GH request catalogue"
+  );
+  return { subject: snapshot, records };
+}
+
+export {
+  createGhState,
+  prepareGhRequest,
+  observeGhResponse,
+} from "./npm-update-gh-grants.mjs";

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

@@ -0,0 +1,214 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Bounded trusted GitHub transport. @module npm-updater */
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { assertPinnedVerifier } from "./github-attestation-verifier.mjs";
+import { required } from "./npm-update-contract.mjs";
+import { runProcess } from "./npm-update-process.mjs";
+import { gitObjectId } from "./npm-update-object.mjs";
+import { FILES } from "./npm-update-contract.mjs";
+import { executeCanonicalHelper } from "./npm-update-controller-factory.mjs";
+/** Explicit minimum gh identity and token; no caller/candidate executable override. */
+const HOST_OPTION = "--hostname";
+const GITHUB_HOST = "github.com";
+const TRANSPORT_PATH = "/usr/bin:/bin";
+const NO_HOME = "/nonexistent";
+
+export class GitHub {
+  constructor(policy, token, execute = runProcess) {
+    assertPinnedVerifier(policy);
+    required(
+      typeof token === "string" && token.length > 0,
+      "job-scoped GitHub token is absent"
+    );
+    this.policy = policy;
+    this.token = token;
+    this.execute = execute;
+  }
+  async request(endpoint, method = "GET", body) {
+    required(
+      endpoint.startsWith(`repos/${this.policy.repository}/`) ||
+        endpoint === `repos/${this.policy.repository}` ||
+        endpoint.startsWith("search/issues?"),
+      "provider endpoint outside configured repository"
+    );
+    const args = [
+      "api",
+      HOST_OPTION,
+      GITHUB_HOST,
+      "--method",
+      method,
+      endpoint,
+    ];
+    if (body) args.push("--input", "-");
+    const result = await this.execute(this.policy.ghExecutable, args, {
+      env: {
+        PATH: TRANSPORT_PATH,
+        GH_TOKEN: this.token,
+        GH_HOST: GITHUB_HOST,
+        HOME: NO_HOME,
+        GIT_TERMINAL_PROMPT: "0",
+      },
+      input: body ? canonicalJson(body) : undefined,
+      timeout: 30_000,
+    });
+    const bytes = result.stdout;
+    required(bytes.length <= 3_145_728, "provider response exceeds bound");
+    return bytes.length
+      ? JSON.parse(new TextDecoder("utf8", { fatal: true }).decode(bytes))
+      : null;
+  }
+  async list(endpoint) {
+    const entries = [];
+    for (let page = 1; page <= 20; page++) {
+      const batch = await this.request(
+        `${endpoint}${endpoint.includes("?") ? "&" : "?"}per_page=100&page=${page}`
+      );
+      required(Array.isArray(batch), "provider page is not an array");
+      entries.push(...batch);
+      if (batch.length < 100) return entries;
+    }
+    throw new Error("npm updater: provider pagination exceeded bound");
+  }
+  /** Absence is a proved 404, never a read error interpreted as empty state. */
+  async maybe(endpoint) {
+    required(
+      endpoint.startsWith(`repos/${this.policy.repository}/`),
+      "recovery endpoint outside configured repository"
+    );
+    const result = await this.execute(
+      this.policy.ghExecutable,
+      ["api", HOST_OPTION, GITHUB_HOST, "--include", endpoint],
+      {
+        env: {
+          PATH: TRANSPORT_PATH,
+          GH_TOKEN: this.token,
+          HOME: NO_HOME,
+        },
+        allowed: [0, 1],
+        timeout: 30_000,
+      }
+    );
+    const text = result.stdout.toString();
+    const split = text.includes("\r\n\r\n") ? "\r\n\r\n" : "\n\n";
+    const status = /^HTTP\/\S+ (\d+)\b/.exec(text);
+    required(Boolean(status), "recovery provider status missing");
+    if (status[1] === "404") return null;
+    required(
+      result.code === 0 && status[1] === "200",
+      "recovery provider refused read"
+    );
+    return JSON.parse(text.slice(text.indexOf(split) + split.length));
+  }
+  async issue(number) {
+    required(
+      Number.isSafeInteger(number) && number > 0,
+      "invalid live issue number"
+    );
+    const path = `repos/${this.policy.repository}/issues/${number}`;
+    const issue = await this.request(path);
+    issue.comments = await this.list(`${path}/comments`);
+    issue.children = await this.list(`${path}/sub_issues`);
+    issue.blockers = await this.list(`${path}/dependencies/blocked_by`);
+    return issue;
+  }
+  async main(parent) {
+    const repo = await this.request(`repos/${this.policy.repository}`);
+    required(
+      repo.full_name === this.policy.repository &&
+        repo.default_branch === "main" &&
+        String(repo.id) === this.policy.repositoryId &&
+        String(repo.owner.id) === this.policy.ownerId,
+      "actual repository identity differs"
+    );
+    const main = await this.request(
+      `repos/${this.policy.repository}/git/ref/heads/main`
+    );
+    required(main.object?.sha === parent, "actual main parent changed");
+    return repo;
+  }
+  async assignable(login) {
+    const result = await this.execute(
+      this.policy.ghExecutable,
+      [
+        "api",
+        HOST_OPTION,
+        GITHUB_HOST,
+        "--include",
+        `repos/${this.policy.repository}/assignees/${login}`,
+      ],
+      {
+        env: {
+          PATH: TRANSPORT_PATH,
+          GH_TOKEN: this.token,
+          HOME: NO_HOME,
+        },
+        timeout: 30_000,
+      }
+    );
+    required(
+      /^HTTP\/\S+ 204\b/m.test(result.stdout.toString()),
+      "trusted maintainer is not currently assignable"
+    );
+  }
+  /** Invoke the shipped tracker writer/validator, preserving configured full/trailer mode. */
+  async workItem(cwd, args, authority) {
+    required(
+      ["backlink", "validate-pr"].includes(args[0]) &&
+        args.every(value => typeof value === "string"),
+      "unsupported traceability operation"
+    );
+    required(
+      authority?.config && authority?.pr && authority?.descriptor,
+      "authenticated publication controller authority is absent"
+    );
+    const phase =
+      args[0] === "backlink"
+        ? "publication-backlink"
+        : "publication-validate-pr";
+    return executeCanonicalHelper(
+      { ...authority, cwd, token: this.token },
+      phase,
+      args[0],
+      authority.pr,
+      args
+    );
+  }
+  /** Git API writes reproduce only the already qualified raw commit and complete tree. */
+  async gitCommit(proposal, descriptor, commit, authorize, cwd) {
+    const path = `repos/${this.policy.repository}/git`;
+    const tree = [];
+    for (const file of FILES) {
+      await authorize();
+      const bytes = Buffer.from(proposal.files[file]);
+      const blob = await this.request(`${path}/blobs`, "POST", {
+        content: bytes.toString("base64"),
+        encoding: "base64",
+      });
+      const sha = gitObjectId(cwd, "blob", bytes);
+      required(blob.sha === sha, "provider blob bytes differ");
+      tree.push({ path: file, mode: "100644", type: "blob", sha });
+    }
+    const parent = await this.request(`${path}/commits/${proposal.parent}`);
+    await authorize();
+    const built = await this.request(`${path}/trees`, "POST", {
+      base_tree: parent.tree.sha,
+      tree,
+    });
+    required(built.sha === descriptor.tree, "provider complete tree differs");
+    await authorize();
+    const created = await this.request(`${path}/commits`, "POST", {
+      message: commit.message,
+      tree: built.sha,
+      parents: [proposal.parent],
+      author: commit.author,
+      committer: commit.committer,
+    });
+    required(
+      created.sha === commit.sha,
+      "provider raw commit cannot preserve the gated SHA"
+    );
+    return created;
+  }
+}

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

@@ -0,0 +1,238 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Fixed authenticated data qualifies complete import and canonical-child closures without evaluating source. */
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { isBuiltin } from "node:module";
+import { posix } from "node:path";
+
+import {
+  managedTemplateMembers,
+  HELPER_CONTROLS as CONTROLS,
+  HELPER_PACKAGE_MEMBERS as PACKAGE,
+} from "./npm-update-helper-inventory.mjs";
+export { managedTemplateMembers } from "./npm-update-helper-inventory.mjs";
+
+/** The independently authenticated classifier retains its one literal canonical dependency. */
+export function classifierGraphMatches(bytes) {
+  const text = bytes.map(value =>
+    new TextDecoder("utf8", { fatal: true }).decode(value)
+  );
+  const importsIn = source =>
+    source
+      .split("\n")
+      .map(line =>
+        line
+          .trim()
+          .replace(/^export\s+(?:async\s+)?(?:function|const|let|class)\b/, "")
+      );
+  const dependenciesIn = source =>
+    importsIn(source).filter(line => /\b(?:import|export)\b/.test(line));
+  const imports = dependenciesIn(text[0]);
+  return (
+    imports.length === 1 &&
+    imports[0] ===
+      'import { isPreWorkLaneType } from "./intake-prework-denominator.mjs";' &&
+    !/\bimport\s*\(/.test(text[0]) &&
+    dependenciesIn(text[1]).length === 0 &&
+    !/\bimport\s*\(/.test(text[1])
+  );
+}
+
+/** Relative normalized names never authorize traversal, URLs, absolute paths or unknown helpers. */
+function memberPath(member) {
+  assert(
+    typeof member === "string" &&
+      member.length <= 256 &&
+      member === posix.normalize(member) &&
+      !member.startsWith("/") &&
+      !member.split("/").includes("..") &&
+      !/[\\\0\n]/.test(member) &&
+      (managedTemplateMembers().has(member) || PACKAGE.includes(member)),
+    "helper path is outside the fixed inventory"
+  );
+}
+
+function fields(value, expected) {
+  assert(
+    value &&
+      typeof value === "object" &&
+      !Array.isArray(value) &&
+      Object.getPrototypeOf(value) === Object.prototype &&
+      Object.keys(value).sort().join("\n") === [...expected].sort().join("\n"),
+    "helper graph schema differs"
+  );
+}
+
+/** Every declared edge is finite, unique and points to a builtin or another fixed member. */
+function edges(record, field) {
+  const values = record[field];
+  assert(
+    Array.isArray(values) &&
+      values.length <= 64 &&
+      new Set(values).size === values.length,
+    "helper edges are ambiguous or unbounded"
+  );
+  for (const value of values) {
+    if (
+      field !== "children" &&
+      typeof value === "string" &&
+      value.startsWith("node:") &&
+      isBuiltin(value)
+    )
+      continue;
+    memberPath(value);
+  }
+  return values.filter(value => !value.startsWith("node:"));
+}
+
+/**
+ * @typedef {{staticImports: string[], dynamicImports: string[], children: string[]}} HelperEdges
+ * @typedef {HelperEdges & {sha256: string}} HelperMember
+ * @typedef {{version: 1, controls: Record<string, HelperEdges>, members: Record<string, HelperMember>}} HelperManifest
+ */
+
+/**
+ * SHA256 binds static, literal dynamic and canonical subprocess edges to the actual audited source.
+ * @returns {HelperManifest} The closed validated manifest.
+ */
+export function validateHelperManifest(manifest) {
+  fields(manifest, ["version", "controls", "members"]);
+  assert(manifest.version === 1, "unsupported helper graph version");
+  const names = Object.keys(manifest.members ?? {});
+  assert(
+    names.length > 0 && names.length <= 128,
+    "helper member inventory is empty or unbounded"
+  );
+  for (const name of names) {
+    memberPath(name);
+    const record = manifest.members[name];
+    fields(record, ["sha256", "staticImports", "dynamicImports", "children"]);
+    assert(
+      /^[a-f0-9]{64}$/.test(record.sha256),
+      "helper source hash is invalid"
+    );
+    for (const field of ["staticImports", "dynamicImports", "children"])
+      edges(record, field);
+  }
+  assert(
+    manifest.controls &&
+      typeof manifest.controls === "object" &&
+      !Array.isArray(manifest.controls),
+    "helper control inventory differs"
+  );
+  for (const [name, record] of Object.entries(manifest.controls)) {
+    assert(
+      CONTROLS.includes(name) && !Object.hasOwn(manifest.members, name),
+      "unknown or overlapping helper control"
+    );
+    fields(record, ["staticImports", "dynamicImports", "children"]);
+    for (const field of ["staticImports", "dynamicImports", "children"])
+      edges(record, field);
+  }
+  return manifest;
+}
+
+/** Independently authenticated control/manifest bytes avoid an impossible self-inclusive source hash. */
+export function helperManifest(bytes) {
+  assert(
+    Buffer.isBuffer(bytes) && bytes.length <= 262_144,
+    "helper manifest is unbounded"
+  );
+  const text = new TextDecoder("utf8", { fatal: true, ignoreBOM: true }).decode(
+    bytes
+  );
+  const manifest = validateHelperManifest(JSON.parse(text));
+  assert(
+    text === `${JSON.stringify(manifest, null, 2)}\n`,
+    "helper manifest is not canonical readable JSON"
+  );
+  assert(
+    Object.keys(manifest.controls).sort().join("\n") ===
+      [...CONTROLS].sort().join("\n"),
+    "independent helper controls are incomplete"
+  );
+  return manifest;
+}
+
+/** A controller manifest covers the whole fixed inventory; omitted unrelated members cannot mask drift. */
+export function controllerMembers(manifest) {
+  validateHelperManifest(manifest);
+  const expected = [...managedTemplateMembers().keys(), ...PACKAGE].filter(
+    member => !CONTROLS.includes(member)
+  );
+  assert(
+    Object.keys(manifest.members).sort().join("\n") ===
+      expected.sort().join("\n"),
+    "controller helper manifest inventory is incomplete"
+  );
+  return [...expected, ...CONTROLS];
+}
+
+/** This pure check never grants authority; callers authenticate every buffer from one pinned owner first. */
+function checkedClosure(manifest, authenticated, entries) {
+  validateHelperManifest(manifest);
+  const selected = new Set();
+  const visit = name => {
+    memberPath(name);
+    if (selected.has(name)) return;
+    const record = manifest.members[name] ?? manifest.controls[name];
+    assert(record, "helper entry is outside the manifest inventory");
+    const bytes = authenticated.get(name);
+    assert(
+      Buffer.isBuffer(bytes) && bytes.length <= 1_048_576,
+      "authenticated helper member is missing or unbounded"
+    );
+    if (record.sha256)
+      assert(
+        createHash("sha256").update(bytes).digest("hex") === record.sha256,
+        "authenticated helper source hash changed"
+      );
+    selected.add(name);
+    for (const field of ["staticImports", "dynamicImports", "children"])
+      for (const child of edges(record, field)) visit(child);
+  };
+  for (const entry of entries) visit(entry);
+  return [...selected].sort();
+}
+
+/** The external selector remains bounded independently of the fixed authority inventory. */
+export function assertManagedSelection(entries) {
+  assert(
+    Array.isArray(entries) &&
+      entries.length > 0 &&
+      entries.length <= 64 &&
+      new Set(entries).size === entries.length,
+    "helper selection is ambiguous"
+  );
+}
+
+/** External callers select at most64 unique roots; fixed control nodes do not consume that budget. */
+export function managedClosure(manifest, authenticated, entries) {
+  assertManagedSelection(entries);
+  assert(authenticated instanceof Map, "helper selection is ambiguous");
+  return checkedClosure(manifest, authenticated, entries);
+}
+
+/** Fixed control authority accompanies a bounded caller's complete selected closure. */
+export function managedControllerSelection(manifest, authenticated, entries) {
+  return [
+    ...new Set([
+      ...managedClosure(manifest, authenticated, entries),
+      ...CONTROLS,
+    ]),
+  ];
+}
+
+/** Complete authority audit accepts exactly the fixed inventory, never an expanded caller selector. */
+export function auditControllerClosure(manifest, authenticated) {
+  const members = controllerMembers(manifest);
+  assert(
+    authenticated instanceof Map &&
+      authenticated.size === members.length &&
+      [...authenticated.keys()].every(member => members.includes(member)),
+    "complete authenticated controller inventory differs"
+  );
+  return checkedClosure(manifest, authenticated, members);
+}