infraweaver 0.1.0

package/src/prep/index.ts

@@ -0,0 +1,96 @@
+import { performance } from "node:perf_hooks";
+import { installNodeDependencies } from "#app/prep/installNodeDependencies";
+import { installPythonDependencies } from "#app/prep/installPythonDependencies";
+import type { PrepDefinition, PrepOptions, PrepResult } from "#app/prep/types";
+import { log } from "#app/utils/cli";
+import { spawn } from "#app/utils/subprocess";
+
+export type { PrepOptions, PrepResult } from "#app/prep/types";
+
+// register all prep steps here
+const prepSteps: PrepDefinition[] = [installNodeDependencies, installPythonDependencies];
+
+/** tracked paths with staged or unstaged modifications. */
+async function dirtyTrackedPaths(): Promise<Set<string>> {
+  const result = await spawn({
+    cmd: "git",
+    args: ["diff", "--name-only", "HEAD"],
+    env: process.env,
+    activityTimeout: 0,
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `git diff --name-only HEAD failed (exit ${result.exitCode}): ${result.stderr.trim() || "(no stderr)"}`,
+    );
+  }
+  return new Set(result.stdout.split("\n").filter(Boolean));
+}
+
+/**
+ * discard tracked-file mods left by prep steps so the customer checkout is
+ * clean before agent tools run (#906: frozen installs run package lifecycle
+ * scripts that rewrite tracked generated files like the msw worker, and the
+ * resulting dirt makes `checkout_pr` refuse). only paths that were clean
+ * before prep are restored — pre-existing dirt and files the agent touched
+ * elsewhere are never clobbered. untracked files (e.g. node_modules) are
+ * unaffected.
+ */
+async function restorePrepDirtiedFiles(preDirty: Set<string>): Promise<void> {
+  const dirtied = [...(await dirtyTrackedPaths())].filter((path) => !preDirty.has(path));
+  if (dirtied.length === 0) return;
+  const result = await spawn({
+    cmd: "git",
+    args: ["restore", "--staged", "--worktree", "--", ...dirtied],
+    env: process.env,
+    activityTimeout: 0,
+  });
+  if (result.exitCode !== 0) {
+    log.warning(
+      `» failed to restore ${dirtied.length} tracked file(s) modified by prep: ${result.stderr.trim() || "(no stderr)"}`,
+    );
+    return;
+  }
+  log.info(`» restored ${dirtied.length} tracked file(s) modified by prep: ${dirtied.join(", ")}`);
+}
+
+/**
+ * run all prep steps sequentially.
+ * failures are logged as warnings but don't stop the run.
+ */
+export async function runPrepPhase(options: PrepOptions): Promise<PrepResult[]> {
+  log.debug("» starting prep phase...");
+  const startTime = performance.now();
+  const results: PrepResult[] = [];
+
+  // prep is non-mutating by contract; snapshot so any tracked drift from
+  // lifecycle scripts can be attributed to prep and restored, even when a
+  // step fails partway through.
+  const preDirty = await dirtyTrackedPaths();
+
+  try {
+    for (const step of prepSteps) {
+      const shouldRun = await step.shouldRun();
+      if (!shouldRun) {
+        log.debug(`» skipping ${step.name} (not applicable)`);
+        continue;
+      }
+
+      log.debug(`» running ${step.name}...`);
+      const result = await step.run(options);
+      results.push(result);
+
+      if (result.dependenciesInstalled) {
+        log.debug(`» ${step.name}: dependencies installed`);
+      } else if (result.issues.length > 0) {
+        log.warning(`» ${step.name}: ${result.issues[0]}`);
+      }
+    }
+  } finally {
+    await restorePrepDirtiedFiles(preDirty);
+  }
+
+  const totalDurationMs = performance.now() - startTime;
+  log.debug(`» prep phase completed (${Math.round(totalDurationMs)}ms)`);
+
+  return results;
+}

package/src/prep/installNodeDependencies.ts

