@codyswann/lisa 4.70.4 → 4.71.0

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

@@ -0,0 +1,263 @@
+// 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-prepare.mjs
+ * @description Real script-free npm installations distinguish current packages from missing trees.
+ * @module npm-updater
+ */
+import {
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  readdirSync,
+  existsSync,
+} from "node:fs";
+import { join } from "node:path";
+import {
+  FILES,
+  SECTIONS,
+  required,
+  validatePolicy,
+  validateHost,
+  validateLock,
+  proposalFrom,
+} from "./npm-update-contract.mjs";
+import {
+  runProcess,
+  runNpm,
+  withPrivateRoot,
+  effectiveEngineStrict,
+} from "./npm-update-process.mjs";
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { qualifyLisaOwner } from "./npm-update-owner.mjs";
+export { qualifyLisaOwner } from "./npm-update-owner.mjs";
+import { sha256 } from "./github-attestation-verifier.mjs";
+
+const NPM_FLAGS = ["--ignore-scripts", "--no-audit", "--no-fund"];
+
+/** Actual installed versions, not only lock entries, reach npm's outdated boundary. */
+function installedVersions(directory, selections) {
+  return Object.fromEntries(
+    selections.map(({ name }) => [
+      name,
+      JSON.parse(
+        readFileSync(
+          join(directory, "node_modules", name, "package.json"),
+          "utf8"
+        )
+      ).version,
+    ])
+  );
+}
+
+/** Re-read the committed source; an unstaged manifest cannot become the baseline. */
+export async function baseline(cwd, env, proposal) {
+  const command = args =>
+    runProcess("git", args, { cwd, env, maximum: 1_048_576 });
+  const parent = (await command(["rev-parse", "HEAD"])).stdout
+    .toString()
+    .trim();
+  const files = {};
+  for (const file of FILES) {
+    const entry = (
+      await command(["ls-tree", "HEAD", "--", file])
+    ).stdout.toString();
+    required(
+      entry.startsWith("100644 blob ") && entry.trim().split("\n").length === 1,
+      "regular committed npm files required"
+    );
+    files[file] = (await command(["show", `HEAD:${file}`])).stdout.toString(
+      "utf8"
+    );
+  }
+  if (proposal)
+    required(
+      parent === proposal.parent &&
+        canonicalJson(JSON.parse(files["package.json"])) ===
+          canonicalJson(proposal.before),
+      "committed proposal baseline differs"
+    );
+  return { parent, files };
+}
+
+/** Installed evidence and genuine selected registry metadata define the update set. */
+async function findUpdates(
+  before,
+  policy,
+  installedBefore,
+  detected,
+  outdated,
+  npm
+) {
+  const updates = [];
+  for (const selection of policy.packages) {
+    const sections = SECTIONS.filter(
+      section => before[section]?.[selection.name]
+    );
+    required(
+      sections.length === 1,
+      "selected package must be one unambiguous direct dependency"
+    );
+    if (installedBefore[selection.name] === selection.version) continue;
+    required(
+      outdated.code === 1 &&
+        detected[selection.name]?.current === installedBefore[selection.name],
+      "outdated did not reach installed selected package"
+    );
+    const metadata = await npm([
+      "view",
+      `${selection.name}@${selection.version}`,
+      "--json",
+    ]);
+    const registry = JSON.parse(metadata.stdout.toString());
+    required(
+      registry.name === selection.name &&
+        registry.version === selection.version &&
+        registry.dist?.integrity,
+      "selected registry metadata differs"
+    );
+    updates.push({
+      name: selection.name,
+      section: sections[0],
+      from: before[sections[0]][selection.name],
+      to: selection.version,
+    });
+  }
+  return updates;
+}
+
+/** npm writes only the explicitly selected ordinary dependency sections. */
+async function installUpdates(updates, npm, npmFlags) {
+  for (const update of updates) {
+    const sectionFlag = {
+      dependencies: "--save-prod",
+      devDependencies: "--save-dev",
+      optionalDependencies: "--save-optional",
+    }[update.section];
+    await npm([
+      "install",
+      `${update.name}@${update.to}`,
+      "--save-exact",
+      "--package-lock-only",
+      sectionFlag,
+      ...npmFlags,
+    ]);
+  }
+}
+
+/** Build only a two-file proposal in a private HOME, never executing repository scripts. */
+async function preparedProposal({
+  app,
+  npm,
+  policy,
+  original,
+  before,
+  updates,
+  npmFlags,
+  version,
+  outdated,
+  installedBefore,
+}) {
+  await installUpdates(updates, npm, npmFlags);
+  const files = Object.fromEntries(
+    FILES.map(file => [file, readFileSync(join(app, file), "utf8")])
+  );
+  const proposal = proposalFrom(
+    policy,
+    original.parent,
+    before,
+    files,
+    updates
+  );
+  const hashes = Object.fromEntries(
+    FILES.map(file => [file, sha256(readFileSync(join(app, file)))])
+  );
+  await npm(["ci", ...npmFlags]);
+  required(
+    FILES.every(file => hashes[file] === sha256(readFileSync(join(app, file)))),
+    "npm ci rewrote manifest or lock"
+  );
+  required(
+    readdirSync(app).sort().join("\n") ===
+      ["node_modules", ...FILES].sort().join("\n"),
+    "unexpected npm output path or lifecycle effect"
+  );
+  return {
+    status: "prepared",
+    proposal,
+    npm: {
+      version,
+      outdatedExit: outdated.code,
+      installedBefore,
+      installedAfter: installedVersions(app, policy.packages),
+      ciPreserved: true,
+    },
+  };
+}
+
+/** The private resource lifecycle remains outside the prepared proposal's npm checks. */
+export async function prepareUpdate({ cwd, policy: input, config }) {
+  const engineStrict = await effectiveEngineStrict(cwd);
+  const npmFlags = [...NPM_FLAGS, ...(engineStrict ? ["--engine-strict"] : [])];
+  const policy = validatePolicy(input, config);
+  let privatePath;
+  const result = await withPrivateRoot(async (root, env) => {
+    privatePath = root;
+    const app = join(root, "app");
+    mkdirSync(app, { mode: 0o700 });
+    required(process.versions.node === "22.23.3", "Node22.23.3 is required");
+    const version = (await runNpm(["--version"], { env })).stdout
+      .toString()
+      .trim();
+    required(
+      ["10.9.9", "11.21.0"].includes(version),
+      "supported npm10.9.9 or11.21.0 is required"
+    );
+    const original = await baseline(cwd, env);
+    const before = JSON.parse(original.files["package.json"]);
+    validateHost(before);
+    required(
+      !before.workspaces &&
+        (!before.packageManager || before.packageManager === `npm@${version}`),
+      "unsupported workspace or npm declaration"
+    );
+    await qualifyLisaOwner(cwd, before, policy, config, engineStrict);
+    validateLock(JSON.parse(original.files["package-lock.json"]), before, []);
+    for (const file of FILES)
+      writeFileSync(join(app, file), original.files[file], { mode: 0o600 });
+    const npm = (args, allowed = [0]) =>
+      runNpm(args, { cwd: app, env, timeout: 120_000, allowed });
+    await npm(["ci", ...npmFlags]);
+    const installedBefore = installedVersions(app, policy.packages);
+    const outdated = await npm(["outdated", "--json", "--long"], [0, 1]);
+    const detected = JSON.parse(outdated.stdout.toString() || "{}");
+    const updates = await findUpdates(
+      before,
+      policy,
+      installedBefore,
+      detected,
+      outdated,
+      npm
+    );
+    if (updates.length === 0)
+      return {
+        status: "no-selected-update",
+        npm: { version, outdatedExit: outdated.code, installedBefore },
+      };
+    return preparedProposal({
+      app,
+      npm,
+      policy,
+      original,
+      before,
+      updates,
+      npmFlags,
+      version,
+      outdated,
+      installedBefore,
+    });
+  });
+  required(!existsSync(privatePath), "private npm resources remain");
+  return { ...result, cleanup: { absent: true } };
+}

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

