@codyswann/lisa 4.70.4 → 4.71.1

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

@@ -0,0 +1,126 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** One fixed source inventory is shared by the closed validator and reproducible generator. */
+const COMMON = [
+  "lisa-work-item.mjs",
+  "lisa-automation-provenance.mjs",
+  "lisa-rails-prepush.mjs",
+  "lisa-history-secrets.mjs",
+  "lisa-gates.mjs",
+  "lisa-run-gates.mjs",
+  "lisa-commit-msg-gates.mjs",
+  "lisa-test-node.mjs",
+  "lib/invoked-as-script.mjs",
+  "lib/bounded-spawn.mjs",
+  "lib/process-tree-runner.mjs",
+  "lib/windows-process-job.mjs",
+  "lib/windows-process-job.ps1",
+  "lib/windows-process-job.cs",
+  "lib/kill-marks.mjs",
+  "lib/gate-failure-diagnosis.mjs",
+  "lib/worktree-dependencies.mjs",
+  "lib/history-secret-git.mjs",
+  "lib/history-secret-scanner.mjs",
+  "lib/history-secret-evidence.mjs",
+  "lib/history-secret-evidence-shape.mjs",
+  "lib/history-secret-policy.mjs",
+  "lib/github-attestation-verifier.mjs",
+  "lib/github-attestation-provider.mjs",
+  "lib/github-attestation-recovery.mjs",
+  "lib/automation-provenance-contract.mjs",
+  "lib/automation-provenance-local.mjs",
+];
+const RAILS = [
+  "lisa-clean-git-env.sh",
+  "lisa-scratch-run.sh",
+  "check-threshold-ratchet.mjs",
+  "threshold-ratchet-families.mjs",
+  "threshold-ratchet-compare.mjs",
+];
+const PRODUCER = [
+  "allocate",
+  "authorization",
+  "broker-client",
+  "checkpoint",
+  "contract",
+  "controller-broker",
+  "controller-factory",
+  "controller-recipe",
+  "execution-adapter",
+  "gate-hooks",
+  "gate-install",
+  "gate-proof",
+  "gate",
+  "gh-dispatch",
+  "gh-grants",
+  "gh-requests",
+  "github",
+  "helper",
+  "helper-graph",
+  "helper-inventory",
+  "hosted-gate",
+  "hosted-hook",
+  "hook-installation",
+  "hook-preload",
+  "hook-provider",
+  "hook-read-client",
+  "invariants",
+  "isolation",
+  "leaf",
+  "leaf-contract",
+  "npm",
+  "native-process",
+  "object",
+  "orchestrator",
+  "owner",
+  "prepare",
+  "process",
+  "process-core",
+  "publication",
+  "publish",
+  "quality",
+  "recovery",
+  "runtime-archive",
+  "runtime-graph",
+  "runtime-transport",
+  "runtime",
+  "tool-launcher",
+  "worker-environment",
+  "worker-inspection",
+  "worker-lifecycle",
+  "worker-policy",
+];
+export const HELPER_CONTROLS = [
+  "lib/npm-update-helper-graph.mjs",
+  "npm-updater-helper-graph.json",
+];
+export const CLASSIFIER_MEMBERS = [
+  "plugins/lisa/scripts/intake-blocker-reprobe.mjs",
+  "plugins/lisa/scripts/intake-prework-denominator.mjs",
+];
+export const OWNER_MEMBERS = [
+  "plugins/lisa/hooks/auto-update.mjs",
+  "plugins/lisa/hooks/auto-update.sh",
+  "plugins/lisa/.codex-plugin/hooks.json",
+];
+export const HELPER_PACKAGE_MEMBERS = CLASSIFIER_MEMBERS.map(
+  member => `package/${member}`
+);
+
+/** Only reviewed upstream templates and fixed classifier package members can enter the inventory. */
+export function managedTemplateMembers() {
+  return new Map([
+    ...[
+      ...COMMON,
+      "lisa-npm-updater.mjs",
+      "npm-updater-helper-graph.json",
+      "npm-updater-gate-runtime.json",
+      "npm-updater-gate-supervisor.c",
+      "npm-updater-gate.Dockerfile",
+      ...PRODUCER.map(name => `lib/npm-update-${name}.mjs`),
+    ].map(member => [member, `all/copy-overwrite/scripts/${member}`]),
+    ...RAILS.map(member => [member, `rails/copy-overwrite/scripts/${member}`]),
+    ["lisa-mutation.sh", "rails/copy-contents/scripts/lisa-mutation.sh"],
+  ]);
+}

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