@@ -0,0 +1,251 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { detect } from "package-manager-detector";
+import { resolveCommand } from "package-manager-detector/commands";
+import type {
+  NodePackageManager,
+  NodePrepResult,
+  PrepDefinition,
+  PrepOptions,
+} from "#app/prep/types";
+import { log } from "#app/utils/cli";
+import {
+  ensurePackageManager,
+  resolvePackageManagerSpec,
+} from "#app/utils/packageManager";
+import { spawn } from "#app/utils/subprocess";
+
+async function isCommandAvailable(command: string): Promise<boolean> {
+  const result = await spawn({
+    cmd: "which",
+    args: [command],
+    env: { PATH: process.env.PATH || "" },
+  });
+  return result.exitCode === 0;
+}
+
+/**
+ * Escape hatch for the one installer we cannot verify (see `installFallback`).
+ * Opt-in by name so enabling it is a deliberate, auditable choice.
+ */
+const ALLOW_REMOTE_INSTALL_SCRIPT = "INFRAWEAVER_ALLOW_REMOTE_INSTALL_SCRIPT";
+
+// fallback installers for managers corepack doesn't ship shims for.
+// pnpm and yarn are handled by `ensurePackageManager` (corepack); bun and
+// deno fall through to here because corepack ignores them.
+async function installFallback(
+  name: NodePackageManager,
+  installSpec: string,
+): Promise<string | null> {
+  if (name === "npm") return null;
+
+  // Deno has no npm-installable shim, so upstream's documented path is
+  // `curl … | sh` — piping a remote script straight into a shell, with no
+  // pinned version and nothing to verify it against. That contradicts the
+  // supply-chain posture the rest of the engine holds (the agent CLIs are
+  // version-pinned AND digest-verified, see utils/install.ts), so it is
+  // fail-closed: we do not execute an unverifiable remote script by default.
+  //
+  // Pre-installing deno on the runner is the supported path — `isCommandAvailable`
+  // above short-circuits before we ever get here.
+  if (name === "deno" && process.env[ALLOW_REMOTE_INSTALL_SCRIPT] !== "true") {
+    return (
+      `refusing to install deno by piping a remote script into a shell ` +
+      `(curl https://deno.land/install.sh | sh) — it is neither version-pinned nor ` +
+      `integrity-verified. Install deno on the runner before this step (e.g. the ` +
+      `denoland/setup-deno action, which pins a version), or set ` +
+      `${ALLOW_REMOTE_INSTALL_SCRIPT}=true to accept the risk explicitly.`
+    );
+  }
+
+  log.info(
+    `» installing ${installSpec} via npm install -g (corepack does not manage ${name})`,
+  );
+  const args =
+    name === "deno"
+      ? ["-c", "curl -fsSL https://deno.land/install.sh | sh"]
+      : ["install", "-g", installSpec];
+  const cmd = name === "deno" ? "sh" : "npm";
+  if (name === "deno") {
+    log.warning(
+      `» ${ALLOW_REMOTE_INSTALL_SCRIPT}=true — executing an unverified remote install script`,
+    );
+  }
+  const result = await spawn({
+    cmd,
+    args,
+    env: { PATH: process.env.PATH || "", HOME: process.env.HOME || "" },
+    onStderr: (chunk) => process.stderr.write(chunk),
+  });
+  if (result.exitCode !== 0) {
+    return result.stderr || `failed to install ${name}`;
+  }
+  if (name === "deno") {
+    const denoPath = join(process.env.HOME || "", ".deno", "bin");
+    process.env.PATH = `${denoPath}:${process.env.PATH}`;
+  }
+  log.info(`» installed ${name}`);
+  return null;
+}
+
+export const installNodeDependencies: PrepDefinition = {
+  name: "installNodeDependencies",
+
+  shouldRun: () => {
+    const packageJsonPath = join(process.cwd(), "package.json");
+    return existsSync(packageJsonPath);
+  },
+
+  run: async (options: PrepOptions): Promise<NodePrepResult> => {
+    // prefer the project's declared spec (devEngines.packageManager wins over
+    // packageManager). fall back to lockfile detection when nothing is declared.
+    // restrict detect() to the lockfile strategy: `detected` here doubles as
+    // the lockfile-presence gate below, and the default strategy set also
+    // returns positives off `packageManager`/`devEngines` fields (which would
+    // mask the very case we're trying to detect — declared manager but no
+    // lockfile committed).
+    const declared = await resolvePackageManagerSpec(process.cwd());
+    const detected = await detect({
+      cwd: process.cwd(),
+      strategies: ["lockfile"],
+    });
+
+    const packageManager: NodePackageManager =
+      declared?.name ?? (detected?.name as NodePackageManager) ?? "npm";
+    const agent = detected?.agent ?? packageManager;
+
+    if (declared) {
+      log.info(
+        `» using ${packageManager}@${declared.version} from package.json (${declared.source})`,
+      );
+    } else if (detected) {
+      log.info(`» detected package manager: ${packageManager} (${agent})`);
+    } else {
+      log.info(`» no package manager declared, defaulting to npm`);
+    }
+
+    // provisioning: corepack for pnpm/yarn, legacy npm-install-g for bun/deno.
+    // when shell is disabled we can't run installers (they execute code), so
+    // we require the binary to already be on PATH.
+    if (!(await isCommandAvailable(packageManager))) {
+      if (options.ignoreScripts) {
+        return {
+          language: "node",
+          packageManager,
+          dependenciesInstalled: false,
+          issues: [
+            `${packageManager} is not available and cannot be installed when shell is disabled (would execute code)`,
+          ],
+        };
+      }
+
+      let provisioned = false;
+      if (declared)
+        provisioned = await ensurePackageManager({
+          spec: declared,
+          binDir: options.binDir,
+        });
+      if (!provisioned) {
+        const fallbackSpec = declared
+          ? `${declared.name}@${declared.version}`
+          : packageManager;
+        const installError = await installFallback(
+          packageManager,
+          fallbackSpec,
+        );
+        if (installError) {
+          return {
+            language: "node",
+            packageManager,
+            dependenciesInstalled: false,
+            issues: [installError],
+          };
+        }
+      }
+    } else if (declared) {
+      // PATH already has the binary — but it may be the wrong version.
+      // ensurePackageManager is idempotent (caches on `--version` match) so
+      // this is cheap when main.ts already activated it.
+      await ensurePackageManager({ spec: declared, binDir: options.binDir });
+    }
+
+    // frozen-lockfile install only. eager prep is non-mutating by contract:
+    // we run it before the agent starts and any artifact it leaves in the
+    // tree (e.g. a generated `package-lock.json`) trips the dirty-tree
+    // post-run gate and produces a spurious PR. `frozen` commands
+    // (`npm ci`, `pnpm install --frozen-lockfile`, etc.) were assumed to
+    // fail cleanly without a lockfile — that assumption is false for
+    // pnpm 11.1.1 against a no-deps `package.json` (it silently writes an
+    // empty `pnpm-lock.yaml` despite the flag). gate on `detect()` having
+    // found a lockfile; it walks up the tree (so monorepo subpackages
+    // resolve to the workspace-root lockfile) and recognizes every
+    // manager's accepted lockfile variants (`bun.lockb` + `bun.lock`,
+    // `npm-shrinkwrap.json` + `package-lock.json`, etc.). when none is
+    // present, the project either has no installable dependencies or
+    // opts into install via a `setup` lifecycle hook
+    // (`action/utils/lifecycle.ts`); either way, eager prep should skip.
+    if (!detected) {
+      log.info(
+        `» skipping ${packageManager} install: no lockfile found (would otherwise risk lockfile drift)`,
+      );
+      return {
+        language: "node",
+        packageManager,
+        dependenciesInstalled: false,
+        issues: [],
+      };
+    }
+
+    const resolved = resolveCommand(agent, "frozen", []);
+    if (!resolved) {
+      return {
+        language: "node",
+        packageManager,
+        dependenciesInstalled: false,
+        issues: [`no frozen-install command available for ${agent}`],
+      };
+    }
+
+    // SECURITY: when shell is disabled, suppress lifecycle scripts to prevent
+    // agents from injecting arbitrary code execution via package.json scripts
+    if (options.ignoreScripts) {
+      resolved.args.push("--ignore-scripts");
+      log.info("» --ignore-scripts enabled (shell disabled)");
+    }
+
+    const fullCommand = `${resolved.command} ${resolved.args.join(" ")}`;
+    log.info(`» running: ${fullCommand}`);
+    const result = await spawn({
+      cmd: resolved.command,
+      args: resolved.args,
+      env: { PATH: process.env.PATH || "", HOME: process.env.HOME || "" },
+    });
+
+    const output = [result.stdout, result.stderr]
+      .filter(Boolean)
+      .join("\n")
+      .trim();
+    if (output) {
+      log.startGroup(`${fullCommand} output`);
+      log.info(output);
+      log.endGroup();
+    }
+
+    if (result.exitCode !== 0) {
+      const errorMessage = output || `exited with code ${result.exitCode}`;
+      return {
+        language: "node",
+        packageManager,
+        dependenciesInstalled: false,
+        issues: [`\`${fullCommand}\` failed:\n${errorMessage}`],
+      };
+    }
+
+    return {
+      language: "node",
+      packageManager,
+      dependenciesInstalled: true,
+      issues: [],
+    };
+  },
+};

