@beastmode-develeap/beastmode 0.1.198 → 0.1.199

package/dist/index.js

@@ -8490,8 +8490,8 @@ async function runInit(name, opts) {
     throw new Error(`Factory already exists at ./${factoryName}. Use 'beastmode config' to modify.`);
   }
   if (opts.from) {
-    const { readFileSync: readFileSync33 } = await import("fs");
-    const templateContent = readFileSync33(resolve6(opts.from), "utf-8");
+    const { readFileSync: readFileSync36 } = await import("fs");
+    const templateContent = readFileSync36(resolve6(opts.from), "utf-8");
     const { parseTemplate: parseTemplate2 } = await Promise.resolve().then(() => (init_template_importer(), template_importer_exports));
     const template = parseTemplate2(templateContent);
     info(`Importing from template: ${opts.from}`);
@@ -11423,10 +11423,10 @@ async function runMigrate(opts) {
   let runDirs = [];
   const checkpoints = /* @__PURE__ */ new Map();
   if (existsSync28(runsDir)) {
-    const { readdirSync: readdirSync13 } = await import("fs");
-    runDirs = readdirSync13(runsDir).filter((d) => {
+    const { readdirSync: readdirSync14 } = await import("fs");
+    runDirs = readdirSync14(runsDir).filter((d) => {
       try {
-        return readdirSync13(join26(runsDir, d)).length > 0;
+        return readdirSync14(join26(runsDir, d)).length > 0;
       } catch {
         return false;
       }
@@ -11444,8 +11444,8 @@ async function runMigrate(opts) {
   }
   let worktreeOutput = "";
   try {
-    const { execSync: execSync13 } = await import("child_process");
-    worktreeOutput = execSync13("git worktree list", {
+    const { execSync: execSync14 } = await import("child_process");
+    worktreeOutput = execSync14("git worktree list", {
       cwd,
       encoding: "utf-8",
       timeout: 5e3
@@ -11568,8 +11568,8 @@ async function runPipeline(projectName, opts) {
   let projectConfig = null;
   const projectsDir = join27(bmDir, "projects");
   if (existsSync29(projectsDir)) {
-    const { readdirSync: readdirSync13 } = await import("fs");
-    const projectFiles = readdirSync13(projectsDir).filter(
+    const { readdirSync: readdirSync14 } = await import("fs");
+    const projectFiles = readdirSync14(projectsDir).filter(
       (f) => f.endsWith(".json")
     );
     if (projectName) {
@@ -11618,14 +11618,14 @@ async function runPipeline(projectName, opts) {
   const daemonConfig = generateDaemonConfig(factoryConfig, projectConfig, factoryDir);
   writeFileSync22(daemonConfigPath, JSON.stringify(daemonConfig, null, 2), "utf-8");
   info(`Generated daemon config at: ${daemonConfigPath}`);
-  const { execSync: execSync13 } = await import("child_process");
+  const { execSync: execSync14 } = await import("child_process");
   let pythonAvailable = false;
   try {
-    execSync13("python --version", { timeout: 5e3, encoding: "utf-8" });
+    execSync14("python --version", { timeout: 5e3, encoding: "utf-8" });
     pythonAvailable = true;
   } catch {
     try {
-      execSync13("python3 --version", { timeout: 5e3, encoding: "utf-8" });
+      execSync14("python3 --version", { timeout: 5e3, encoding: "utf-8" });
       pythonAvailable = true;
     } catch {
     }
@@ -11746,8 +11746,8 @@ async function runDaemon(opts) {
   let projectConfig = null;
   const projectsDir = join28(bmDir, "projects");
   if (existsSync30(projectsDir)) {
-    const { readdirSync: readdirSync13 } = await import("fs");
-    const projectFiles = readdirSync13(projectsDir).filter(
+    const { readdirSync: readdirSync14 } = await import("fs");
+    const projectFiles = readdirSync14(projectsDir).filter(
       (f) => f.endsWith(".json")
     );
     if (projectFiles.length > 0) {
@@ -11778,16 +11778,16 @@ async function runDaemon(opts) {
     console.log(JSON.stringify(daemonConfig, null, 2));
     return;
   }
-  const { execSync: execSync13 } = await import("child_process");
+  const { execSync: execSync14 } = await import("child_process");
   let pythonCmd = "python";
   let pythonAvailable = false;
   try {
-    execSync13("python --version", { timeout: 5e3, encoding: "utf-8" });
+    execSync14("python --version", { timeout: 5e3, encoding: "utf-8" });
     pythonAvailable = true;
     pythonCmd = "python";
   } catch {
     try {
-      execSync13("python3 --version", { timeout: 5e3, encoding: "utf-8" });
+      execSync14("python3 --version", { timeout: 5e3, encoding: "utf-8" });
       pythonAvailable = true;
       pythonCmd = "python3";
     } catch {
@@ -12466,7 +12466,313 @@ var updateCommand = new Command22("update").description("Pull latest BeastMode i
 init_display();
 import { Command as Command23 } from "commander";
 import { spawn as spawn3 } from "child_process";
-import { resolve as resolve20 } from "path";
+import { existsSync as existsSync37, readdirSync as readdirSync12, readFileSync as readFileSync34 } from "fs";
+import { basename as basename6, join as join36, resolve as resolve20 } from "path";
+
+// src/cli/runner-image-builder.ts
+import { execSync as execSync10 } from "child_process";
+import { createHash } from "crypto";
+import {
+  existsSync as existsSync34,
+  mkdirSync as mkdirSync20,
+  readFileSync as readFileSync32,
+  writeFileSync as writeFileSync27
+} from "fs";
+import { join as join32 } from "path";
+
+// src/cli/stack-detect.ts
+import { existsSync as existsSync33, readFileSync as readFileSync31 } from "fs";
+import { join as join31 } from "path";
+var NODE_LOCKFILES = [
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lockb",
+  "package.json"
+];
+var PYTHON_LOCKFILES = [
+  "poetry.lock",
+  "uv.lock",
+  "Pipfile.lock",
+  "requirements.txt",
+  "pyproject.toml"
+];
+var GO_LOCKFILES = ["go.mod", "go.sum"];
+var RUST_LOCKFILES = ["Cargo.lock", "Cargo.toml"];
+var JAVA_MAVEN_LOCKFILES = ["pom.xml"];
+var JAVA_GRADLE_LOCKFILES = [
+  "build.gradle",
+  "build.gradle.kts",
+  "gradle.lockfile"
+];
+var STACK_LOCKFILES = {
+  nextjs: NODE_LOCKFILES,
+  vite: NODE_LOCKFILES,
+  react: NODE_LOCKFILES,
+  node: NODE_LOCKFILES,
+  fastapi: PYTHON_LOCKFILES,
+  django: PYTHON_LOCKFILES,
+  python: PYTHON_LOCKFILES,
+  go: GO_LOCKFILES,
+  rust: RUST_LOCKFILES,
+  "java-maven": JAVA_MAVEN_LOCKFILES,
+  "java-gradle": JAVA_GRADLE_LOCKFILES
+};
+function readFileSafe2(path) {
+  try {
+    return readFileSync31(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function parseJsonSafe2(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function detectRunnerStack(projectDir) {
+  const pkgContent = readFileSafe2(join31(projectDir, "package.json"));
+  if (pkgContent) {
+    const pkg = parseJsonSafe2(pkgContent);
+    if (pkg) {
+      const deps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+      if (deps.next) return { name: "nextjs", language: "node" };
+      if (deps.vite) return { name: "vite", language: "node" };
+      if (deps["react-scripts"]) return { name: "react", language: "node" };
+    }
+    return { name: "node", language: "node" };
+  }
+  if (existsSync33(join31(projectDir, "manage.py"))) {
+    return { name: "django", language: "python" };
+  }
+  const pyproject = readFileSafe2(join31(projectDir, "pyproject.toml"));
+  if (pyproject) {
+    if (pyproject.toLowerCase().includes("fastapi")) {
+      return { name: "fastapi", language: "python" };
+    }
+    return { name: "python", language: "python" };
+  }
+  if (existsSync33(join31(projectDir, "requirements.txt"))) {
+    return { name: "python", language: "python" };
+  }
+  if (existsSync33(join31(projectDir, "go.mod"))) {
+    return { name: "go", language: "go" };
+  }
+  if (existsSync33(join31(projectDir, "Cargo.toml"))) {
+    return { name: "rust", language: "rust" };
+  }
+  if (existsSync33(join31(projectDir, "pom.xml"))) {
+    return { name: "java-maven", language: "java" };
+  }
+  if (existsSync33(join31(projectDir, "build.gradle")) || existsSync33(join31(projectDir, "build.gradle.kts"))) {
+    return { name: "java-gradle", language: "java" };
+  }
+  return { name: "node", language: "node" };
+}
+function findLockfiles(projectDir, stackName) {
+  const candidates = STACK_LOCKFILES[stackName] ?? [];
+  return candidates.filter((f) => existsSync33(join31(projectDir, f)));
+}
+
+// src/cli/runner-image-builder.ts
+var RUNNER_STATE_DIR = ".beastmode/runner";
+var LAST_BUILD_FILE = "last-build.json";
+var LAYERS_FILE = "runner-layers.json";
+function getDependencyInstallCommand(stack, lockfiles) {
+  if (lockfiles.length === 0) return null;
+  const has = (name) => lockfiles.includes(name);
+  if (stack.language === "node") {
+    if (has("pnpm-lock.yaml")) return "pnpm install --frozen-lockfile";
+    if (has("yarn.lock")) return "yarn install --frozen-lockfile";
+    if (has("bun.lockb")) return "bun install --frozen-lockfile";
+    if (has("package-lock.json")) return "npm ci";
+    if (has("package.json")) return "npm install";
+    return null;
+  }
+  if (stack.language === "python") {
+    if (has("poetry.lock")) return "poetry install --no-interaction --no-root";
+    if (has("uv.lock")) return "uv sync --frozen";
+    if (has("Pipfile.lock")) return "pipenv install --deploy";
+    if (has("requirements.txt")) return "pip install -r requirements.txt";
+    if (has("pyproject.toml")) return "pip install .";
+    return null;
+  }
+  if (stack.language === "go") {
+    if (has("go.mod")) return "go mod download";
+    return null;
+  }
+  if (stack.language === "rust") {
+    if (has("Cargo.lock") || has("Cargo.toml")) return "cargo fetch";
+    return null;
+  }
+  if (stack.language === "java") {
+    if (stack.name === "java-maven" && has("pom.xml")) {
+      return "mvn -B -q dependency:go-offline";
+    }
+    if (stack.name === "java-gradle" && (has("build.gradle") || has("build.gradle.kts"))) {
+      return "./gradlew --no-daemon dependencies || true";
+    }
+    return null;
+  }
+  return null;
+}
+function runtimeInstallBlock(stack) {
+  switch (stack.language) {
+    case "node":
+      return [
+        "RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \\",
+        " && apt-get install -y --no-install-recommends nodejs \\",
+        " && npm install -g pnpm yarn \\",
+        " && rm -rf /var/lib/apt/lists/*"
+      ].join("\n");
+    case "python":
+      return [
+        "RUN apt-get update \\",
+        " && apt-get install -y --no-install-recommends python3 python3-pip python3-venv \\",
+        " && rm -rf /var/lib/apt/lists/*"
+      ].join("\n");
+    case "go":
+      return [
+        "RUN curl -fsSL https://go.dev/dl/go1.22.0.linux-amd64.tar.gz \\",
+        " | tar -C /usr/local -xz",
+        'ENV PATH="/usr/local/go/bin:${PATH}"'
+      ].join("\n");
+    case "rust":
+      return [
+        "RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \\",
+        " | sh -s -- -y --default-toolchain stable",
+        'ENV PATH="/root/.cargo/bin:${PATH}"'
+      ].join("\n");
+    case "java":
+      return [
+        "RUN apt-get update \\",
+        " && apt-get install -y --no-install-recommends openjdk-17-jdk-headless maven gradle \\",
+        " && rm -rf /var/lib/apt/lists/*"
+      ].join("\n");
+    default:
+      return "# no runtime block for unknown language";
+  }
+}
+function generateDockerfile(stack, lockfiles) {
+  const lines = [];
+  lines.push("FROM myoung34/github-runner:latest");
+  lines.push("USER root");
+  lines.push("WORKDIR /opt/runner-deps");
+  lines.push(runtimeInstallBlock(stack));
+  if (lockfiles.length > 0) {
+    for (const lf of lockfiles) {
+      lines.push(`COPY ${lf} ./${lf}`);
+    }
+    const installCmd = getDependencyInstallCommand(stack, lockfiles);
+    if (installCmd) {
+      lines.push(`RUN ${installCmd}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function computeLockfileHash(projectDir, lockfiles) {
+  const hash = createHash("sha256");
+  for (const lf of lockfiles) {
+    const path = join32(projectDir, lf);
+    hash.update(lf);
+    hash.update("\0");
+    if (existsSync34(path)) {
+      try {
+        hash.update(readFileSync32(path));
+      } catch {
+        hash.update("<unreadable>");
+      }
+    } else {
+      hash.update("<missing>");
+    }
+    hash.update("\0");
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function readLastBuild(projectDir) {
+  const path = join32(projectDir, RUNNER_STATE_DIR, LAST_BUILD_FILE);
+  if (!existsSync34(path)) return null;
+  try {
+    const data = JSON.parse(readFileSync32(path, "utf-8"));
+    if (data && typeof data === "object" && typeof data.lockfileHash === "string" && typeof data.imageTag === "string" && typeof data.builtAt === "string") {
+      return data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function shouldRebuild(projectDir, currentHash) {
+  const last = readLastBuild(projectDir);
+  if (!last) return true;
+  return last.lockfileHash !== currentHash;
+}
+function imageTagFor(projectName, hash) {
+  const safeName = projectName.toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+  return `beastmode-runner-${safeName}:${hash}`;
+}
+function writeStateFile(projectDir, fileName, payload) {
+  const dir = join32(projectDir, RUNNER_STATE_DIR);
+  mkdirSync20(dir, { recursive: true });
+  writeFileSync27(
+    join32(dir, fileName),
+    JSON.stringify(payload, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function buildRunnerImage(opts) {
+  const { projectDir, projectName, stack, lockfiles, force, dryRun } = opts;
+  if (!existsSync34(projectDir)) {
+    throw new Error(`Project directory not found: ${projectDir}`);
+  }
+  const lockfileHash = computeLockfileHash(projectDir, lockfiles);
+  const imageTag = imageTagFor(projectName, lockfileHash);
+  const dockerfile = generateDockerfile(stack, lockfiles);
+  if (dryRun) {
+    return { imageTag, lockfileHash, dockerfile, built: false };
+  }
+  if (!force && !shouldRebuild(projectDir, lockfileHash)) {
+    return { imageTag, lockfileHash, dockerfile, built: false };
+  }
+  try {
+    execSync10(
+      `docker build -t ${imageTag} -f - ${projectDir}`,
+      {
+        input: dockerfile,
+        stdio: ["pipe", "inherit", "inherit"]
+      }
+    );
+  } catch (err) {
+    const e = err;
+    if (e && e.code === "ENOENT") {
+      throw new Error(
+        "Docker is required for runner image builds. Install Docker and retry."
+      );
+    }
+    const msg = err?.message ?? String(err);
+    throw new Error(`docker build failed: ${msg}`);
+  }
+  const builtAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeStateFile(projectDir, LAST_BUILD_FILE, {
+    lockfileHash,
+    imageTag,
+    builtAt
+  });
+  writeStateFile(projectDir, LAYERS_FILE, {
+    project: projectName,
+    stack: stack.name,
+    lockfile_hash: lockfileHash,
+    image_tag: imageTag,
+    lockfiles,
+    built_at: builtAt
+  });
+  return { imageTag, lockfileHash, dockerfile, built: true };
+}
 
 // src/cli/github-runners.ts
 var GitHubRunnerApiError = class extends Error {
@@ -12538,19 +12844,19 @@ function resolveGitHubConfig() {
 }
 
 // src/cli/runner-helpers.ts
-import { execSync as execSync10, spawn, spawnSync as spawnSync5 } from "child_process";
+import { execSync as execSync11, spawn, spawnSync as spawnSync5 } from "child_process";
 import { promises as fs } from "fs";
-import { join as join31 } from "path";
+import { join as join33 } from "path";
 init_display();
 async function writeRunnerMeta(dir, meta) {
   await fs.mkdir(dir, { recursive: true });
-  const path = join31(dir, "runner-meta.json");
+  const path = join33(dir, "runner-meta.json");
   await fs.writeFile(path, JSON.stringify(meta, null, 2) + "\n", "utf-8");
 }
 function resolveRepoSlug() {
   let rawUrl;
   try {
-    rawUrl = execSync10("git remote get-url origin", {
+    rawUrl = execSync11("git remote get-url origin", {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -12636,6 +12942,7 @@ async function removeContainer(name) {
 }
 async function startRunnerContainer(opts) {
   const labelStr = opts.labels.join(",");
+  const image = opts.image ?? "myoung34/github-runner:latest";
   const args = [
     "run",
     "-d",
@@ -12652,7 +12959,7 @@ async function startRunnerContainer(opts) {
     `RUNNER_NAME=${opts.name}`,
     "-v",
     "/var/run/docker.sock:/var/run/docker.sock",
-    "myoung34/github-runner:latest"
+    image
   ];
   const result = spawnSync5("docker", args, {
     stdio: ["ignore", "ignore", "pipe"],
@@ -12738,19 +13045,19 @@ function setupStep(text) {
 
 // src/cli/native-runner.ts
 import {
-  execSync as execSync11,
+  execSync as execSync12,
   spawn as spawn2,
   spawnSync as spawnSync6
 } from "child_process";
 import {
   createWriteStream,
-  existsSync as existsSync33,
-  mkdirSync as mkdirSync20,
+  existsSync as existsSync35,
+  mkdirSync as mkdirSync21,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync27
+  writeFileSync as writeFileSync28
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join32, dirname as dirname8 } from "path";
+import { join as join34, dirname as dirname8 } from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 init_display();
@@ -12780,8 +13087,8 @@ function runnerDownloadUrl(os, arch) {
   return `https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-${ghOs}-${arch}-${RUNNER_VERSION}.tar.gz`;
 }
 async function downloadAndExtractRunner(installDir, os, arch) {
-  const runShPath = join32(installDir, "run.sh");
-  if (existsSync33(runShPath)) {
+  const runShPath = join34(installDir, "run.sh");
+  if (existsSync35(runShPath)) {
     info(
       `Runner binary already present at ${runShPath} \u2014 skipping download.`
     );
@@ -12791,7 +13098,7 @@ async function downloadAndExtractRunner(installDir, os, arch) {
     return;
   }
   const url = runnerDownloadUrl(os, arch);
-  const tarball = join32(installDir, "runner.tar.gz");
+  const tarball = join34(installDir, "runner.tar.gz");
   setupStep(
     `Downloading GitHub Actions runner v${RUNNER_VERSION} (${os}/${arch})...`
   );
@@ -12807,7 +13114,7 @@ async function downloadAndExtractRunner(installDir, os, arch) {
   );
   setupStep("Extracting runner...");
   try {
-    execSync11("tar -xzf runner.tar.gz", { cwd: installDir, stdio: "ignore" });
+    execSync12("tar -xzf runner.tar.gz", { cwd: installDir, stdio: "ignore" });
   } catch (err) {
     throw new Error(
       `Failed to extract runner archive: ${err?.message ?? String(err)}`
@@ -12842,7 +13149,7 @@ async function configureRunner(installDir, repoUrl, token, name, labels) {
     "--unattended",
     "--replace"
   ];
-  const result = spawnSync6(join32(installDir, "config.sh"), args, {
+  const result = spawnSync6(join34(installDir, "config.sh"), args, {
     cwd: installDir,
     stdio: ["ignore", "inherit", "pipe"],
     encoding: "utf-8"
@@ -12870,7 +13177,7 @@ function startRunnerForeground(installDir) {
       "Use --service to install as a launchd agent for persistent operation."
     );
   }
-  spawn2(join32(installDir, "run.sh"), [], {
+  spawn2(join34(installDir, "run.sh"), [], {
     cwd: installDir,
     stdio: "inherit"
   });
@@ -12895,16 +13202,16 @@ WantedBy=default.target
 }
 async function installSystemdService(installDir, name) {
   const unitName = `beastmode-runner-${name}.service`;
-  const unitDir = join32(homedir4(), ".config", "systemd", "user");
-  mkdirSync20(unitDir, { recursive: true });
-  writeFileSync27(
-    join32(unitDir, unitName),
+  const unitDir = join34(homedir4(), ".config", "systemd", "user");
+  mkdirSync21(unitDir, { recursive: true });
+  writeFileSync28(
+    join34(unitDir, unitName),
     systemdUnitContent(installDir, name),
     "utf-8"
   );
   try {
-    execSync11("systemctl --user daemon-reload", { stdio: "inherit" });
-    execSync11(`systemctl --user enable --now ${unitName}`, {
+    execSync12("systemctl --user daemon-reload", { stdio: "inherit" });
+    execSync12(`systemctl --user enable --now ${unitName}`, {
       stdio: "inherit"
     });
   } catch (err) {
@@ -12952,17 +13259,17 @@ function launchdPlistContent(installDir, name) {
 }
 async function installLaunchdService(installDir, name) {
   const label = `com.beastmode.runner.${name}`;
-  const plistPath2 = join32(
+  const plistPath2 = join34(
     homedir4(),
     "Library",
     "LaunchAgents",
     `${label}.plist`
   );
-  mkdirSync20(dirname8(plistPath2), { recursive: true });
-  mkdirSync20(join32(installDir, "logs"), { recursive: true });
-  writeFileSync27(plistPath2, launchdPlistContent(installDir, name), "utf-8");
+  mkdirSync21(dirname8(plistPath2), { recursive: true });
+  mkdirSync21(join34(installDir, "logs"), { recursive: true });
+  writeFileSync28(plistPath2, launchdPlistContent(installDir, name), "utf-8");
   try {
-    execSync11(`launchctl load ${plistPath2}`, { stdio: "inherit" });
+    execSync12(`launchctl load ${plistPath2}`, { stdio: "inherit" });
   } catch (err) {
     throw new Error(
       `launchd agent install failed: ${err?.message ?? String(err)}.`
@@ -13001,7 +13308,7 @@ async function nativeRunnerSetup(opts) {
   }
   const ghConfig = resolveGitHubConfig();
   const repoSlug = opts.repo ?? resolveRepoSlug();
-  const installDir = join32(homedir4(), ".beastmode", "runners", opts.name);
+  const installDir = join34(homedir4(), ".beastmode", "runners", opts.name);
   if (opts.dryRun) {
     info(
       `[dry-run] Would install native runner '${opts.name}' for repo ${repoSlug}`
@@ -13011,7 +13318,7 @@ async function nativeRunnerSetup(opts) {
     info(`[dry-run] Mode: ${opts.service ? "service" : "foreground"}`);
     return;
   }
-  mkdirSync20(installDir, { recursive: true });
+  mkdirSync21(installDir, { recursive: true });
   setupStep("Generating registration token via GitHub API...");
   const { token: regToken } = await createRegistrationToken(ghConfig);
   await downloadAndExtractRunner(installDir, platformOs, arch);
@@ -13049,13 +13356,13 @@ async function nativeRunnerSetup(opts) {
 
 // src/cli/workflow-switcher.ts
 import {
-  existsSync as existsSync34,
-  mkdirSync as mkdirSync21,
-  readFileSync as readFileSync31,
+  existsSync as existsSync36,
+  mkdirSync as mkdirSync22,
+  readFileSync as readFileSync33,
   unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync28
+  writeFileSync as writeFileSync29
 } from "fs";
-import { dirname as dirname9, join as join33 } from "path";
+import { dirname as dirname9, join as join35 } from "path";
 var TARGET_LABEL = "[self-hosted, beastmode]";
 var TARGET_WORKFLOWS = [
   ".github/workflows/test.yml",
@@ -13094,8 +13401,8 @@ function restoreRunsOn(content, originals) {
   return newLines.join("\n");
 }
 async function switchWorkflows(projectDir) {
-  const statePath = join33(projectDir, STATE_FILE);
-  if (existsSync34(statePath)) {
+  const statePath = join35(projectDir, STATE_FILE);
+  if (existsSync36(statePath)) {
     return { alreadySwitched: true, files: [] };
   }
   const state = {
@@ -13105,40 +13412,40 @@ async function switchWorkflows(projectDir) {
   };
   const resultFiles = [];
   for (const relPath of TARGET_WORKFLOWS) {
-    const absPath = join33(projectDir, relPath);
-    if (!existsSync34(absPath)) {
+    const absPath = join35(projectDir, relPath);
+    if (!existsSync36(absPath)) {
       throw new Error(`Workflow file not found: ${relPath}`);
     }
-    const content = readFileSync31(absPath, "utf-8");
+    const content = readFileSync33(absPath, "utf-8");
     const { newContent, originals } = replaceRunsOn(content, TARGET_LABEL);
     if (originals.length === 0) {
       throw new Error(`No runs-on found in ${relPath}`);
     }
-    writeFileSync28(absPath, newContent, "utf-8");
+    writeFileSync29(absPath, newContent, "utf-8");
     state.files.push({ relativePath: relPath, originals });
     resultFiles.push({ relativePath: relPath, jobCount: originals.length });
   }
-  mkdirSync21(dirname9(statePath), { recursive: true });
-  writeFileSync28(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  mkdirSync22(dirname9(statePath), { recursive: true });
+  writeFileSync29(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
   return { alreadySwitched: false, files: resultFiles };
 }
 async function restoreWorkflows(projectDir) {
-  const statePath = join33(projectDir, STATE_FILE);
-  if (!existsSync34(statePath)) {
+  const statePath = join35(projectDir, STATE_FILE);
+  if (!existsSync36(statePath)) {
     return { nothingToRestore: true, files: [] };
   }
   const state = JSON.parse(
-    readFileSync31(statePath, "utf-8")
+    readFileSync33(statePath, "utf-8")
   );
   const resultFiles = [];
   for (const fileState of state.files) {
-    const absPath = join33(projectDir, fileState.relativePath);
-    if (!existsSync34(absPath)) {
+    const absPath = join35(projectDir, fileState.relativePath);
+    if (!existsSync36(absPath)) {
       throw new Error(`Workflow file not found: ${fileState.relativePath}`);
     }
-    const content = readFileSync31(absPath, "utf-8");
+    const content = readFileSync33(absPath, "utf-8");
     const newContent = restoreRunsOn(content, fileState.originals);
-    writeFileSync28(absPath, newContent, "utf-8");
+    writeFileSync29(absPath, newContent, "utf-8");
     resultFiles.push({
       relativePath: fileState.relativePath,
       jobCount: fileState.originals.length
@@ -13150,12 +13457,38 @@ async function restoreWorkflows(projectDir) {
 
 // src/cli/commands/runner-cmd.ts
 var runnerCommand = new Command23("runner").description("Manage self-hosted GitHub Actions runners");
+function resolveProjectName(projectDir) {
+  const projectsDir = join36(projectDir, ".beastmode", "projects");
+  if (existsSync37(projectsDir)) {
+    try {
+      for (const entry of readdirSync12(projectsDir)) {
+        if (!entry.endsWith(".json")) continue;
+        const file = join36(projectsDir, entry);
+        try {
+          const raw = readFileSync34(file, "utf-8");
+          const data = JSON.parse(raw);
+          if (typeof data.path === "string" && resolve20(data.path) === resolve20(projectDir) && typeof data.name === "string" && data.name.length > 0) {
+            return data.name;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return basename6(resolve20(projectDir));
+}
 async function runnerSetupAction(opts) {
   if (opts.service !== void 0 && !opts.native) {
     throw new Error(
       "--service requires --native. The Docker runner always runs as a container service."
     );
   }
+  if (opts.buildImage && opts.native) {
+    throw new Error(
+      "Custom image builds require Docker mode. --build-image is incompatible with --native."
+    );
+  }
   if (opts.native) {
     await nativeRunnerSetup(opts);
     return;
@@ -13196,6 +13529,46 @@ async function runnerSetupAction(opts) {
   });
   setupStep("Waiting for runner to appear online on GitHub (timeout 60s)...");
   await pollUntilOnline(ghConfig, opts.name, 6e4);
+  if (opts.buildImage) {
+    try {
+      const projectDir = resolve20(opts.projectDir ?? process.cwd());
+      const stack = detectRunnerStack(projectDir);
+      const lockfiles = findLockfiles(projectDir, stack.name);
+      if (lockfiles.length === 0) {
+        info(
+          `No lockfiles detected for stack "${stack.name}" \u2014 skipping custom image build.`
+        );
+      } else {
+        setupStep(
+          `Building custom runner image (stack: ${stack.name}, lockfiles: ${lockfiles.join(", ")})...`
+        );
+        const projectName = resolveProjectName(projectDir);
+        const result = buildRunnerImage({
+          projectDir,
+          projectName,
+          stack,
+          lockfiles
+        });
+        setupStep(
+          `Restarting container '${opts.name}' on custom image ${result.imageTag}...`
+        );
+        await removeContainer(opts.name);
+        await startRunnerContainer({
+          name: opts.name,
+          repoUrl,
+          token: regToken,
+          labels: ["self-hosted", opts.label],
+          image: result.imageTag
+        });
+        await pollUntilOnline(ghConfig, opts.name, 6e4);
+        success(`Runner now using custom image: ${result.imageTag}`);
+      }
+    } catch (err) {
+      warn(
+        `Custom image build failed \u2014 runner staying on base image. Reason: ${err?.message ? String(err.message) : String(err)}`
+      );
+    }
+  }
   setupStep("Adding runner to docker-compose...");
   await composeUpRunner();
   await writeRunnerMeta(".beastmode", {
@@ -13233,6 +13606,14 @@ runnerCommand.command("setup").description("Set up a self-hosted GitHub Actions
 ).option(
   "--service",
   "Install as background service (systemd/launchd). Requires --native."
+).option(
+  "--build-image",
+  "Build a custom runner image with pre-installed project dependencies",
+  false
+).option(
+  "--project-dir <path>",
+  "Project root used to detect stack for --build-image",
+  process.cwd()
 ).action(async (opts) => {
   try {
     await runnerSetupAction(opts);
@@ -13418,31 +13799,79 @@ runnerCommand.command("restore-workflows").description("Restore workflows to ori
     process.exitCode = 1;
   }
 });
+async function runnerBuildImageAction(opts) {
+  const projectDir = resolve20(opts.projectDir);
+  if (!existsSync37(projectDir)) {
+    throw new Error(`Project directory not found: ${projectDir}`);
+  }
+  const stack = detectRunnerStack(projectDir);
+  const lockfiles = findLockfiles(projectDir, stack.name);
+  if (lockfiles.length === 0) {
+    info(
+      `No lockfiles detected for stack "${stack.name}" \u2014 skipping dependency layer.`
+    );
+    return;
+  }
+  const projectName = resolveProjectName(projectDir);
+  const result = buildRunnerImage({
+    projectDir,
+    projectName,
+    stack,
+    lockfiles,
+    force: opts.force,
+    dryRun: opts.dryRun
+  });
+  if (opts.dryRun) {
+    header("Dry run: Dockerfile");
+    process.stdout.write(result.dockerfile);
+    info(`Image would be tagged: ${result.imageTag}`);
+    return;
+  }
+  success(
+    `Stack detected: ${stack.name} (lockfiles: ${lockfiles.join(", ")})`
+  );
+  if (result.built) {
+    success(`Runner image built: ${result.imageTag}`);
+  } else {
+    info(`Runner image already up-to-date: ${result.imageTag}`);
+  }
+  info(`Lockfile hash: ${result.lockfileHash}`);
+}
+runnerCommand.command("build-image").description(
+  "Build a custom runner image with pre-installed project dependencies"
+).option("--project-dir <path>", "Project root directory", process.cwd()).option("--force", "Rebuild even if lockfiles unchanged", false).option("--dry-run", "Print Dockerfile without building", false).action(async (opts) => {
+  try {
+    await runnerBuildImageAction(opts);
+  } catch (err) {
+    error(err?.message ? String(err.message) : String(err));
+    process.exitCode = 1;
+  }
+});
 
 // src/cli/commands/project-cmd.ts
 init_engine();
 import { Command as Command24 } from "commander";
-import { existsSync as existsSync35, mkdirSync as mkdirSync22, writeFileSync as writeFileSync29, readFileSync as readFileSync32, readdirSync as readdirSync12, renameSync as renameSync2 } from "fs";
-import { join as join34, resolve as resolve21, basename as basename6 } from "path";
-import { execSync as execSync12 } from "child_process";
+import { existsSync as existsSync38, mkdirSync as mkdirSync23, writeFileSync as writeFileSync30, readFileSync as readFileSync35, readdirSync as readdirSync13, renameSync as renameSync2 } from "fs";
+import { join as join37, resolve as resolve21, basename as basename7 } from "path";
+import { execSync as execSync13 } from "child_process";
 var DEFAULT_MAX_PROJECTS = 5;
 var MIN_DISK_WARNING_GB = 10;
 function countExistingProjects(factoryDir) {
-  const projectsDir = join34(factoryDir, ".beastmode", "projects");
-  if (!existsSync35(projectsDir)) return 0;
+  const projectsDir = join37(factoryDir, ".beastmode", "projects");
+  if (!existsSync38(projectsDir)) return 0;
   let count = 0;
-  for (const entry of readdirSync12(projectsDir)) {
+  for (const entry of readdirSync13(projectsDir)) {
     if (entry.startsWith(".")) continue;
-    if (existsSync35(join34(projectsDir, entry, "project.json"))) count++;
+    if (existsSync38(join37(projectsDir, entry, "project.json"))) count++;
     else if (entry.endsWith(".json")) count++;
   }
   return count;
 }
 function getMaxProjects(factoryDir) {
-  const configPath = join34(factoryDir, ".beastmode", "config.json");
-  if (existsSync35(configPath)) {
+  const configPath = join37(factoryDir, ".beastmode", "config.json");
+  if (existsSync38(configPath)) {
     try {
-      const config = JSON.parse(readFileSync32(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync35(configPath, "utf-8"));
       if (typeof config.max_projects === "number") return config.max_projects;
     } catch {
     }
@@ -13451,7 +13880,7 @@ function getMaxProjects(factoryDir) {
 }
 function getFreeDiskGB() {
   try {
-    const output = execSync12("df -k / | tail -1", { encoding: "utf-8", timeout: 3e3 });
+    const output = execSync13("df -k / | tail -1", { encoding: "utf-8", timeout: 3e3 });
     const parts = output.trim().split(/\s+/);
     const availKB = parseInt(parts[3], 10);
     if (!isNaN(availKB)) return Math.floor(availKB / (1024 * 1024));
@@ -13461,10 +13890,10 @@ function getFreeDiskGB() {
 }
 function projectAddAction(factoryDir, projectPath, opts) {
   const resolvedPath = resolve21(projectPath);
-  if (!existsSync35(resolvedPath)) throw new Error(`Directory not found: ${resolvedPath}`);
-  const projectName = opts.name || basename6(resolvedPath);
-  const projectsDir = join34(factoryDir, ".beastmode", "projects", projectName);
-  if (existsSync35(projectsDir)) throw new Error(`Project already exists: ${projectName}`);
+  if (!existsSync38(resolvedPath)) throw new Error(`Directory not found: ${resolvedPath}`);
+  const projectName = opts.name || basename7(resolvedPath);
+  const projectsDir = join37(factoryDir, ".beastmode", "projects", projectName);
+  if (existsSync38(projectsDir)) throw new Error(`Project already exists: ${projectName}`);
   const currentCount = countExistingProjects(factoryDir);
   const maxProjects = getMaxProjects(factoryDir);
   if (currentCount >= maxProjects) {
@@ -13478,22 +13907,22 @@ function projectAddAction(factoryDir, projectPath, opts) {
       `Warning: only ${freeGB}GB free disk space. Each project with worktrees may use 1-2GB. Consider freeing space.`
     );
   }
-  mkdirSync22(projectsDir, { recursive: true });
+  mkdirSync23(projectsDir, { recursive: true });
   let stack = {};
   try {
     stack = detectStack(resolvedPath);
   } catch {
   }
   let verifyPort = 3001;
-  const allProjectsDir = join34(factoryDir, ".beastmode", "projects");
-  if (existsSync35(allProjectsDir)) {
-    for (const d of readdirSync12(allProjectsDir)) {
+  const allProjectsDir = join37(factoryDir, ".beastmode", "projects");
+  if (existsSync38(allProjectsDir)) {
+    for (const d of readdirSync13(allProjectsDir)) {
       if (d.startsWith(".")) continue;
       if (d === projectName) continue;
-      const pf = join34(allProjectsDir, d, "project.json");
-      if (existsSync35(pf)) {
+      const pf = join37(allProjectsDir, d, "project.json");
+      if (existsSync38(pf)) {
         try {
-          const pc = JSON.parse(readFileSync32(pf, "utf-8"));
+          const pc = JSON.parse(readFileSync35(pf, "utf-8"));
           const port = pc?.deploy?.verify_port;
           if (typeof port === "number" && port >= verifyPort) verifyPort = port + 1;
         } catch {
@@ -13519,14 +13948,14 @@ function projectAddAction(factoryDir, projectPath, opts) {
     slots: { max: null },
     registered_at: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync29(join34(projectsDir, "project.json"), JSON.stringify(projectConfig, null, 2) + "\n");
-  writeFileSync29(join34(projectsDir, "extensions.json"), JSON.stringify({
+  writeFileSync30(join37(projectsDir, "project.json"), JSON.stringify(projectConfig, null, 2) + "\n");
+  writeFileSync30(join37(projectsDir, "extensions.json"), JSON.stringify({
     plugins: { add: [], remove: [] },
     mcps: { add: {}, remove: [] },
     skills: { add: [], remove: [] }
   }, null, 2) + "\n");
-  const runsDir = join34(factoryDir, "runs", projectName);
-  if (!existsSync35(runsDir)) mkdirSync22(runsDir, { recursive: true });
+  const runsDir = join37(factoryDir, "runs", projectName);
+  if (!existsSync38(runsDir)) mkdirSync23(runsDir, { recursive: true });
   if (!opts.boardId) {
     void (async () => {
       try {
@@ -13566,28 +13995,28 @@ function projectAddAction(factoryDir, projectPath, opts) {
   }
 }
 function projectListAction(factoryDir) {
-  const projectsDir = join34(factoryDir, ".beastmode", "projects");
-  if (!existsSync35(projectsDir)) return [];
-  return readdirSync12(projectsDir).filter((d) => !d.startsWith(".") && existsSync35(join34(projectsDir, d, "project.json"))).map((d) => {
+  const projectsDir = join37(factoryDir, ".beastmode", "projects");
+  if (!existsSync38(projectsDir)) return [];
+  return readdirSync13(projectsDir).filter((d) => !d.startsWith(".") && existsSync38(join37(projectsDir, d, "project.json"))).map((d) => {
     try {
-      return JSON.parse(readFileSync32(join34(projectsDir, d, "project.json"), "utf-8"));
+      return JSON.parse(readFileSync35(join37(projectsDir, d, "project.json"), "utf-8"));
     } catch {
       return null;
     }
   }).filter(Boolean);
 }
 function projectRemoveAction(factoryDir, name) {
-  const projectDir = join34(factoryDir, ".beastmode", "projects", name);
-  if (!existsSync35(projectDir)) throw new Error(`Project not found: ${name}`);
-  const archiveDir = join34(factoryDir, ".beastmode", "projects", ".archived", name);
-  mkdirSync22(join34(factoryDir, ".beastmode", "projects", ".archived"), { recursive: true });
+  const projectDir = join37(factoryDir, ".beastmode", "projects", name);
+  if (!existsSync38(projectDir)) throw new Error(`Project not found: ${name}`);
+  const archiveDir = join37(factoryDir, ".beastmode", "projects", ".archived", name);
+  mkdirSync23(join37(factoryDir, ".beastmode", "projects", ".archived"), { recursive: true });
   renameSync2(projectDir, archiveDir);
 }
 var projectCommand = new Command24("project").description("Manage projects in this factory");
 projectCommand.command("add <path>").description("Register a project").option("--name <name>", "Override project name").option("--board-id <id>", "Link to existing board ID").action((path, opts) => {
   const factoryDir = resolve21(".");
   projectAddAction(factoryDir, path, opts);
-  console.log(`Project registered: ${opts.name || basename6(resolve21(path))}`);
+  console.log(`Project registered: ${opts.name || basename7(resolve21(path))}`);
 });
 projectCommand.command("list").description("List registered projects").action(() => {
   const projects = projectListAction(resolve21("."));