@codyswann/lisa 4.70.4 → 4.71.1

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

@@ -0,0 +1,155 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Literal native process supervision and capture preserve argv/stdin/status and cancellation. */
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { required } from "./npm-update-contract.mjs";
+
+/** The complete supervisor vector, including its control overhead, is bounded literal data. */
+function supervisedArguments(vector) {
+  required(
+    vector.length <= 512 &&
+      vector.every(
+        value =>
+          typeof value === "string" &&
+          !value.includes("\0") &&
+          Buffer.byteLength(value) <= 65_536
+      ) &&
+      Buffer.byteLength(JSON.stringify(vector)) <= 262_144,
+    "invalid or unbounded supervised argument vector"
+  );
+  return vector;
+}
+
+/** Explicit direct argv preserves authenticated bootstrap arguments without a shell hop. */
+function startSupervised(command, args, timeout, cwd, env) {
+  const supervisor = fileURLToPath(
+    new URL("./process-tree-runner.mjs", import.meta.url)
+  );
+  required(
+    typeof command === "string" && command.length > 0 && Array.isArray(args),
+    "literal executable and arguments required"
+  );
+  return spawn(
+    process.execPath,
+    supervisedArguments([
+      supervisor,
+      `--timeout-ms=${timeout}`,
+      `--watch-pid=${process.pid}`,
+      "--direct-argv",
+      "--",
+      command,
+      ...args,
+    ]),
+    { cwd, env, stdio: ["pipe", "pipe", "pipe"] }
+  );
+}
+
+/**
+ * Execute argv data in an owned session; timeout/output overflow never returns success.
+ * @param {string} command Literal executable.
+ * @param {string[]} args Original argument vector.
+ * @param {{cwd?: string, env?: NodeJS.ProcessEnv, input?: string | Buffer,
+ * timeout?: number, allowed?: number[], maximum?: number,
+ * signal?: AbortSignal}} [options] Bounded execution.
+ * @returns {Promise<{code: number, stdout: Buffer, stderr: Buffer}>} Actual child result.
+ */
+export function runProcess(
+  command,
+  args,
+  {
+    cwd,
+    env,
+    input,
+    timeout = 30_000,
+    allowed = [0],
+    maximum = 3_145_728,
+    signal: abortSignal,
+  } = {}
+) {
+  required(
+    process.platform !== "win32",
+    "owned process sessions require Linux or macOS"
+  );
+  required(
+    Number.isInteger(timeout) && timeout > 0 && timeout <= 1_800_000,
+    "invalid child deadline"
+  );
+  required(
+    abortSignal === undefined || abortSignal instanceof AbortSignal,
+    "invalid child cancellation signal"
+  );
+  required(!abortSignal?.aborted, "child was cancelled before execution");
+  return new Promise((resolve, reject) => {
+    const child = startSupervised(command, args, timeout, cwd, env);
+    captureProcess(child, {
+      command,
+      input,
+      timeout,
+      allowed,
+      maximum,
+      abortSignal,
+    }).then(resolve, reject);
+  });
+}
+
+/** Native close, not cancellation delivery, completes an owned child. */
+function captureProcess(
+  child,
+  { command, input, timeout, allowed, maximum, abortSignal }
+) {
+  return new Promise((resolveResult, reject) => {
+    const chunks = [];
+    const errors = [];
+    let size = 0;
+    let failure;
+    let closed = false;
+    const stop = reason => {
+      failure ??= new Error(`npm updater: ${reason}`);
+      if (!closed && child.pid) child.kill("SIGTERM");
+    };
+    const abort = () => stop("child was cancelled");
+    abortSignal?.addEventListener("abort", abort, { once: true });
+    if (abortSignal?.aborted) abort();
+    const timer = setTimeout(() => stop("child exceeded deadline"), timeout);
+    const collect = target => data => {
+      size += data.length;
+      if (size > maximum) stop("child output exceeded bound");
+      else target.push(data);
+    };
+    child.stdout.on("data", collect(chunks));
+    child.stderr.on("data", collect(errors));
+    child.on("error", error => {
+      failure = error;
+    });
+    child.stdin.on("error", error => {
+      if (error.code !== "EPIPE") stop("child input failed");
+    });
+    child.stdin.end(input);
+    child.on("close", (code, signal) => {
+      closed = true;
+      clearTimeout(timer);
+      abortSignal?.removeEventListener("abort", abort);
+      if (failure || signal || !allowed.includes(code)) {
+        const error =
+          failure ?? new Error(`npm updater: child failed (${code ?? signal})`);
+        reject(
+          Object.assign(error, {
+            stdout: Buffer.concat(chunks),
+            stderr: Buffer.concat(errors),
+            command,
+            code,
+            nativeCompleted: !failure && !signal,
+          })
+        );
+        return;
+      }
+      resolveResult({
+        code,
+        stdout: Buffer.concat(chunks),
+        stderr: Buffer.concat(errors),
+      });
+    });
+  });
+}

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