@@ -0,0 +1,179 @@
+// 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-process-core.mjs
+ * @description Private bounded process and file boundaries keep credentials out of candidates.
+ * @module npm-updater
+ */
+import {
+  constants,
+  openSync,
+  closeSync,
+  fstatSync,
+  ftruncateSync,
+  readSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  lstatSync,
+  existsSync,
+  realpathSync,
+  readdirSync,
+} from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { randomBytes } from "node:crypto";
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { required } from "./npm-update-contract.mjs";
+
+/** A fresh HOME and allowlist remove ambient Git/npm/issuer/write authority. */
+export function candidateEnvironment(home, source = process.env) {
+  return {
+    PATH: source.PATH ?? "/usr/bin:/bin",
+    HOME: home,
+    LANG: "C.UTF-8",
+    LC_ALL: "C.UTF-8",
+    TZ: "UTC",
+    TMPDIR: join(home, "tmp"),
+    NPM_CONFIG_USERCONFIG: join(home, "npmrc"),
+    NPM_CONFIG_GLOBALCONFIG: join(home, "global-npmrc"),
+    NPM_CONFIG_CACHE: join(home, "npm-cache"),
+    NPM_CONFIG_REGISTRY: "https://registry.npmjs.org/",
+    NPM_CONFIG_AUDIT: "false",
+    NPM_CONFIG_FUND: "false",
+    NPM_CONFIG_UPDATE_NOTIFIER: "false",
+    GIT_TERMINAL_PROMPT: "0",
+  };
+}
+
+/**
+ * Single owned root includes every cache and temp path; cleanup is a checked result.
+ * @template T
+ * @param {(root: string, env: NodeJS.ProcessEnv) => T | Promise<T>} operation Owned work.
+ * @returns {Promise<T>} The operation result after checked cleanup.
+ */
+export async function withPrivateRoot(operation) {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "lisa-npm-update-")));
+  const nonce = randomBytes(24).toString("hex");
+  writeFileSync(join(root, "owner"), nonce, { mode: 0o600 });
+  mkdirSync(join(root, "tmp"), { mode: 0o700 });
+  try {
+    return await operation(root, candidateEnvironment(root));
+  } finally {
+    required(
+      lstatSync(root).isDirectory() &&
+        !lstatSync(root).isSymbolicLink() &&
+        readFileSync(join(root, "owner"), "utf8") === nonce,
+      "cleanup ownership changed"
+    );
+    required(
+      !readdirSync(root).some(name =>
+        /^namespace-[a-f0-9]{16}\.json$/.test(name)
+      ),
+      "owned namespace registration cleanup outstanding"
+    );
+    rmSync(root, { recursive: true });
+    required(!existsSync(root), "owned root cleanup failed");
+  }
+}
+
+/** Read through a no-follow descriptor so aliases and growth cannot bypass bounds. */
+export function readBytes(file, maximum = 3_145_728, privateFile = true) {
+  required(
+    Number.isSafeInteger(maximum) && maximum > 0 && maximum <= 4_194_304,
+    "invalid file bound"
+  );
+  const fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const st = fstatSync(fd);
+    required(
+      st.isFile() &&
+        st.size <= maximum &&
+        (!privateFile ||
+          ((st.mode & 0o077) === 0 &&
+            st.nlink === 1 &&
+            st.uid === process.getuid())),
+      "invalid bounded private file"
+    );
+    const bytes = Buffer.alloc(maximum + 1);
+    let length = 0;
+    let count;
+    do {
+      count = readSync(fd, bytes, length, bytes.length - length, null);
+      length += count;
+      required(length <= maximum, "file grew beyond bound");
+    } while (count > 0);
+    return bytes.subarray(0, length);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+/** Canonical serialization rejects duplicate keys instead of discarding ambiguity. */
+export function readJson(file, maximum) {
+  const bytes = readBytes(file, maximum);
+  const text = new TextDecoder("utf8", { fatal: true, ignoreBOM: true }).decode(
+    bytes
+  );
+  const value = JSON.parse(text);
+  required(
+    text === `${canonicalJson(value)}\n`,
+    "JSON must be canonical without duplicate fields"
+  );
+  return value;
+}
+
+/** Fresh outputs never follow symlinks or overwrite recovery evidence. */
+export function writeJson(file, value) {
+  const absolute = resolve(file);
+  writeFileSync(absolute, `${canonicalJson(value)}\n`, {
+    mode: 0o600,
+    flag: "wx",
+  });
+  return absolute;
+}
+
+/** Replace only an already private, singly linked owned phase file. */
+export function replaceJson(file, value) {
+  const bytes = Buffer.from(`${canonicalJson(value)}\n`);
+  required(bytes.length <= 3_145_728, "replacement phase data exceeds bound");
+  const fd = openSync(file, constants.O_WRONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = fstatSync(fd);
+    required(
+      stat.isFile() &&
+        stat.nlink === 1 &&
+        stat.uid === process.getuid() &&
+        (stat.mode & 0o077) === 0,
+      "phase replacement is not owned private data"
+    );
+    ftruncateSync(fd, 0);
+    writeFileSync(fd, bytes);
+  } finally {
+    closeSync(fd);
+  }
+  required(readBytes(file).equals(bytes), "phase replacement readback differs");
+}
+
+/** A fixed phase directory must be private and genuinely owned before any writes. */
+export function phaseDirectory(directory) {
+  const parent = lstatSync(dirname(directory));
+  required(
+    parent.isDirectory() && !parent.isSymbolicLink(),
+    "phase parent is aliased"
+  );
+  if (!existsSync(directory)) mkdirSync(directory, { mode: 0o700 });
+  const stat = lstatSync(directory);
+  required(
+    stat.isDirectory() &&
+      !stat.isSymbolicLink() &&
+      stat.uid === process.getuid() &&
+      (stat.mode & 0o077) === 0,
+    "phase directory is not owned private storage"
+  );
+}
+
+export { runProcess } from "./npm-update-native-process.mjs";

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

@@ -0,0 +1,16 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Compatibility exports retain bounded IO and native npm/owner APIs through one-way implementation dependencies. */
+export {
+  candidateEnvironment,
+  withPrivateRoot,
+  readBytes,
+  readJson,
+  writeJson,
+  replaceJson,
+  phaseDirectory,
+  runProcess,
+} from "./npm-update-process-core.mjs";
+export { runNpm, effectiveEngineStrict } from "./npm-update-npm.mjs";
+export { releasedLisaIdentity } from "./npm-update-owner.mjs";