iterate on prep

prep/installNodeDependencies.ts

@@ -0,0 +1,126 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { detect } from "package-manager-detector";
+import { resolveCommand } from "package-manager-detector/commands";
+import { log } from "../utils/cli.ts";
+import { spawn } from "../utils/subprocess.ts";
+import type { NodePackageManager, NodePrepResult, PrepDefinition } from "./types.ts";
+
+// package managers that need installation (npm is always available)
+type InstallablePackageManager = Exclude<NodePackageManager, "npm">;
+
+// install commands for each package manager
+const PM_INSTALL_COMMANDS: Record<InstallablePackageManager, string[]> = {
+  pnpm: ["npm", "install", "-g", "pnpm"],
+  yarn: ["npm", "install", "-g", "yarn"],
+  bun: ["npm", "install", "-g", "bun"],
+  deno: ["sh", "-c", "curl -fsSL https://deno.land/install.sh | sh"],
+};
+
+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 installPackageManager(name: InstallablePackageManager): Promise<string | null> {
+  log.info(`📦 installing ${name}...`);
+  const [cmd, ...args] = PM_INSTALL_COMMANDS[name];
+  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}`;
+  }
+
+  // deno installs to $HOME/.deno/bin - add to PATH for subsequent commands
+  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 (): Promise<NodePrepResult> => {
+    // detect package manager
+    const detected = await detect({ cwd: process.cwd() });
+    if (!detected) {
+      return {
+        language: "node",
+        packageManager: "npm",
+        dependenciesInstalled: false,
+        issues: ["no package manager detected from lockfile"],
+      };
+    }
+
+    const packageManager = detected.name as NodePackageManager;
+    log.info(`📦 detected package manager: ${packageManager} (${detected.agent})`);
+
+    // check if package manager is available, install if needed (npm is always available)
+    if (packageManager !== "npm" && !(await isCommandAvailable(packageManager))) {
+      log.info(`${packageManager} not found, attempting to install...`);
+      const installError = await installPackageManager(packageManager);
+      if (installError) {
+        return {
+          language: "node",
+          packageManager,
+          dependenciesInstalled: false,
+          issues: [installError],
+        };
+      }
+    }
+
+    // get the frozen install command (or fallback to regular install)
+    const resolved =
+      resolveCommand(detected.agent, "frozen", []) || resolveCommand(detected.agent, "install", []);
+    if (!resolved) {
+      return {
+        language: "node",
+        packageManager,
+        dependenciesInstalled: false,
+        issues: [`no install command found for ${detected.agent}`],
+      };
+    }
+
+    log.info(`running: ${resolved.command} ${resolved.args.join(" ")}`);
+    const result = await spawn({
+      cmd: resolved.command,
+      args: resolved.args,
+      env: { PATH: process.env.PATH || "", HOME: process.env.HOME || "" },
+      onStderr: (chunk) => process.stderr.write(chunk),
+    });
+
+    if (result.exitCode !== 0) {
+      return {
+        language: "node",
+        packageManager,
+        dependenciesInstalled: false,
+        issues: [result.stderr || `${resolved.command} exited with code ${result.exitCode}`],
+      };
+    }
+
+    return {
+      language: "node",
+      packageManager,
+      dependenciesInstalled: true,
+      issues: [],
+    };
+  },
+};