package/src/prep/installPythonDependencies.ts

@@ -0,0 +1,235 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type {
+  PrepDefinition,
+  PrepOptions,
+  PythonPackageManager,
+  PythonPrepResult,
+} from "#app/prep/types";
+import { log } from "#app/utils/cli";
+import { spawn } from "#app/utils/subprocess";
+
+interface PythonConfig {
+  file: string;
+  tool: PythonPackageManager;
+  // non-empty: the first element is the executable, the rest are args
+  installCmd: [string, ...string[]];
+}
+
+// python dependency file patterns in priority order
+const PYTHON_CONFIGS: PythonConfig[] = [
+  {
+    file: "requirements.txt",
+    tool: "pip",
+    installCmd: ["pip", "install", "-r", "requirements.txt"],
+  },
+  {
+    file: "pyproject.toml",
+    tool: "pip",
+    installCmd: ["pip", "install", "."],
+  },
+  {
+    file: "Pipfile",
+    tool: "pipenv",
+    installCmd: ["pipenv", "install"],
+  },
+  {
+    file: "Pipfile.lock",
+    tool: "pipenv",
+    installCmd: ["pipenv", "sync"],
+  },
+  {
+    file: "poetry.lock",
+    tool: "poetry",
+    installCmd: ["poetry", "install", "--no-interaction"],
+  },
+  {
+    file: "setup.py",
+    tool: "pip",
+    installCmd: ["pip", "install", "-e", "."],
+  },
+];
+
+/**
+ * A root `pyproject.toml` no longer implies a pip-installable package. When it
+ * lacks a `[build-system]` table (PEP 517/518) it is a tool-config / PEP 735
+ * dependency-groups file (e.g. ruff/mypy under uv), and `pip install .` falls
+ * back to legacy setuptools flat-layout discovery, which hard-fails on monorepos
+ * ("Multiple top-level packages discovered in a flat-layout"). The gate is a
+ * heuristic proxy for "scaffolded as a distributable package": pip treats a
+ * pyproject without `[build-system]` as the legacy setuptools backend and would
+ * proceed, so we trade a rare false-negative to kill the common tooling-only
+ * false positive. Unreadable → treat as not installable (skip, don't crash prep).
+ */
+function pyprojectDeclaresBuildSystem(cwd: string): boolean {
+  try {
+    const content = readFileSync(join(cwd, "pyproject.toml"), "utf8");
+    return /^\s*\[build-system\]/m.test(content);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Whether a detected config file should actually drive an install. Everything
+ * applies except a `pyproject.toml` with no build system — that one is skipped
+ * so a tooling-only pyproject doesn't trigger a doomed `pip install .`.
+ */
+function configApplies(config: PythonConfig, cwd: string): boolean {
+  if (config.file === "pyproject.toml") return pyprojectDeclaresBuildSystem(cwd);
+  return true;
+}
+
+// tool install commands (via pip). Each command is non-empty (executable + args).
+const TOOL_INSTALL_COMMANDS: Record<string, [string, ...string[]]> = {
+  pipenv: ["pip", "install", "pipenv"],
+  poetry: ["pip", "install", "poetry"],
+};
+
+async function isCommandAvailable(command: string): Promise<boolean> {
+  const result = await spawn({
+    cmd: "which",
+    args: [command],
+    env: { PATH: process.env.PATH || "" },
+  });
+  return result.exitCode === 0;
+}
+
+async function installTool(name: string): Promise<string | null> {
+  const installCmd = TOOL_INSTALL_COMMANDS[name];
+  if (!installCmd) {
+    // tool doesn't need installation (e.g., pip)
+    return null;
+  }
+
+  log.info(`» installing ${name}...`);
+  const [cmd, ...args] = installCmd;
+  const result = await spawn({
+    cmd,
+    args,
+    env: { PATH: process.env.PATH || "", HOME: process.env.HOME || "" },
+    onStderr: (chunk) => process.stderr.write(chunk),
+  });
+
+  if (result.exitCode !== 0) {
+    return result.stderr || `failed to install ${name}`;
+  }
+
+  log.info(`» installed ${name}`);
+  return null;
+}
+
+export const installPythonDependencies: PrepDefinition = {
+  name: "installPythonDependencies",
+
+  shouldRun: async () => {
+    // check if python is available
+    const hasPython = (await isCommandAvailable("python3")) || (await isCommandAvailable("python"));
+    if (!hasPython) {
+      return false;
+    }
+
+    // check if any python config file exists AND actually drives an install
+    // (a tooling-only pyproject.toml without a [build-system] table does not).
+    const cwd = process.cwd();
+    return PYTHON_CONFIGS.some(
+      (config) => existsSync(join(cwd, config.file)) && configApplies(config, cwd),
+    );
+  },
+
+  run: async (options: PrepOptions): Promise<PythonPrepResult> => {
+    const cwd = process.cwd();
+
+    // find the first matching config that actually drives an install (skips a
+    // tooling-only pyproject.toml, letting a lower-priority config win instead).
+    const config = PYTHON_CONFIGS.find(
+      (c) => existsSync(join(cwd, c.file)) && configApplies(c, cwd),
+    );
+    if (!config) {
+      return {
+        language: "python",
+        packageManager: "pip",
+        configFile: "unknown",
+        dependenciesInstalled: false,
+        issues: ["no python config file found"],
+      };
+    }
+
+    log.info(`» detected python config: ${config.file} (using ${config.tool})`);
+
+    // SECURITY: when shell is disabled, skip ALL python dependency installation.
+    // every python install path can potentially execute arbitrary code:
+    //   - setup.py / pyproject.toml: directly execute build backends
+    //   - requirements.txt: can contain "-e ." or local path references that
+    //     trigger setup.py execution
+    //   - Pipfile/poetry.lock: can contain path dependencies pointing to local
+    //     directories with malicious setup.py
+    //   - source distributions from PyPI also execute setup.py
+    // there is no equivalent of npm's --ignore-scripts for pip.
+    if (options.ignoreScripts) {
+      log.info(
+        `» skipping python install (shell disabled, python packages can execute arbitrary code)`,
+      );
+      return {
+        language: "python",
+        packageManager: config.tool,
+        configFile: config.file,
+        dependenciesInstalled: false,
+        issues: [
+          `skipped: python dependency installation can execute arbitrary code (setup.py, build backends, local path references), which is blocked when shell is disabled`,
+        ],
+      };
+    }
+
+    // check if the tool is available, install if needed
+    const isAvailable = await isCommandAvailable(config.tool);
+    if (!isAvailable) {
+      log.info(`» ${config.tool} not found, attempting to install...`);
+      const installError = await installTool(config.tool);
+      if (installError) {
+        return {
+          language: "python",
+          packageManager: config.tool,
+          configFile: config.file,
+          dependenciesInstalled: false,
+          issues: [installError],
+        };
+      }
+    }
+
+    // run the install command
+    const [cmd, ...args] = config.installCmd;
+    const fullCommand = `${cmd} ${args.join(" ")}`;
+    log.info(`» running: ${fullCommand}`);
+    const result = await spawn({
+      cmd,
+      args,
+      env: { PATH: process.env.PATH || "", HOME: process.env.HOME || "" },
+    });
+
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+    if (output) {
+      log.startGroup(`${fullCommand} output`);
+      log.info(output);
+      log.endGroup();
+    }
+
+    if (result.exitCode !== 0) {
+      return {
+        language: "python",
+        packageManager: config.tool,
+        configFile: config.file,
+        dependenciesInstalled: false,
+        issues: [output || `${cmd} exited with code ${result.exitCode}`],
+      };
+    }
+
+    return {
+      language: "python",
+      packageManager: config.tool,
+      configFile: config.file,
+      dependenciesInstalled: true,
+      issues: [],
+    };
+  },
+};

package/src/prep/types.ts

@@ -0,0 +1,38 @@
+interface PrepResultBase {
+  dependenciesInstalled: boolean;
+  issues: string[];
+}
+
+export type NodePackageManager = "npm" | "pnpm" | "yarn" | "bun" | "deno";
+
+export interface NodePrepResult extends PrepResultBase {
+  language: "node";
+  packageManager: NodePackageManager;
+}
+
+export type PythonPackageManager = "pip" | "pipenv" | "poetry";
+
+export interface PythonPrepResult extends PrepResultBase {
+  language: "python";
+  packageManager: PythonPackageManager;
+  configFile: string;
+}
+
+export interface UnknownLanguagePrepResult extends PrepResultBase {
+  language: "unknown";
+}
+
+export type PrepResult = NodePrepResult | PythonPrepResult | UnknownLanguagePrepResult;
+
+export type PrepOptions = {
+  /** when true, lifecycle scripts (postinstall, etc.) are suppressed */
+  ignoreScripts: boolean;
+  /** directory the corepack shim is installed into (see `packageManagerBinDir`) */
+  binDir: string;
+};
+
+export interface PrepDefinition {
+  name: string;
+  shouldRun: () => Promise<boolean> | boolean;
+  run: (options: PrepOptions) => Promise<PrepResult>;
+}