@codyswann/lisa 4.70.4 → 4.71.0

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

@@ -0,0 +1,207 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** A disposable CI gate exposes only a fixed read capability; publisher credentials never enter this job. */
+import { createServer, createConnection } from "node:net";
+import { chmodSync, lstatSync, realpathSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { required, keys } from "./npm-update-contract.mjs";
+import { createGhDispatcher } from "./npm-update-gh-dispatch.mjs";
+
+export const HOOK_READ_SLOTS = [
+  "commit-prepare",
+  "commit-work-item",
+  "commit-provenance",
+  "audit-work-item",
+  "audit-provenance",
+  "destination-work-item",
+  "destination-provenance",
+];
+
+/** Slots separate actual hook reads; they are bounded state labels, not claimed caller authentication. */
+function readScopes(profile, token) {
+  required(
+    profile.subject.phase === "hook-read",
+    "hook broker cannot carry writer authority"
+  );
+  return new Map(
+    HOOK_READ_SLOTS.map(slot => [slot, createGhDispatcher(profile, token)])
+  );
+}
+
+function nativeResponse(result) {
+  return {
+    status: result.status,
+    signal: result.signal,
+    stdout: Buffer.from(result.stdout ?? "").toString("base64"),
+    stderr: Buffer.from(result.stderr ?? "").toString("base64"),
+    error: result.error
+      ? { code: result.error.code ?? null, name: result.error.name }
+      : null,
+  };
+}
+
+/** Node normally unlinks its listener on close; an existing pathname still requires the original inode. */
+function removeOwnedSocket(path, identity) {
+  try {
+    const current = lstatSync(path);
+    required(
+      current.dev === identity.dev &&
+        current.ino === identity.ino &&
+        current.isSocket(),
+      "hook read cleanup ownership changed"
+    );
+    unlinkSync(path);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+
+/** No request can supply a native path, token, environment or new provider subject. */
+function dispatchRead(scopes, request, cwd) {
+  keys(request, ["slot", "args", "options"]);
+  const execute = scopes.get(request.slot);
+  required(execute, "unknown hook read slot");
+  keys(request.options, ["encoding", "timeout", "maxBuffer", "killSignal"]);
+  return nativeResponse(
+    execute(
+      "spawnSync",
+      "gh",
+      request.args,
+      { ...request.options, cwd, env: {} },
+      spawnSync
+    )
+  );
+}
+
+/** Each connection has a finite byte budget and consumes the shared phase request bound. */
+function readServer(profile, scopes) {
+  const connections = new Set();
+  const state = { count: 0, closing: false };
+  const server = createServer(socket => {
+    if (state.closing || connections.size >= 32) {
+      socket.destroy();
+      return;
+    }
+    connections.add(socket);
+    socket.on("error", () => {});
+    socket.once("close", () => connections.delete(socket));
+    const chunks = [];
+    let bytes = 0;
+    socket.on("data", chunk => {
+      bytes += chunk.length;
+      if (bytes > 262_144) socket.destroy();
+      else chunks.push(chunk);
+    });
+    socket.on("end", () => {
+      try {
+        required(
+          !state.closing &&
+            Date.now() < profile.deadline &&
+            ++state.count <= 1024,
+          "hook read phase exhausted"
+        );
+        const text = new TextDecoder("utf8", { fatal: true }).decode(
+          Buffer.concat(chunks)
+        );
+        const request = JSON.parse(text);
+        required(
+          text === `${JSON.stringify(request)}\n`,
+          "ambiguous hook read request"
+        );
+        socket.end(
+          `${JSON.stringify({ ok: true, result: dispatchRead(scopes, request, profile.cwd) })}\n`
+        );
+      } catch {
+        socket.end('{"ok":false}\n');
+      }
+    });
+  });
+  return { server, connections, state };
+}
+
+/** Private pathname ownership and finite requests bound transport; this is not same-user confidentiality. */
+export async function startHookReadBroker(profile, token) {
+  const scopes = readScopes(profile, token);
+  const path = join(profile.home, "hook-reader.sock");
+  required(
+    Buffer.byteLength(path) <= 103 &&
+      realpathSync(profile.home) === profile.home,
+    "hook read pathname is unsupported"
+  );
+  const { server, connections, state } = readServer(profile, scopes);
+  let identity;
+  try {
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(path, resolve);
+    });
+    identity = lstatSync(path);
+    chmodSync(path, 0o600);
+    required(
+      identity.isSocket() &&
+        identity.uid === process.getuid() &&
+        (lstatSync(path).mode & 0o777) === 0o600,
+      "hook read socket ownership differs"
+    );
+  } catch (error) {
+    await new Promise(resolve => server.close(resolve));
+    if (identity) removeOwnedSocket(path, identity);
+    throw error;
+  }
+  let completion;
+  const close = () =>
+    (completion ??= (async () => {
+      state.closing = true;
+      clearTimeout(timer);
+      for (const socket of connections) socket.destroy();
+      await new Promise(resolve => server.close(resolve));
+      removeOwnedSocket(path, identity);
+    })());
+  const timer = setTimeout(() => {
+    close().catch(() => {});
+  }, profile.deadline - Date.now());
+  timer.unref();
+  return { path, close };
+}
+
+/** Literal public request data crosses IPC; the parent supplies all credentialed execution authority. */
+export async function requestHookRead(context, request) {
+  const identity = lstatSync(context.path);
+  required(
+    identity.isSocket() &&
+      identity.uid === process.getuid() &&
+      (identity.mode & 0o077) === 0 &&
+      context.path === join(context.root, "hook-reader.sock") &&
+      context.deadline > Date.now(),
+    "hook read endpoint is unavailable"
+  );
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(context.path);
+    const chunks = [];
+    let bytes = 0;
+    const timer = setTimeout(
+      () => socket.destroy(new Error("hook read phase expired")),
+      context.deadline - Date.now()
+    );
+    socket.on("connect", () => socket.end(`${JSON.stringify(request)}\n`));
+    socket.on("data", chunk => {
+      bytes += chunk.length;
+      if (bytes > 11_185_000)
+        socket.destroy(new Error("hook read capture exceeded"));
+      else chunks.push(chunk);
+    });
+    socket.once("error", reject);
+    socket.once("close", () => clearTimeout(timer));
+    socket.once("end", () => {
+      try {
+        const response = JSON.parse(Buffer.concat(chunks).toString());
+        required(response.ok === true, "hook read request refused");
+        resolve(response.result);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}

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

@@ -0,0 +1,164 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Canonical synchronous callers receive the actual broker-owned native result, without a credential. */
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { invokedAsScript } from "./invoked-as-script.mjs";
+import { isProviderTransport } from "./npm-update-worker-environment.mjs";
+import { readJson } from "./npm-update-process.mjs";
+import { keys, required } from "./npm-update-contract.mjs";
+import { requestHookRead } from "./npm-update-hook-provider.mjs";
+
+const ENTRY = fileURLToPath(import.meta.url);
+const OPTIONS = new Set([
+  "cwd",
+  "encoding",
+  "env",
+  "input",
+  "timeout",
+  "maxBuffer",
+  "killSignal",
+]);
+
+/** Only public native bounds cross IPC; ambient environment, loaders and tokens never cross. */
+function requestOptions(options, context) {
+  required(
+    options &&
+      typeof options === "object" &&
+      !Array.isArray(options) &&
+      Object.keys(options).every(key => OPTIONS.has(key)),
+    "unsupported canonical hook GH option"
+  );
+  required(
+    options.encoding === "utf8" &&
+      options.input === undefined &&
+      (options.cwd === undefined || resolve(options.cwd) === context.cwd) &&
+      (options.killSignal === undefined || options.killSignal === "SIGKILL"),
+    "unsupported canonical hook GH options"
+  );
+  const env = options.env ?? process.env;
+  required(
+    env &&
+      typeof env === "object" &&
+      !Array.isArray(env) &&
+      Object.values(env).every(
+        value =>
+          value === undefined ||
+          (typeof value === "string" && !value.includes("\0"))
+      ) &&
+      !env.GH_TOKEN &&
+      !env.GITHUB_TOKEN &&
+      Object.entries(env).every(
+        ([key, value]) => !value || !isProviderTransport(key)
+      ) &&
+      (!env.GH_HOST || env.GH_HOST === "github.com") &&
+      (!env.GITHUB_API_URL ||
+        env.GITHUB_API_URL === "https://api.github.com") &&
+      (!env.GITHUB_SERVER_URL ||
+        env.GITHUB_SERVER_URL === "https://github.com"),
+    "hook caller contains provider credentials or transport overrides"
+  );
+  return {
+    encoding: "utf8",
+    timeout: options.timeout ?? 30_000,
+    maxBuffer: options.maxBuffer ?? 1_048_576,
+    killSignal: "SIGKILL",
+  };
+}
+
+/** Native error/status distinctions survive the internal successful IPC process. */
+export function hookNativeResult(value) {
+  keys(value, ["status", "signal", "stdout", "stderr", "error"]);
+  if (value.error !== null) keys(value.error, ["name", "code"]);
+  required(
+    (value.status === null ||
+      (Number.isInteger(value.status) &&
+        value.status >= 0 &&
+        value.status <= 255)) &&
+      (value.signal === null || /^SIG[A-Z0-9]+$/.test(value.signal)) &&
+      (value.error === null ||
+        (typeof value.error.name === "string" &&
+          value.error.name.length <= 64 &&
+          (value.error.code === null ||
+            /^E[A-Z0-9]+$/.test(value.error.code)))),
+    "invalid hook native status"
+  );
+  const bytes = [value.stdout, value.stderr].map(encoded => {
+    required(
+      typeof encoded === "string" && /^[A-Za-z0-9+/]*={0,2}$/.test(encoded),
+      "invalid hook native capture"
+    );
+    const decoded = Buffer.from(encoded, "base64");
+    required(
+      decoded.toString("base64") === encoded,
+      "ambiguous hook native capture"
+    );
+    return decoded;
+  });
+  required(
+    bytes[0].length + bytes[1].length <= 8_388_608,
+    "hook native capture exceeded"
+  );
+  return {
+    status: value.status,
+    signal: value.signal,
+    stdout: bytes[0].toString(),
+    stderr: bytes[1].toString(),
+    ...(value.error
+      ? {
+          error: Object.assign(
+            new Error("native hook provider did not complete"),
+            value.error
+          ),
+        }
+      : {}),
+  };
+}
+
+/** The selected source entry supplies saved native spawnSync; client subprocess cannot select GH authority. */
+export function synchronousHookRead(
+  context,
+  slot,
+  args,
+  options,
+  execute,
+  node
+) {
+  const native = requestOptions(options, context);
+  const timeout = Math.min(native.timeout, context.deadline - Date.now());
+  required(timeout > 0, "hook provider phase expired");
+  const result = execute(node, [ENTRY, context.file], {
+    cwd: context.cwd,
+    encoding: "utf8",
+    timeout,
+    maxBuffer: 11_185_000,
+    killSignal: "SIGKILL",
+    input: `${JSON.stringify({ slot, args, options: native })}\n`,
+    env: { PATH: "/usr/bin:/bin", HOME: context.root, LANG: "C.UTF-8" },
+  });
+  if (result.error || result.signal || result.status !== 0)
+    return { ...result, stdout: "", stderr: "" };
+  return hookNativeResult(JSON.parse(result.stdout));
+}
+
+async function main() {
+  required(process.argv.length === 3, "invalid hook read client arguments");
+  const context = readJson(process.argv[2], 1_048_576);
+  const chunks = [];
+  let length = 0;
+  for await (const chunk of process.stdin) {
+    length += chunk.length;
+    required(length <= 262_144, "hook request exceeded");
+    chunks.push(chunk);
+  }
+  const request = JSON.parse(Buffer.concat(chunks).toString());
+  const result = await requestHookRead(context.reader, request);
+  process.stdout.write(JSON.stringify(result));
+}
+
+if (invokedAsScript(import.meta.url))
+  main().catch(() => {
+    process.stderr.write("hook provider request refused\n");
+    process.exitCode = 1;
+  });

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

@@ -0,0 +1,272 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Supported disposable Actions Linux gates use original native tools; publisher authority stays in another job. */
+import {
+  existsSync,
+  lstatSync,
+  readFileSync,
+  mkdirSync,
+  writeFileSync,
+} from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { required } from "./npm-update-contract.mjs";
+import { runProcess, writeJson } from "./npm-update-process.mjs";
+import { qualifiedControllerGraph } from "./npm-update-helper.mjs";
+import {
+  controllerTools,
+  controllerSubject,
+} from "./npm-update-controller-factory.mjs";
+import { startHookReadBroker } from "./npm-update-hook-provider.mjs";
+import { originalHookInstallation } from "./npm-update-hook-installation.mjs";
+import {
+  sha256,
+  PROPOSAL_PREDICATE,
+  RECOVERY_PREDICATE,
+} from "./github-attestation-verifier.mjs";
+
+/** This diagnoses the supported caller; attestation/provider validation independently establishes actual authority. */
+export function assertHostedGate(
+  context,
+  env = process.env,
+  platform = process.platform,
+  arch = process.arch
+) {
+  required(
+    platform === "linux" &&
+      arch === "x64" &&
+      env.GITHUB_ACTIONS === "true" &&
+      env.RUNNER_ENVIRONMENT === "github-hosted" &&
+      env.GITHUB_REPOSITORY === context.policy.repository &&
+      env.GITHUB_SHA === context.proposal.parent &&
+      env.GITHUB_REF === "refs/heads/main" &&
+      context.config.automationProvenance.allowedTriggers.includes(
+        env.GITHUB_EVENT_NAME
+      ),
+    "gate requires the opted-in genuine hosted Linux AMD64 caller"
+  );
+}
+
+/** Every native step consumes the same original thirty-minute phase budget. */
+export function remainingGateTime(deadline, now = Date.now()) {
+  required(
+    Number.isSafeInteger(deadline) &&
+      deadline > now &&
+      deadline <= now + 1_800_000,
+    "original gate phase deadline is absent or expired"
+  );
+  return deadline - now;
+}
+
+function nativeStep(context, env, command, args, maximum = 3_145_728) {
+  return runProcess(command, args, {
+    cwd: context.cwd,
+    env,
+    timeout: remainingGateTime(context.deadline),
+    maximum,
+  });
+}
+
+/** Lifecycle execution is disabled; Bundler is an explicit original tool install in this credential-free job. */
+async function installHostedDependencies(context, root, env) {
+  const ruby = existsSync(join(context.cwd, "Gemfile"));
+  const installed = { ...env };
+  if (ruby) {
+    required(
+      existsSync(join(context.cwd, "Gemfile.lock")),
+      "frozen Ruby lock is missing"
+    );
+    installed.BUNDLE_PATH = join(root, "ruby-dependencies");
+    installed.BUNDLE_APP_CONFIG = join(root, "bundle");
+    installed.BUNDLE_FROZEN = "true";
+  }
+  const before = [
+    "package.json",
+    "package-lock.json",
+    ...(ruby ? ["Gemfile", "Gemfile.lock"] : []),
+  ].map(name => [name, readFileSync(join(context.cwd, name))]);
+  await nativeStep(context, installed, "npm", [
+    "ci",
+    "--ignore-scripts",
+    "--no-audit",
+    "--no-fund",
+  ]);
+  if (ruby)
+    await nativeStep(context, installed, "bundle", [
+      "install",
+      "--jobs",
+      "2",
+      "--retry",
+      "0",
+    ]);
+  required(
+    before.every(([name, bytes]) =>
+      readFileSync(join(context.cwd, name)).equals(bytes)
+    ),
+    "ordinary dependency install changed manifest/lock baseline"
+  );
+  return installed;
+}
+
+/** The original supported manager installs its own wrappers; no synthetic replacement hook is written. */
+async function installOriginalManager(context, env) {
+  const lefthook = existsSync(join(context.cwd, "lefthook.yml"));
+  if (lefthook)
+    await nativeStep(context, env, "bundle", ["exec", "lefthook", "install"]);
+  else {
+    const husky = join(context.cwd, "node_modules/husky/bin.js");
+    required(
+      existsSync(husky) && existsSync(join(context.cwd, ".husky/pre-push")),
+      "original hook manager installation is unavailable"
+    );
+    await nativeStep(context, env, process.execPath, [husky]);
+  }
+  const git = args => nativeStep(context, env, "/usr/bin/git", args);
+  const result = await git(["rev-parse", "--git-path", "hooks"]);
+  const text = result.stdout.toString();
+  required(
+    text.endsWith("\n") && !/[\n\r\0]/.test(text.slice(0, -1)),
+    "original hook path is unsupported"
+  );
+  const directory = resolve(context.cwd, text.slice(0, -1));
+  const wrappers = {};
+  for (const name of [
+    "pre-commit",
+    "prepare-commit-msg",
+    "commit-msg",
+    "pre-push",
+  ]) {
+    const path = join(directory, name);
+    required(
+      lstatSync(path).isFile() && !lstatSync(path).isSymbolicLink(),
+      "original hook wrapper is missing or aliased"
+    );
+    wrappers[name] = sha256(readFileSync(path));
+  }
+  const installation = { manager: lefthook ? "lefthook" : "husky", wrappers };
+  await originalHookInstallation(context.cwd, git, installation);
+  return installation;
+}
+
+/** Proof paths are the actual fixed slots installed for the unchanged canonical verifier. */
+async function proofScope(context, env) {
+  const result = await nativeStep(context, env, "/usr/bin/git", [
+    "rev-parse",
+    "--git-common-dir",
+  ]);
+  const text = result.stdout.toString();
+  required(
+    text.endsWith("\n") && !/[\n\r\0]/.test(text.slice(0, -1)),
+    "original Git control path is unsupported"
+  );
+  const control = resolve(
+    context.cwd,
+    text.slice(0, -1),
+    "lisa/automation-provenance"
+  );
+  const policy = context.config.automationProvenance;
+  const record = (file, bundle, predicate) => ({
+    file: join(control, file),
+    bundle: join(control, bundle),
+    predicate,
+    signerWorkflow: policy.signerWorkflow,
+    signerDigest: policy.signerDigest,
+  });
+  const proofs = [record("descriptor.json", "bundle.json", PROPOSAL_PREDICATE)];
+  if (context.recovery !== undefined)
+    proofs.push(
+      record("recovery.json", "recovery-bundle.json", RECOVERY_PREDICATE)
+    );
+  const recoveryDescriptor =
+    context.recovery === undefined
+      ? undefined
+      : JSON.parse(context.recovery.toString());
+  return { proofs, recoveryDescriptor };
+}
+
+/** PATH preserves original native commands; the sole Node gateway carries no provider token. */
+function nodeGateway(root, context) {
+  const bin = join(root, "hook-bin");
+  mkdirSync(bin, { mode: 0o700 });
+  const entry = fileURLToPath(
+    new URL("./npm-update-hosted-hook.mjs", import.meta.url)
+  );
+  const quote = text => {
+    required(!/[\0\n\r]/.test(text), "unsupported hosted gateway path");
+    return `'${text.replaceAll("'", "'\\''")}'`;
+  };
+  const file = join(root, "hosted-hooks.json");
+  writeJson(file, context);
+  writeFileSync(
+    join(bin, "node"),
+    `#!/bin/sh\nexec ${quote(context.native.node.path)} ${quote(entry)} --context ${quote(file)} -- "$@"\n`,
+    { flag: "wx", mode: 0o700 }
+  );
+  return bin;
+}
+
+/** A separate read-only capability is available during original gates; it cannot acquire publisher/issuer permissions. */
+export async function createHostedGate(context, root, env) {
+  assertHostedGate(context);
+  const native = controllerTools(context.config.automationProvenance);
+  const graph = await qualifiedControllerGraph(context.cwd, context.config, [
+    "lisa-work-item.mjs",
+    "lisa-automation-provenance.mjs",
+    "lisa-rails-prepush.mjs",
+    "lib/npm-update-hosted-hook.mjs",
+    "lib/npm-update-hook-preload.mjs",
+  ]);
+  const installed = await installHostedDependencies(context, root, env);
+  const installation = await installOriginalManager(context, installed);
+  const scope = await proofScope(context, installed);
+  mkdirSync(join(root, "gh-config"), { mode: 0o700 });
+  const profile = {
+    version: 1,
+    deadline: context.deadline,
+    cwd: context.cwd,
+    home: root,
+    nativeGh: native.gh,
+    invocation: {
+      entry: join(context.cwd, "scripts/lisa-npm-updater.mjs"),
+      args: [join(context.cwd, "scripts/lisa-npm-updater.mjs"), "gate"],
+      cwd: context.cwd,
+    },
+    subject: controllerSubject(
+      { ...context, recoveryDescriptor: scope.recoveryDescriptor },
+      "hook-read",
+      null,
+      scope.proofs
+    ),
+  };
+  const broker = await startHookReadBroker(profile, context.token);
+  try {
+    const bin = nodeGateway(root, {
+      version: 1,
+      root,
+      cwd: context.cwd,
+      graph,
+      native,
+      reader: { root, path: broker.path, deadline: context.deadline },
+    });
+    return {
+      installation,
+      env: {
+        ...installed,
+        PATH: `${bin}:${installed.PATH}`,
+        CI: "true",
+        GITHUB_ACTIONS: "true",
+        GITHUB_REPOSITORY: context.policy.repository,
+        GITHUB_RUN_ID: process.env.GITHUB_RUN_ID,
+        GITHUB_RUN_ATTEMPT: process.env.GITHUB_RUN_ATTEMPT,
+        GITHUB_SHA: context.proposal.parent,
+        GITHUB_REF: "refs/heads/main",
+        GITHUB_EVENT_NAME: process.env.GITHUB_EVENT_NAME,
+      },
+      close: broker.close,
+    };
+  } catch (error) {
+    await broker.close();
+    throw error;
+  }
+}