@@ -0,0 +1,292 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Independent Git or registry archive authority qualifies canonical helpers before import. */
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { existsSync, lstatSync, realpathSync } from "node:fs";
+import { required, VERSION, OBJECT } from "./npm-update-contract.mjs";
+import {
+  readBytes,
+  runProcess,
+  withPrivateRoot,
+} from "./npm-update-process-core.mjs";
+import {
+  runNpm,
+  archiveIntegrity,
+  findLisaPackageOwner,
+} from "./npm-update-npm.mjs";
+import {
+  CLASSIFIER_MEMBERS as MEMBERS,
+  OWNER_MEMBERS,
+} from "./npm-update-helper-inventory.mjs";
+import {
+  managedTemplateMembers,
+  helperManifest,
+  controllerMembers,
+  managedControllerSelection,
+  auditControllerClosure,
+  assertManagedSelection,
+  classifierGraphMatches,
+} from "./npm-update-helper-graph.mjs";
+
+const PACKAGE = "@codyswann/lisa";
+
+/** Native package resolution supports both upstream and actual emitted managed layouts. */
+export function helperOwner() {
+  const local = findLisaPackageOwner(fileURLToPath(import.meta.url));
+  if (local) return { ...local, source: existsSync(join(local.root, ".git")) };
+  let entry;
+  try {
+    entry = createRequire(import.meta.url).resolve(PACKAGE);
+  } catch {
+    throw new Error(
+      "npm updater: qualified installed Lisa helper is unavailable"
+    );
+  }
+  const installed = findLisaPackageOwner(entry);
+  required(installed, "resolved helper has no canonical Lisa package owner");
+  return { ...installed, source: false };
+}
+
+/** The fixed canonical import graph must stay inside its independently qualified package. */
+function helperBytes(root, members) {
+  return members.map(relative => {
+    const file = join(root, relative);
+    required(
+      realpathSync(file) === file &&
+        lstatSync(file).isFile() &&
+        !lstatSync(file).isSymbolicLink(),
+      "canonical helper is aliased or absent"
+    );
+    return readBytes(file, 1_048_576, false);
+  });
+}
+
+/** Current committed Git identity supplies source-local authority; production pins the approved signer. */
+async function sourceAuthority(owner, config, bytes, members) {
+  const env = {
+    PATH: process.env.PATH,
+    HOME: "/nonexistent",
+    GIT_TERMINAL_PROMPT: "0",
+  };
+  const git = args =>
+    runProcess("git", args, { cwd: owner.root, env, maximum: 1_048_576 });
+  const head = (await git(["rev-parse", "HEAD"])).stdout.toString().trim();
+  const expected = config.automationProvenance?.signerDigest ?? head;
+  required(
+    typeof expected === "string" && OBJECT.test(expected),
+    "approved helper Git identity is unavailable"
+  );
+  const trusted = [];
+  for (let index = 0; index < members.length; index++) {
+    let blob;
+    try {
+      blob = (await git(["show", `${expected}:${members[index]}`])).stdout;
+    } catch (cause) {
+      throw new Error(
+        `npm updater: approved helper Git member unavailable: ${members[index]}`,
+        { cause }
+      );
+    }
+    if (bytes)
+      required(
+        blob.equals(bytes[index]),
+        "canonical helper differs from approved Git blob"
+      );
+    trusted.push(blob);
+  }
+  return trusted;
+}
+
+/** Official release identity and integrity authenticate both fixed members without extracting files. */
+async function releaseAuthority(owner, config, bytes, members) {
+  const digest = config.automationProvenance?.signerDigest;
+  required(
+    typeof digest === "string" &&
+      OBJECT.test(digest) &&
+      VERSION.test(owner.metadata.version),
+    "approved release identity is unavailable"
+  );
+  await withPrivateRoot(async (root, env) => {
+    const registry = JSON.parse(
+      (
+        await runNpm(
+          ["view", `${PACKAGE}@${owner.metadata.version}`, "--json"],
+          { env, maximum: 1_048_576 }
+        )
+      ).stdout
+    );
+    required(
+      registry.name === PACKAGE &&
+        registry.version === owner.metadata.version &&
+        registry.gitHead === digest &&
+        typeof registry.dist?.integrity === "string",
+      "registry helper identity differs from approved source"
+    );
+    const packed = JSON.parse(
+      (
+        await runNpm(
+          [
+            "pack",
+            `${PACKAGE}@${owner.metadata.version}`,
+            "--ignore-scripts",
+            "--json",
+            "--pack-destination",
+            root,
+          ],
+          { cwd: root, env, timeout: 120_000, maximum: 1_048_576 }
+        )
+      ).stdout
+    );
+    const filename = `codyswann-lisa-${owner.metadata.version}.tgz`;
+    required(
+      Array.isArray(packed) &&
+        packed.length === 1 &&
+        packed[0].filename === filename,
+      "registry archive selection differs"
+    );
+    const archive = join(root, filename);
+    required(
+      archiveIntegrity(archive) === registry.dist.integrity,
+      "actual helper archive registry integrity differs"
+    );
+    for (let index = 0; index < members.length; index++) {
+      const member = `package/${members[index]}`;
+      const listing = await runProcess("tar", ["-tzf", archive, "--", member], {
+        env,
+        maximum: 65_536,
+      });
+      required(
+        listing.stdout.toString() === `${member}\n`,
+        "canonical archive member is missing or ambiguous"
+      );
+      const result = await runProcess("tar", ["-xOf", archive, "--", member], {
+        env,
+        maximum: 1_048_576,
+      });
+      required(
+        result.stdout.equals(bytes[index]),
+        "installed canonical helper differs from authenticated archive"
+      );
+    }
+  });
+}
+
+/** Only fixed canonical lifecycle files can be selected by trusted callers. */
+export async function qualifiedHelperFiles(config, members) {
+  required(
+    Array.isArray(members) &&
+      members.length > 0 &&
+      members.length <= 5 &&
+      new Set(members).size === members.length &&
+      members.every(member => [...MEMBERS, ...OWNER_MEMBERS].includes(member)),
+    "unsupported canonical helper selection"
+  );
+  const owner = helperOwner();
+  const bytes = helperBytes(owner.root, members);
+  if (owner.source) await sourceAuthority(owner, config, bytes, members);
+  else await releaseAuthority(owner, config, bytes, members);
+  return {
+    ...owner,
+    bytes: new Map(members.map((member, index) => [member, bytes[index]])),
+  };
+}
+
+/** Emitted hook bytes gain authority only from exact independently authenticated templates. */
+export async function qualifiedManagedFiles(cwd, config, members) {
+  const inventory = managedTemplateMembers();
+  required(
+    Array.isArray(members) &&
+      members.length > 0 &&
+      members.length <= inventory.size &&
+      new Set(members).size === members.length &&
+      members.every(member => inventory.has(member)),
+    "unsupported managed helper selection"
+  );
+  required(
+    OBJECT.test(config.automationProvenance?.signerDigest ?? ""),
+    "immutable managed helper authority is missing"
+  );
+  required(
+    typeof cwd === "string" && cwd.startsWith("/") && realpathSync(cwd) === cwd,
+    "managed workspace is aliased or unavailable"
+  );
+  const owner = helperOwner();
+  const templates = members.map(member => inventory.get(member));
+  const bytes = owner.source
+    ? await sourceAuthority(owner, config, null, templates)
+    : helperBytes(owner.root, templates);
+  if (!owner.source) await releaseAuthority(owner, config, bytes, templates);
+  const graph = {};
+  for (let index = 0; index < members.length; index++) {
+    const file = join(cwd, "scripts", members[index]);
+    required(
+      realpathSync(file) === file &&
+        !lstatSync(file).isSymbolicLink() &&
+        readBytes(file, 1_048_576, false).equals(bytes[index]),
+      "managed consumer helper differs from authenticated template"
+    );
+    graph[file] = createHash("sha256").update(bytes[index]).digest("hex");
+  }
+  return graph;
+}
+
+/** Authenticate one owner's control, manifest and complete byte graph before selecting controller entries. */
+export async function qualifiedControllerGraph(cwd, config, entries) {
+  assertManagedSelection(entries);
+  const controls = [
+    "lib/npm-update-helper-graph.mjs",
+    "npm-updater-helper-graph.json",
+  ];
+  const checked = await qualifiedManagedFiles(cwd, config, controls);
+  const manifest = helperManifest(
+    readBytes(join(cwd, "scripts", controls[1]), 262_144, false)
+  );
+  const members = controllerMembers(manifest);
+  const managed = members.filter(member => !member.startsWith("package/"));
+  Object.assign(checked, await qualifiedManagedFiles(cwd, config, managed));
+  const owner = await qualifiedHelperFiles(config, MEMBERS);
+  const authenticated = new Map();
+  const paths = new Map();
+  for (const member of members) {
+    const packaged = member.startsWith("package/");
+    const relative = packaged ? member.slice("package/".length) : member;
+    const file = join(packaged ? owner.root : join(cwd, "scripts"), relative);
+    const bytes = readBytes(file, 1_048_576, false);
+    required(
+      packaged
+        ? bytes.equals(owner.bytes.get(relative))
+        : createHash("sha256").update(bytes).digest("hex") === checked[file],
+      "authenticated controller helper changed during selection"
+    );
+    authenticated.set(member, bytes);
+    paths.set(member, file);
+  }
+  // Audit every authenticated member, then select the actual complete entry closure.
+  auditControllerClosure(manifest, authenticated);
+  const selected = managedControllerSelection(manifest, authenticated, entries);
+  return Object.fromEntries(
+    [...selected].map(member => [
+      paths.get(member),
+      createHash("sha256").update(authenticated.get(member)).digest("hex"),
+    ])
+  );
+}
+
+/** No canonical package code is imported until independent authority qualifies its fixed graph. */
+export async function canonicalClassifier(config) {
+  const owner = await qualifiedHelperFiles(config, MEMBERS);
+  required(
+    classifierGraphMatches(MEMBERS.map(member => owner.bytes.get(member))),
+    "canonical helper import graph differs"
+  );
+  const module = await import(pathToFileURL(join(owner.root, MEMBERS[0])).href);
+  required(
+    typeof module.humanGateVerdict === "function",
+    "canonical hold classifier is unavailable"
+  );
+  return module.humanGateVerdict;
+}

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