@@ -0,0 +1,190 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Genuine immutable npm and released helper identity preserve native engine policy. */
+import {
+  lstatSync,
+  existsSync,
+  constants,
+  openSync,
+  closeSync,
+  fstatSync,
+  readSync,
+  realpathSync,
+} from "node:fs";
+import { createHash } from "node:crypto";
+import { join, dirname, isAbsolute, parse } from "node:path";
+import { required } from "./npm-update-contract.mjs";
+import { readBytes, runProcess } from "./npm-update-process-core.mjs";
+import { sha256 } from "./github-attestation-verifier.mjs";
+
+/** Ascend from the actual entry; a host manifest never becomes the Lisa package owner. */
+export function findLisaPackageOwner(entry) {
+  let directory = dirname(realpathSync(entry));
+  const root = parse(directory).root;
+  while (directory !== root) {
+    const manifest = join(directory, "package.json");
+    if (existsSync(manifest)) {
+      const metadata = JSON.parse(readBytes(manifest, 1_048_576, false));
+      if (metadata.name === "@codyswann/lisa")
+        return { root: directory, metadata };
+    }
+    directory = dirname(directory);
+  }
+  return undefined;
+}
+
+/** Stream a bounded regular archive so its actual bytes, not metadata, prove registry integrity. */
+export function archiveIntegrity(file) {
+  const fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = fstatSync(fd);
+    required(
+      lstatSync(file).isFile() &&
+        !lstatSync(file).isSymbolicLink() &&
+        stat.isFile() &&
+        stat.nlink === 1 &&
+        stat.uid === process.getuid() &&
+        stat.size > 0 &&
+        stat.size <= 150_000_000,
+      "invalid bounded owned helper archive"
+    );
+    const hash = createHash("sha512");
+    const buffer = Buffer.alloc(65_536);
+    let total = 0;
+    let count;
+    while ((count = readSync(fd, buffer, 0, buffer.length, null)) > 0) {
+      total += count;
+      required(total <= 150_000_000, "helper archive grew beyond bound");
+      hash.update(buffer.subarray(0, count));
+    }
+    return `sha512-${hash.digest("base64")}`;
+  } finally {
+    closeSync(fd);
+  }
+}
+
+/** Public metadata is bounded during consumption and must match the prepared lock. */
+export async function registryVersion(update, proposal) {
+  const response = await fetch(
+    `https://registry.npmjs.org/${encodeURIComponent(update.name)}/${update.to}`,
+    { signal: AbortSignal.timeout(30_000), redirect: "error" }
+  );
+  if (!response.ok || !response.body) {
+    await response.body?.cancel();
+    required(false, "selected registry version is unavailable");
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let length = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      length += value.byteLength;
+      required(length <= 1_048_576, "registry response exceeds bound");
+      chunks.push(Buffer.from(value));
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+  const text = new TextDecoder("utf-8", {
+    fatal: true,
+    ignoreBOM: true,
+  }).decode(Buffer.concat(chunks));
+  const value = JSON.parse(text);
+  const lock = JSON.parse(proposal.files["package-lock.json"]);
+  const item = lock.packages?.[`node_modules/${update.name}`];
+  required(
+    value.name === update.name &&
+      value.version === update.to &&
+      item?.version === update.to &&
+      value.dist?.integrity === item.integrity &&
+      typeof item.integrity === "string" &&
+      value.dist.tarball === item.resolved &&
+      typeof item.resolved === "string",
+    "registry selected version, archive or integrity differs"
+  );
+  return { name: value.name, version: value.version };
+}
+
+/** Run genuine immutable npm11 with the actual required Node interpreter. */
+export async function runNpm(args, options) {
+  const cli = process.env.LISA_NPM_CLI;
+  if (!cli) return runProcess("npm", args, options);
+  required(
+    process.versions.node === "22.23.3" &&
+      isAbsolute(cli) &&
+      !lstatSync(cli).isSymbolicLink(),
+    "qualified Node/npm CLI required"
+  );
+  const metadata = JSON.parse(
+    readBytes(join(dirname(cli), "../package.json"), 1_048_576, false)
+  );
+  required(
+    metadata.name === "npm" &&
+      metadata.version === "11.21.0" &&
+      metadata.engines?.node === "^20.17.0 || >=22.9.0" &&
+      sha256(readBytes(cli, 1_048_576, false)) ===
+        "8e5f6f3429f8cdbe693cdc29904e9d5a7b127a494bd15c804bd54c7403bfcbe7",
+    "immutable supported npm identity differs"
+  );
+  return runProcess(process.execPath, [cli, ...args], options);
+}
+
+/** Resolve only the effective boolean with native precedence, before isolating HOME. */
+export async function effectiveEngineStrict(cwd, source = process.env) {
+  const env = {
+    PATH: source.PATH,
+    HOME: source.HOME,
+    LANG: "C.UTF-8",
+    GIT_TERMINAL_PROMPT: "0",
+  };
+  required(typeof env.HOME === "string", "engine policy HOME is unavailable");
+  const allowed = new Set([
+    "engine_strict",
+    "engine-strict",
+    "userconfig",
+    "globalconfig",
+    "prefix",
+  ]);
+  for (const [name, value] of Object.entries(source))
+    if (
+      allowed.has(name.toLowerCase().replace(/^npm_config_/, "")) &&
+      /^npm_config_/i.test(name)
+    )
+      env[name] = value;
+  const git = args => runProcess("git", args, { cwd, env, maximum: 1_048_576 });
+  const project = join(cwd, ".npmrc");
+  if (existsSync(project)) {
+    required(
+      lstatSync(project).isFile() && !lstatSync(project).isSymbolicLink(),
+      "engine policy project config is aliased"
+    );
+    const entry = (
+      await git(["ls-tree", "HEAD", "--", ".npmrc"])
+    ).stdout.toString();
+    required(
+      entry.startsWith("100644 blob ") && entry.trim().split("\n").length === 1,
+      "engine policy project config is not committed"
+    );
+    const changed = await git(["diff", "--name-only", "HEAD", "--", ".npmrc"]);
+    required(
+      !changed.stdout.length,
+      "engine policy project config differs from HEAD"
+    );
+  }
+  const result = await runNpm(["config", "get", "engine-strict", "--json"], {
+    cwd,
+    env,
+    maximum: 65_536,
+  });
+  required(!result.stderr.length, "engine policy config warning is ambiguous");
+  const text = result.stdout.toString().trim();
+  required(
+    ["true", "false"].includes(text),
+    "engine policy is unresolved or nonboolean"
+  );
+  return text === "true";
+}

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

@@ -0,0 +1,112 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Bounded read-only local Git validates exact protocol identities without granting publication authority. */
+import { isAbsolute } from "node:path";
+import { boundedSpawnSync } from "./bounded-spawn.mjs";
+import { required } from "./npm-update-invariants.mjs";
+import { sha256 } from "./github-attestation-verifier.mjs";
+
+/**
+ * Git computes its own protocol identities without writing an object or running filters.
+ * @param {string} cwd Original trusted publisher checkout.
+ * @param {string} type Closed blob or commit object kind.
+ * @param {Buffer} bytes Exact already bounded raw object contents.
+ * @returns {string} The genuine SHA1 Git object identity.
+ */
+export function gitObjectId(cwd, type, bytes) {
+  required(
+    typeof cwd === "string" && isAbsolute(cwd),
+    "trusted Git cwd required"
+  );
+  required(type === "blob" || type === "commit", "unsupported Git object kind");
+  required(
+    Buffer.isBuffer(bytes) &&
+      bytes.length <= (type === "commit" ? 65_536 : 1_048_576),
+    "bounded raw Git object required"
+  );
+  const options = {
+    cwd,
+    env: {
+      PATH: process.env.PATH,
+      HOME: "/nonexistent",
+      GIT_TERMINAL_PROMPT: "0",
+    },
+    encoding: "utf8",
+    timeout: 30_000,
+    maxBuffer: 128,
+  };
+  const format = boundedSpawnSync(
+    "git",
+    ["rev-parse", "--show-object-format"],
+    options
+  );
+  required(
+    format.status === 0 &&
+      !format.error &&
+      !format.signal &&
+      format.stderr === "" &&
+      format.stdout === "sha1\n",
+    "publisher requires genuine sha1 Git object format"
+  );
+  const result = boundedSpawnSync(
+    "git",
+    ["hash-object", "-t", type, "--stdin"],
+    { ...options, input: bytes }
+  );
+  required(
+    result.status === 0 &&
+      !result.error &&
+      !result.signal &&
+      result.stderr === "" &&
+      /^[a-f0-9]{40}\n$/.test(result.stdout),
+    "native Git object identity unavailable"
+  );
+  return result.stdout.slice(0, -1);
+}
+
+/** GitHub must recreate the actual raw object, including identity, time and message. */
+export function validateRawCommit(bytes, descriptor, cwd) {
+  required(
+    Buffer.isBuffer(bytes) && bytes.length <= 65_536,
+    "bounded raw commit required"
+  );
+  const text = new TextDecoder("utf-8", {
+    fatal: true,
+    ignoreBOM: true,
+  }).decode(bytes);
+  const split = text.indexOf("\n\n");
+  required(split > 0, "invalid raw commit");
+  const fields = text.slice(0, split).split("\n");
+  required(
+    fields.length === 4 &&
+      fields[0] === `tree ${descriptor.tree}` &&
+      fields[1] === `parent ${descriptor.parent}` &&
+      fields[2] === `author ${descriptor.author}` &&
+      fields[3] === `committer ${descriptor.committer}`,
+    "raw commit metadata differs or signature is unsupported"
+  );
+  const message = text.slice(split + 2);
+  required(
+    sha256(Buffer.from(message)) === descriptor.messageSha256,
+    "raw commit message differs"
+  );
+  const sha = gitObjectId(cwd, "commit", bytes);
+  return {
+    sha,
+    message,
+    author: identity(descriptor.author),
+    committer: identity(descriptor.committer),
+  };
+}
+
+/** UTC-only metadata avoids a provider rewriting timezone-sensitive raw bytes. */
+function identity(value) {
+  const match = /^([^\n<>]+) <([^\n<>]+)> ([1-9]\d*) \+0000$/.exec(value);
+  required(Boolean(match), "publisher requires unsigned UTC Git identity");
+  return {
+    name: match[1],
+    email: match[2],
+    date: new Date(Number(match[3]) * 1000).toISOString(),
+  };
+}