@codyswann/lisa 4.70.4 → 4.71.0

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

@@ -0,0 +1,278 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Parent-authenticated canonical helpers receive immutable phase scopes; their token stays in broker memory. */
+import { mkdirSync, realpathSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { required, OBJECT } from "./npm-update-contract.mjs";
+import { leafRoles } from "./npm-update-leaf-contract.mjs";
+import { qualifiedControllerGraph } from "./npm-update-helper.mjs";
+import { withPrivateRoot, writeJson } from "./npm-update-process.mjs";
+import { assertPinnedVerifier } from "./github-attestation-verifier.mjs";
+import { binaryDigest } from "./npm-update-isolation.mjs";
+import { createGhRequests } from "./npm-update-gh-requests.mjs";
+import { startControllerBroker } from "./npm-update-controller-broker.mjs";
+import { invokeControllerRecipe } from "./npm-update-broker-client.mjs";
+import { boundedSpawnSync } from "./bounded-spawn.mjs";
+
+/** One original phase expiry caps every helper; a later invocation cannot renew its budget. */
+export function controllerDeadline(context, now = Date.now()) {
+  required(
+    Number.isSafeInteger(context.deadline) &&
+      context.deadline > now &&
+      context.deadline <= now + 1_800_000,
+    "original controller phase deadline is absent or expired"
+  );
+  return Math.min(context.deadline, now + 120_000);
+}
+
+/** Existing canonical validators still authorize the allocation; this projection narrows helper authority. */
+export function controllerSubject(context, phase, pr, proofs = []) {
+  const { config, policy, proposal, allocation } = context;
+  const descriptor = context.descriptor ?? context.preview?.descriptor;
+  leafRoles(config, policy.repository);
+  required(
+    proposal.repository === policy.repository &&
+      Number.isSafeInteger(allocation.number) &&
+      allocation.number > 0 &&
+      allocation.workItem === `${policy.repository}#${allocation.number}` &&
+      descriptor?.parent === proposal.parent &&
+      descriptor.workItem === allocation.workItem &&
+      descriptor.claimCommentId === allocation.claimCommentId,
+    "controller allocation or descriptor differs"
+  );
+  required(
+    pr === null ||
+      (Number.isSafeInteger(pr?.number) &&
+        pr.number > 0 &&
+        pr.html_url ===
+          `https://github.com/${policy.repository}/pull/${pr.number}`),
+    "controller actual PR differs"
+  );
+  const recovery = context.recoveryDescriptor;
+  const subject = {
+    phase,
+    repository: policy.repository,
+    tracker: policy.repository,
+    issue: String(allocation.number),
+    branch: `lisa/npm-${proposal.key}`,
+    parent: proposal.parent,
+    origin: { runId: descriptor.runId, runAttempt: descriptor.runAttempt },
+    claim: allocation.claimCommentId,
+    recovery: recovery
+      ? {
+          runId: recovery.runId,
+          runAttempt: recovery.runAttempt,
+          branch: `lisa/npm-${proposal.key}`,
+        }
+      : null,
+    maintainer: policy.maintainer,
+    pr: pr === null ? null : { number: String(pr.number), url: pr.html_url },
+    proofs,
+  };
+  createGhRequests(subject);
+  return subject;
+}
+
+/** Only exact current stage/writer tuples are constructed; arbitrary helper operations cannot enter this factory. */
+export function canonicalHelperArguments(context, phase, operation, pr) {
+  controllerSubject(context, phase, pr);
+  if (phase === "stage-read") {
+    required(pr === null, "stage phase cannot carry publication authority");
+    if (operation === "link") return ["link", context.allocation.workItem];
+    if (operation === "attach-branch") return ["attach-branch"];
+  }
+  if (phase === "publication-backlink" && operation === "backlink" && pr)
+    return [
+      "backlink",
+      "--ref",
+      context.allocation.workItem,
+      "--pr-url",
+      pr.html_url,
+    ];
+  if (
+    phase === "publication-validate-pr" &&
+    operation === "validate-pr" &&
+    pr
+  ) {
+    required(
+      OBJECT.test(context.commit?.sha ?? ""),
+      "controller publication head is missing"
+    );
+    return [
+      "validate-pr",
+      "--base",
+      context.proposal.parent,
+      "--head",
+      context.commit.sha,
+      "--pr-number",
+      String(pr.number),
+      "--repo",
+      context.policy.repository,
+      "--pr-url",
+      pr.html_url,
+    ];
+  }
+  throw Error("unsupported canonical helper phase/operation");
+}
+
+/** Trusted released factory resolves actual tools outside candidate influence and rechecks them before dispatch. */
+export function controllerTools(automation) {
+  assertPinnedVerifier(automation);
+  required(
+    process.version === "v22.23.3",
+    "unsupported native controller Node bootstrap"
+  );
+  const path = realpathSync(process.execPath);
+  const git = realpathSync(
+    [
+      "/Library/Developer/CommandLineTools/usr/bin/git",
+      "/Applications/Xcode.app/Contents/Developer/usr/bin/git",
+      "/usr/bin/git",
+    ].find(existsSync)
+  );
+  const result = boundedSpawnSync(git, ["--version"], {
+    encoding: "utf8",
+    timeout: 5000,
+    maxBuffer: 4096,
+    env: { PATH: "/usr/bin:/bin", HOME: "/nonexistent" },
+  });
+  required(
+    !result.error &&
+      !result.signal &&
+      result.status === 0 &&
+      /^git version [\w. -]+\n$/.test(result.stdout),
+    "native controller Git identity is unavailable"
+  );
+  return {
+    node: { path, version: "22.23.3", sha256: binaryDigest(path) },
+    git: {
+      path: git,
+      version: result.stdout.trim(),
+      sha256: binaryDigest(git),
+    },
+    gh: { path: automation.ghExecutable, sha256: automation.ghSha256 },
+  };
+}
+
+/** Construct private JSON separately from the memory-only credentialed recipe. */
+function canonicalRecipe(context, authority) {
+  const {
+    root,
+    cwd,
+    graph,
+    native,
+    entry,
+    argv,
+    phase,
+    operation,
+    pr,
+    deadline,
+  } = authority;
+  mkdirSync(join(root, "gh-config"), { mode: 0o700 });
+  const launcher = {
+    version: 3,
+    root,
+    cwd,
+    graph,
+    routes: [],
+    controller: { node: native.node, git: native.git },
+    runtime: { tools: { node: native.node } },
+    boundary: null,
+    provider: {
+      version: 1,
+      deadline,
+      cwd,
+      home: root,
+      nativeGh: native.gh,
+      invocation: { entry, args: argv, cwd },
+      subject: controllerSubject(context, phase, pr),
+    },
+  };
+  writeJson(join(root, "launcher.json"), launcher);
+  return {
+    id: operation,
+    command: native.node.path,
+    args: argv,
+    cwd,
+    input: Buffer.alloc(0),
+    allowed: [0],
+    timeout: 120_000,
+    maximum: 3_145_728,
+    context: launcher,
+    env: {
+      PATH: `${dirname(native.node.path)}:${dirname(native.gh.path)}:/usr/bin:/bin`,
+      HOME: root,
+      LANG: "C.UTF-8",
+      GH_TOKEN: context.token,
+      GH_HOST: "github.com",
+      GITHUB_REPOSITORY: context.policy.repository,
+      GIT_TERMINAL_PROMPT: "0",
+    },
+  };
+}
+
+/** Every invocation has fresh private scope/credential-free JSON; no mutable privilege growth across phases. */
+export async function executeCanonicalHelper(
+  context,
+  phase,
+  operation,
+  pr = null,
+  suppliedArgs
+) {
+  controllerDeadline(context);
+  const args = canonicalHelperArguments(context, phase, operation, pr);
+  required(
+    suppliedArgs === undefined ||
+      canonicalJson(args) === canonicalJson(suppliedArgs),
+    "canonical helper invocation differs from controller recipe"
+  );
+  const cwd = realpathSync(context.cwd);
+  const graph = await qualifiedControllerGraph(cwd, context.config, [
+    "lisa-work-item.mjs",
+    "lib/npm-update-execution-adapter.mjs",
+  ]);
+  const entry = join(cwd, "scripts/lisa-work-item.mjs");
+  required(
+    Object.hasOwn(graph, entry),
+    "authenticated canonical helper entry is absent"
+  );
+  const native = controllerTools(context.config.automationProvenance);
+  const argv = [entry, ...args];
+  return withPrivateRoot(async root => {
+    const deadline = controllerDeadline(context);
+    const recipe = canonicalRecipe(context, {
+      root,
+      cwd,
+      graph,
+      native,
+      entry,
+      argv,
+      phase,
+      operation,
+      pr,
+      deadline,
+    });
+    const broker = await startControllerBroker({
+      root,
+      node: native.node,
+      graph,
+      deadline,
+      recipes: [recipe],
+    });
+    try {
+      const result = await invokeControllerRecipe(
+        { root, path: broker.path, deadline },
+        operation
+      );
+      required(
+        result.code === 0,
+        `canonical ${operation} helper refused with native exit ${result.code}`
+      );
+      return result;
+    } finally {
+      await broker.close();
+    }
+  });
+}

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

@@ -0,0 +1,135 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Immutable recipes retain native status/capture while scoped helpers receive their authenticated bootstrap. */
+import { realpathSync } from "node:fs";
+import { join } from "node:path";
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { required, keys } from "./npm-update-contract.mjs";
+import { runProcess } from "./npm-update-process.mjs";
+import { binaryDigest } from "./npm-update-isolation.mjs";
+import {
+  literalArguments,
+  launcherContext,
+  dispatchTool,
+} from "./npm-update-tool-launcher.mjs";
+
+/** The context is controller-created private data; every helper/graph/native tuple is rechecked at dispatch. */
+export function checkedRecipe(recipe, node, graph) {
+  keys(recipe, [
+    "id",
+    "command",
+    "args",
+    "cwd",
+    "input",
+    "env",
+    "allowed",
+    "timeout",
+    "maximum",
+    ...(recipe.context !== undefined ? ["context"] : []),
+  ]);
+  literalArguments(recipe.args);
+  required(
+    /^[a-zA-Z0-9-]{1,128}$/.test(recipe.id) &&
+      recipe.command === node.path &&
+      Object.hasOwn(graph, recipe.args[0]) &&
+      recipe.cwd === realpathSync(recipe.cwd),
+    "unqualified or duplicate broker recipe"
+  );
+  required(
+    Buffer.isBuffer(recipe.input) &&
+      recipe.input.length <= 4_194_304 &&
+      Number.isSafeInteger(recipe.timeout) &&
+      recipe.timeout > 0 &&
+      recipe.timeout <= 1_800_000 &&
+      Number.isSafeInteger(recipe.maximum) &&
+      recipe.maximum > 0 &&
+      recipe.maximum <= 8_388_608,
+    "broker recipe input or capture bound differs"
+  );
+  required(
+    recipe.env &&
+      !recipe.env.NODE_OPTIONS &&
+      !recipe.env.NODE_PATH &&
+      Array.isArray(recipe.allowed) &&
+      recipe.allowed.length > 0 &&
+      recipe.allowed.length <= 256 &&
+      recipe.allowed.every(
+        code => Number.isInteger(code) && code >= 0 && code <= 255
+      ),
+    "broker recipe environment or status policy differs"
+  );
+  if (recipe.context !== undefined) {
+    const actual = launcherContext(join(recipe.context.root, "launcher.json"));
+    required(
+      actual.version === 3 &&
+        actual.provider !== null &&
+        canonicalJson(actual) === canonicalJson(recipe.context) &&
+        canonicalJson(actual.graph) === canonicalJson(graph) &&
+        actual.controller.node.path === node.path &&
+        actual.controller.node.sha256 === node.sha256 &&
+        actual.provider.invocation.entry === recipe.args[0] &&
+        canonicalJson(actual.provider.invocation.args) ===
+          canonicalJson(recipe.args) &&
+        actual.provider.invocation.cwd === recipe.cwd,
+      "broker scoped helper context differs"
+    );
+  }
+  return {
+    ...recipe,
+    args: [...recipe.args],
+    input: Buffer.from(recipe.input),
+    env: { ...recipe.env },
+    allowed: [...recipe.allowed],
+    ...(recipe.context !== undefined
+      ? { context: JSON.parse(JSON.stringify(recipe.context)) }
+      : {}),
+  };
+}
+
+/** Completed nonzero children keep native status/output; cancellation never becomes success. */
+export async function executeRecipe(recipe, deadline, signal, node) {
+  const timeout = Math.min(recipe.timeout, deadline - Date.now());
+  required(timeout > 0 && !signal.aborted, "broker phase expired");
+  required(
+    binaryDigest(node.path) === node.sha256,
+    "broker native controller changed before dispatch"
+  );
+  const contract = {
+    timeout,
+    allowed: recipe.allowed,
+    maximum: recipe.maximum,
+  };
+  try {
+    if (recipe.context !== undefined)
+      return await dispatchTool(
+        recipe.context,
+        "node",
+        recipe.args,
+        recipe.input,
+        recipe.env,
+        recipe.cwd,
+        { ...contract, signal }
+      );
+    return await runProcess(recipe.command, recipe.args, {
+      cwd: recipe.cwd,
+      env: recipe.env,
+      input: recipe.input,
+      ...contract,
+      signal,
+    });
+  } catch (error) {
+    required(
+      error.nativeCompleted === true &&
+        Number.isInteger(error.code) &&
+        error.code >= 0 &&
+        error.code <= 255 &&
+        Buffer.isBuffer(error.stdout) &&
+        Buffer.isBuffer(error.stderr) &&
+        error.stdout.length + error.stderr.length <= recipe.maximum &&
+        !signal.aborted,
+      "broker child did not complete normally"
+    );
+    return { code: error.code, stdout: error.stdout, stderr: error.stderr };
+  }
+}

package/all/copy-overwrite/scripts/lib/npm-update-execution-adapter.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.
+
+/** Trusted canonical Node code forwards nested real tools before application code loads. */
+import childProcess from "node:child_process";
+import { syncBuiltinESMExports } from "node:module";
+import { resolve, basename } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { realpathSync } from "node:fs";
+import {
+  launcherContext,
+  literalArguments,
+} from "./npm-update-tool-launcher.mjs";
+import {
+  currentGraph,
+  controllerRoute,
+  controllerGraph,
+} from "./npm-update-orchestrator.mjs";
+import { binaryDigest } from "./npm-update-isolation.mjs";
+import { required } from "./npm-update-contract.mjs";
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { createGhDispatcher } from "./npm-update-gh-dispatch.mjs";
+
+const ENTRY = fileURLToPath(import.meta.url);
+const LAUNCHER = fileURLToPath(
+  new URL("./npm-update-tool-launcher.mjs", import.meta.url)
+);
+const ORIGINAL = Object.fromEntries(
+  ["spawn", "spawnSync", "execFile", "execFileSync"].map(name => [
+    name,
+    childProcess[name],
+  ])
+);
+const SPELLINGS = {
+  node: "node",
+  npm: "npm",
+  bun: "bun",
+  ruby: "ruby",
+  bundle: "bundle",
+  sh: "shell",
+  bash: "bash",
+  gh: "gh",
+  gitleaks: "gitleaks",
+};
+
+/** Matching filenames never qualify an arbitrary absolute native executable. */
+function commandTool(context, command) {
+  required(
+    typeof command === "string" &&
+      command.length <= 4096 &&
+      !/[\n\0]/.test(command),
+    "invalid nested native command"
+  );
+  const name = basename(command);
+  if (command === process.execPath || command === context.controller.node.path)
+    return "node";
+  if (command === "git" || command === context.controller.git?.path)
+    return "git";
+  const tool = SPELLINGS[name];
+  required(
+    tool &&
+      (!command.includes("/") ||
+        command === context.runtime.tools[tool]?.path ||
+        command === context.controller[tool]?.path ||
+        (["/bin/sh", "/usr/bin/sh"].includes(command) && tool === "shell") ||
+        (["/bin/bash", "/usr/bin/bash"].includes(command) && tool === "bash")),
+    "unqualified nested native command route"
+  );
+  return tool;
+}
+
+/** Private instrumentation may be inherited only by authenticated canonical Node children. */
+function childEnvironment(options, contextFile, canonical) {
+  const env = { ...(options.env ?? process.env) };
+  required(
+    !env.NODE_OPTIONS && !env.NODE_PATH,
+    "unqualified nested Node environment loader"
+  );
+  delete env.LISA_NPM_DISPATCH_CONTEXT;
+  delete env.GH_TOKEN;
+  delete env.GITHUB_TOKEN;
+  if (canonical) env.LISA_NPM_DISPATCH_CONTEXT = contextFile;
+  return env;
+}
+
+/** The proxy itself is genuine qualified Node; its exit is the real dispatched command exit. */
+function nestedInvocation(context, contextFile, command, args, options) {
+  literalArguments(args);
+  required(
+    options.shell !== true && typeof options.shell !== "string",
+    "unqualified nested shell option; use the literal shell tool"
+  );
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const tool = commandTool(context, command);
+  const node = context.controller.node;
+  required(
+    binaryDigest(node.path) === node.sha256 && node.version === "22.23.3",
+    "controller Node identity changed"
+  );
+  if (tool === "git") {
+    const git = context.controller.git;
+    required(
+      git &&
+        realpathSync(git.path) === git.path &&
+        binaryDigest(git.path) === git.sha256,
+      "controller Git identity is unqualified"
+    );
+    return {
+      command: git.path,
+      args,
+      options: {
+        ...options,
+        cwd,
+        env: childEnvironment(options, contextFile, false),
+      },
+    };
+  }
+  const canonical =
+    controllerRoute(
+      tool,
+      args,
+      context.graph,
+      currentGraph(controllerGraph(context.graph, context.routes)),
+      cwd,
+      context.routes,
+      options.env ?? process.env
+    ) === "controller";
+  if (canonical && tool === "node") {
+    const instrumentedArgs = ["--import", pathToFileURL(ENTRY).href, ...args];
+    literalArguments(instrumentedArgs);
+    return {
+      command: node.path,
+      args: instrumentedArgs,
+      options: {
+        ...options,
+        cwd,
+        env: childEnvironment(options, contextFile, true),
+      },
+    };
+  }
+  const proxyArgs = [
+    LAUNCHER,
+    "--context",
+    contextFile,
+    "--tool",
+    tool,
+    "--",
+    ...args,
+  ];
+  literalArguments(proxyArgs);
+  return {
+    command: node.path,
+    args: proxyArgs,
+    options: {
+      ...options,
+      cwd,
+      env: childEnvironment(options, contextFile, false),
+    },
+  };
+}
+
+/** Normalize only Node's documented argument overloads, retaining buffers, FDs and callbacks. */
+function invocationArguments(args, options) {
+  if (!Array.isArray(args)) return { args: [], options: args ?? {} };
+  return { args, options: options ?? {} };
+}
+
+/** This instruments exclusively trusted code; it is not a sandbox for arbitrary same-process JS. */
+export function initializeAdapter(contextFile) {
+  const context = launcherContext(contextFile);
+  const provider = scopedProvider(context);
+  for (const method of ["spawn", "spawnSync", "execFileSync"])
+    childProcess[method] = (command, args, options) => {
+      const normalized = invocationArguments(args, options);
+      if (
+        provider &&
+        (command === "gh" || command === context.provider.nativeGh.path)
+      )
+        return provider(
+          method,
+          command,
+          normalized.args,
+          normalized.options,
+          ORIGINAL.spawnSync
+        );
+      const selected = nestedInvocation(
+        context,
+        contextFile,
+        command,
+        normalized.args,
+        normalized.options
+      );
+      return ORIGINAL[method](
+        selected.command,
+        selected.args,
+        selected.options
+      );
+    };
+  childProcess.execFile = (
+    command,
+    suppliedArgs,
+    suppliedOptions,
+    suppliedCallback
+  ) => {
+    let args = suppliedArgs;
+    let options = suppliedOptions;
+    let callback = suppliedCallback;
+    if (typeof args === "function") {
+      callback = args;
+      args = [];
+      options = {};
+    } else if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    const normalized = invocationArguments(args, options);
+    required(
+      !provider ||
+        (command !== "gh" && command !== context.provider.nativeGh.path),
+      "credentialed GH requires synchronous canonical dispatch"
+    );
+    const selected = nestedInvocation(
+      context,
+      contextFile,
+      command,
+      normalized.args,
+      normalized.options
+    );
+    return ORIGINAL.execFile(
+      selected.command,
+      selected.args,
+      selected.options,
+      callback
+    );
+  };
+  syncBuiltinESMExports();
+}
+
+/** Graph membership and immutable argv/cwd qualify this genuine parent-owned canonical caller. */
+function scopedProvider(context) {
+  if (!context.provider) return null;
+  const profile = context.provider;
+  const preload = ["--import", pathToFileURL(ENTRY).href];
+  required(
+    canonicalJson(process.execArgv.slice(0, 2)) === canonicalJson(preload),
+    "GH caller lacks qualified instrumentation"
+  );
+  const actual = [...process.execArgv.slice(2), ...process.argv.slice(1)];
+  required(
+    canonicalJson(actual) === canonicalJson(profile.invocation.args) &&
+      realpathSync(process.cwd()) === profile.invocation.cwd &&
+      Object.hasOwn(context.graph, profile.invocation.entry),
+    "GH caller tuple differs"
+  );
+  required(
+    actual[0] === profile.invocation.entry ||
+      context.routes?.some(
+        route =>
+          route.tool === "node" &&
+          route.entry === profile.invocation.entry &&
+          canonicalJson(route.args) === canonicalJson(actual) &&
+          route.cwd === profile.cwd
+      ),
+    "GH caller entry differs"
+  );
+  const route = controllerRoute(
+    "node",
+    actual,
+    context.graph,
+    currentGraph(controllerGraph(context.graph, context.routes)),
+    profile.cwd,
+    context.routes,
+    process.env
+  );
+  required(
+    route === "controller" &&
+      realpathSync(process.execPath) === context.controller.node.path &&
+      binaryDigest(process.execPath) === context.controller.node.sha256,
+    "GH caller graph or interpreter differs"
+  );
+  return createGhDispatcher(profile, process.env.GH_TOKEN);
+}
+
+if (
+  process.env.LISA_NPM_DISPATCH_CONTEXT &&
+  process.execArgv.some(
+    (value, index, values) =>
+      value === `--import=${pathToFileURL(ENTRY).href}` ||
+      (value === "--import" && values[index + 1] === pathToFileURL(ENTRY).href)
+  )
+)
+  initializeAdapter(process.env.LISA_NPM_DISPATCH_CONTEXT);