@@ -0,0 +1,116 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Original manager readback preserves installed bytes; dispatch qualification is a separate obligation. */
+import { lstatSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { keys, required } from "./npm-update-contract.mjs";
+import { readBytes } from "./npm-update-process.mjs";
+import { sha256 } from "./github-attestation-verifier.mjs";
+
+const HOOKS = ["pre-commit", "prepare-commit-msg", "commit-msg", "pre-push"];
+const HEX = /^[a-f0-9]{64}$/;
+
+/** Native Git resolves the real installation, including its configured path, without a configuration override. */
+async function installedDirectory(cwd, command) {
+  const result = await command(["rev-parse", "--git-path", "hooks"]);
+  required(
+    Buffer.isBuffer(result.stdout) && result.stdout.length <= 4096,
+    "installed hook path readback is unbounded"
+  );
+  const text = new TextDecoder("utf8", { fatal: true }).decode(result.stdout);
+  required(
+    text.endsWith("\n") && !/[\n\r\0]/.test(text.slice(0, -1)),
+    "installed hook path is unsupported"
+  );
+  const directory = resolve(cwd, text.slice(0, -1));
+  required(
+    directory.startsWith(`${cwd}/`) &&
+      realpathSync(directory) === directory &&
+      lstatSync(directory).isDirectory() &&
+      !lstatSync(directory).isSymbolicLink(),
+    "installed hook directory escapes its checkout or is aliased"
+  );
+  return directory;
+}
+
+/** A separately observed manager installation binds all hooks that an ordinary commit/push can execute. */
+function checkedWrappers(directory, authority) {
+  keys(authority, ["manager", "wrappers"]);
+  required(
+    ["husky", "lefthook"].includes(authority.manager),
+    "unsupported original hook manager"
+  );
+  keys(authority.wrappers, HOOKS);
+  for (const name of HOOKS) {
+    const file = join(directory, name);
+    const stat = lstatSync(file);
+    required(
+      stat.isFile() &&
+        !stat.isSymbolicLink() &&
+        realpathSync(file) === file &&
+        (stat.mode & 0o111) !== 0,
+      "original installed wrapper is missing, nonexecutable or aliased"
+    );
+    required(
+      HEX.test(authority.wrappers[name]) &&
+        sha256(readBytes(file, 65_536, false)) === authority.wrappers[name],
+      "original installed wrapper differs from qualified installation"
+    );
+  }
+}
+
+/** Committed manager configuration is unchanged; this hash does not bless application commands. */
+async function sourceReadback(cwd, command, source) {
+  const bytes = readBytes(join(cwd, source), 1_048_576, false);
+  const committed = await command(["show", `HEAD:${source}`]);
+  required(
+    Buffer.isBuffer(committed.stdout) && bytes.equals(committed.stdout),
+    "original hook source differs from committed source"
+  );
+  return sha256(bytes);
+}
+
+/** Lefthook requires actual installation receipts; legacy Husky source readback retains its original contract. */
+export async function originalHookInstallation(cwd, command, authority) {
+  required(realpathSync(cwd) === cwd, "original hook checkout is aliased");
+  const directory = await installedDirectory(cwd, command);
+  const husky = [join(cwd, ".husky"), join(cwd, ".husky/_")].includes(
+    directory
+  );
+  if (authority !== undefined) {
+    required(
+      authority.manager === (husky ? "husky" : "lefthook"),
+      "original hook manager differs"
+    );
+    checkedWrappers(directory, authority);
+  }
+  if (!husky) {
+    required(
+      authority !== undefined,
+      "original Lefthook installation qualification is absent"
+    );
+  }
+  const source = husky ? ".husky/pre-push" : "lefthook.yml";
+  const path = join(directory, "pre-push");
+  const stat = lstatSync(path);
+  required(
+    stat.isFile() &&
+      !stat.isSymbolicLink() &&
+      realpathSync(path) === path &&
+      (stat.mode & 0o111) !== 0,
+    "original pre-push installation is missing or aliased"
+  );
+  return {
+    manager: husky ? "husky" : "lefthook",
+    path,
+    source,
+    sourceSha256: await sourceReadback(cwd, command, source),
+    wrapperSha256: sha256(readBytes(path, 65_536, false)),
+  };
+}
+
+/** Compatibility export returns the same original executable path; no replacement gate is constructed. */
+export async function originalPrePush(cwd, command, authority) {
+  return (await originalHookInstallation(cwd, command, authority)).path;
+}

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

@@ -0,0 +1,153 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Read-only provider routing instruments authenticated hook code, not arbitrary application Node programs. */
+import childProcess from "node:child_process";
+import { syncBuiltinESMExports } from "node:module";
+import { resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  hostedHookContext,
+  hookEntry,
+  hookReadSlot,
+  tokenFreeHookEnvironment,
+} from "./npm-update-hosted-hook.mjs";
+import { synchronousHookRead } from "./npm-update-hook-read-client.mjs";
+import { required } from "./npm-update-contract.mjs";
+
+const ENTRY = fileURLToPath(import.meta.url);
+const original = {
+  spawn: childProcess.spawn,
+  spawnSync: childProcess.spawnSync,
+  execFile: childProcess.execFile,
+  execFileSync: childProcess.execFileSync,
+};
+const file = process.env.LISA_NPM_HOSTED_HOOK_CONTEXT;
+
+function providerCall(context, entry, argv, command, args, options) {
+  if (command !== "gh" && command !== context.native.gh.path) return null;
+  const slot = hookReadSlot(entry, argv, process.env.LISA_NPM_HOOK_ROLE);
+  required(slot !== null, "hook caller has no provider read recipe");
+  return synchronousHookRead(
+    context,
+    slot,
+    args,
+    options,
+    original.spawnSync,
+    context.native.node.path
+  );
+}
+
+/** Canonical children retain instrumentation; application processes receive neither token nor read-context channel. */
+function nativeChild(context, command, args, options) {
+  const env = tokenFreeHookEnvironment(options.env ?? process.env);
+  delete env.LISA_NPM_HOSTED_HOOK_CONTEXT;
+  if (
+    command === "node" ||
+    command === process.execPath ||
+    command === context.native.node.path
+  ) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const entry = hookEntry(context, args, cwd);
+    if (entry) {
+      required(
+        !args.some(arg =>
+          /^(?:-r|--require|--import|--(?:experimental-)?loader)(?:=|$)/.test(
+            arg
+          )
+        ),
+        "unqualified canonical hook loader"
+      );
+      env.LISA_NPM_HOSTED_HOOK_CONTEXT = context.file;
+      return {
+        command: context.native.node.path,
+        args: ["--import", pathToFileURL(ENTRY).href, ...args],
+        options: { ...options, env },
+      };
+    }
+  }
+  return { command, args, options: { ...options, env } };
+}
+
+/** Preserve Node's documented optional argv/options overloads, including native buffers and FDs. */
+function invocationArguments(args, options) {
+  return Array.isArray(args)
+    ? { args, options: options ?? {} }
+    : { args: [], options: args ?? {} };
+}
+
+function initialize() {
+  required(
+    typeof file === "string" && file.length > 0,
+    "hosted hook context is absent"
+  );
+  const context = hostedHookContext(file);
+  const argv = [...process.execArgv.slice(2), ...process.argv.slice(1)];
+  const entry = hookEntry(context, argv, process.cwd());
+  required(
+    entry !== null &&
+      process.execArgv[0] === "--import" &&
+      process.execArgv[1] === pathToFileURL(ENTRY).href &&
+      !process.env.GH_TOKEN &&
+      !process.env.GITHUB_TOKEN,
+    "hosted provider caller is unqualified or credentialed"
+  );
+  for (const method of ["spawn", "spawnSync", "execFileSync"])
+    childProcess[method] = (command, suppliedArgs, suppliedOptions) => {
+      const { args, options } = invocationArguments(
+        suppliedArgs,
+        suppliedOptions
+      );
+      if (command === "gh" || command === context.native.gh.path) {
+        required(
+          method === "spawnSync",
+          "hook provider requires synchronous native call"
+        );
+        return providerCall(context, entry, argv, command, args, options);
+      }
+      const selected = nativeChild(context, command, args, options);
+      return original[method](
+        selected.command,
+        selected.args,
+        selected.options
+      );
+    };
+  childProcess.execFile = (
+    command,
+    suppliedArgs,
+    suppliedOptions,
+    suppliedCallback
+  ) => {
+    let args = suppliedArgs,
+      options = suppliedOptions,
+      callback = suppliedCallback;
+    if (typeof args === "function") {
+      callback = args;
+      args = [];
+      options = {};
+    } else if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    const normalized = invocationArguments(args, options);
+    required(
+      command !== "gh" && command !== context.native.gh.path,
+      "hook provider requires synchronous native call"
+    );
+    const selected = nativeChild(
+      context,
+      command,
+      normalized.args,
+      normalized.options
+    );
+    return original.execFile(
+      selected.command,
+      selected.args,
+      selected.options,
+      callback
+    );
+  };
+  syncBuiltinESMExports();
+}
+
+initialize();