@beastmode-develeap/beastmode 0.1.146 → 0.1.148

package/dist/index.js

@@ -3366,7 +3366,7 @@ async function createEpicsOnBoard(factoryDir, productName, boardUrl = "http://12
     });
     let itemId = "";
     try {
-      const itemResult = await new Promise((resolve20, reject) => {
+      const itemResult = await new Promise((resolve21, reject) => {
         const url = new URL("/api/items", boardUrl);
         const req = http4.default.request(url, {
           method: "POST",
@@ -3378,7 +3378,7 @@ async function createEpicsOnBoard(factoryDir, productName, boardUrl = "http://12
           });
           res.on("end", () => {
             try {
-              resolve20(JSON.parse(data));
+              resolve21(JSON.parse(data));
             } catch {
               reject(new Error(data));
             }
@@ -3394,13 +3394,13 @@ async function createEpicsOnBoard(factoryDir, productName, boardUrl = "http://12
     if (itemId) {
       createdIds.push(itemId);
       const updatePayload = JSON.stringify({ body: detailContent, creator_name: "beastmode-inception" });
-      await new Promise((resolve20) => {
+      await new Promise((resolve21) => {
         const url = new URL(`/api/items/${itemId}/updates`, boardUrl);
         const req = http4.default.request(url, {
           method: "POST",
           headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(updatePayload).toString() }
-        }, () => resolve20());
-        req.on("error", () => resolve20());
+        }, () => resolve21());
+        req.on("error", () => resolve21());
         req.end(updatePayload);
       });
     }
@@ -3620,19 +3620,19 @@ function getRecentTokenUsage() {
   return recentTokenUsage.slice();
 }
 function boardGet(path, boardUrl) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const url = new URL(path, boardUrl);
     const req = http.request(url, { method: "GET", timeout: 5e3 }, (res) => {
       let data = "";
       res.on("data", (chunk) => {
         data += chunk.toString();
       });
-      res.on("end", () => resolve20(data));
+      res.on("end", () => resolve21(data));
     });
-    req.on("error", (err) => resolve20(`Board API error: ${err.message}`));
+    req.on("error", (err) => resolve21(`Board API error: ${err.message}`));
     req.on("timeout", () => {
       req.destroy();
-      resolve20("Board API timeout");
+      resolve21("Board API timeout");
     });
     req.end();
   });
@@ -4343,7 +4343,7 @@ You are currently scoped to project "${scope}". Focus your answers on this proje
   async function runViaCli(session, content, scope = "factory") {
     session.busy = true;
     try {
-      const { spawn } = await import("child_process");
+      const { spawn: spawn3 } = await import("child_process");
       let boardContext = "";
       try {
         const boardUrl = getBoardUrl(session.factoryPath);
@@ -4435,7 +4435,7 @@ Respond concisely. Continue the conversation naturally.`;
         spawnCmd = "claude";
         spawnArgs = claudeArgs;
       }
-      const child = spawn(spawnCmd, spawnArgs, {
+      const child = spawn3(spawnCmd, spawnArgs, {
         cwd: session.factoryPath,
         env: {
           ...process.env,
@@ -4582,7 +4582,7 @@ function getBoardUrl2(factoryDir) {
   return "http://127.0.0.1:8080";
 }
 function proxyToBoard(boardUrl, method, path, body, query) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     const url = new URL(path, boardUrl);
     if (query) {
       for (const [k, v] of Object.entries(query)) {
@@ -4614,7 +4614,7 @@ function proxyToBoard(boardUrl, method, path, body, query) {
         if (statusCode >= 400) {
           reject(new HttpError(statusCode, parsed));
         } else {
-          resolve20(parsed);
+          resolve21(parsed);
         }
       });
     });
@@ -4624,7 +4624,7 @@ function proxyToBoard(boardUrl, method, path, body, query) {
   });
 }
 function proxyBinaryToBoard(boardUrl, path, query) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     const url = new URL(path, boardUrl);
     if (query) {
       for (const [k, v] of Object.entries(query)) {
@@ -4653,7 +4653,7 @@ function proxyBinaryToBoard(boardUrl, path, query) {
           const cd = res.headers["content-disposition"] || "";
           const match = /filename="([^"]+)"/.exec(cd);
           const filename = match ? match[1] : void 0;
-          resolve20(new BinaryResponse(body, contentType, filename));
+          resolve21(new BinaryResponse(body, contentType, filename));
         });
       }
     );
@@ -4665,7 +4665,7 @@ function proxyBinaryToBoard(boardUrl, path, query) {
   });
 }
 function transparentProxyToBoard(boardUrl, method, path, body, query) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     const url = new URL(path, boardUrl);
     if (query) {
       for (const [k, v] of Object.entries(query)) {
@@ -4688,7 +4688,7 @@ function transparentProxyToBoard(boardUrl, method, path, body, query) {
         const chunks = [];
         res.on("data", (chunk) => chunks.push(chunk));
         res.on("end", () => {
-          resolve20({
+          resolve21({
             statusCode: res.statusCode || 502,
             contentType: res.headers["content-type"] || "application/json",
             body: Buffer.concat(chunks)
@@ -6420,17 +6420,17 @@ function resolveStaticDir() {
   );
 }
 function parseBody(req) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw) {
-        resolve20({});
+        resolve21({});
         return;
       }
       try {
-        resolve20(JSON.parse(raw));
+        resolve21(JSON.parse(raw));
       } catch {
         reject(new Error("Invalid JSON body"));
       }
@@ -6492,11 +6492,11 @@ function clearSessionCookie(res) {
 }
 async function findAvailablePort(start) {
   for (let port = start; port < start + 100; port++) {
-    const available = await new Promise((resolve20) => {
+    const available = await new Promise((resolve21) => {
       const testServer = createServer();
-      testServer.once("error", () => resolve20(false));
+      testServer.once("error", () => resolve21(false));
       testServer.listen(port, "127.0.0.1", () => {
-        testServer.close(() => resolve20(true));
+        testServer.close(() => resolve21(true));
       });
     });
     if (available) return port;
@@ -6817,23 +6817,23 @@ async function startServer(options = {}) {
     if (chatManager) {
       chatManager.shutdown();
     }
-    return new Promise((resolve20) => {
+    return new Promise((resolve21) => {
       server.close(() => {
         if (shutdownResolve) shutdownResolve();
-        resolve20();
+        resolve21();
       });
       setTimeout(() => {
         if (shutdownResolve) shutdownResolve();
-        resolve20();
+        resolve21();
       }, 2e3);
     });
   }
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     server.once("error", reject);
     const host = options.host || "127.0.0.1";
     server.listen(port, host, () => {
       resetInactivityTimer();
-      resolve20({
+      resolve21({
         server,
         port,
         url: `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`,
@@ -8425,12 +8425,12 @@ async function runInit(name, opts) {
     } catch {
       info(`Open ${uiServer.url} in your browser to continue.`);
     }
-    await new Promise((resolve20) => {
-      uiServer.server.on("close", resolve20);
+    await new Promise((resolve21) => {
+      uiServer.server.on("close", resolve21);
       process.on("SIGINT", async () => {
         info("\nShutting down wizard server...");
         await uiServer.shutdown();
-        resolve20();
+        resolve21();
       });
     });
     return;
@@ -8447,8 +8447,8 @@ async function runInit(name, opts) {
     throw new Error(`Factory already exists at ./${factoryName}. Use 'beastmode config' to modify.`);
   }
   if (opts.from) {
-    const { readFileSync: readFileSync31 } = await import("fs");
-    const templateContent = readFileSync31(resolve6(opts.from), "utf-8");
+    const { readFileSync: readFileSync32 } = await import("fs");
+    const templateContent = readFileSync32(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}`);
@@ -9660,16 +9660,16 @@ function tryExec(cmd, timeout = 8e3) {
   }
 }
 function httpGet(url, timeoutMs = 5e3) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const lib = url.startsWith("https") ? https : http3;
     const req = lib.get(url, { timeout: timeoutMs }, (res) => {
       res.resume();
-      resolve20(res.statusCode ?? null);
+      resolve21(res.statusCode ?? null);
     });
-    req.on("error", () => resolve20(null));
+    req.on("error", () => resolve21(null));
     req.on("timeout", () => {
       req.destroy();
-      resolve20(null);
+      resolve21(null);
     });
   });
 }
@@ -9717,7 +9717,7 @@ async function checkClaudeAuth(key) {
     max_tokens: 1,
     messages: [{ role: "user", content: "hi" }]
   });
-  const statusCode = await new Promise((resolve20) => {
+  const statusCode = await new Promise((resolve21) => {
     const req = https.request(
       {
         hostname: "api.anthropic.com",
@@ -9733,13 +9733,13 @@ async function checkClaudeAuth(key) {
       },
       (res) => {
         res.resume();
-        resolve20(res.statusCode ?? null);
+        resolve21(res.statusCode ?? null);
       }
     );
-    req.on("error", () => resolve20(null));
+    req.on("error", () => resolve21(null));
     req.on("timeout", () => {
       req.destroy();
-      resolve20(null);
+      resolve21(null);
     });
     req.write(payload);
     req.end();
@@ -11401,8 +11401,8 @@ async function runMigrate(opts) {
   }
   let worktreeOutput = "";
   try {
-    const { execSync: execSync10 } = await import("child_process");
-    worktreeOutput = execSync10("git worktree list", {
+    const { execSync: execSync11 } = await import("child_process");
+    worktreeOutput = execSync11("git worktree list", {
       cwd,
       encoding: "utf-8",
       timeout: 5e3
@@ -11575,14 +11575,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: execSync10 } = await import("child_process");
+  const { execSync: execSync11 } = await import("child_process");
   let pythonAvailable = false;
   try {
-    execSync10("python --version", { timeout: 5e3, encoding: "utf-8" });
+    execSync11("python --version", { timeout: 5e3, encoding: "utf-8" });
     pythonAvailable = true;
   } catch {
     try {
-      execSync10("python3 --version", { timeout: 5e3, encoding: "utf-8" });
+      execSync11("python3 --version", { timeout: 5e3, encoding: "utf-8" });
       pythonAvailable = true;
     } catch {
     }
@@ -11610,8 +11610,8 @@ async function runPipeline(projectName, opts) {
   }
   const cmd = buildDaemonCommand(null, daemonConfigPath);
   info(`Spawning daemon: ${cmd.command} ${cmd.args.join(" ")}`);
-  const { spawn } = await import("child_process");
-  const child = spawn(cmd.command, cmd.args, {
+  const { spawn: spawn3 } = await import("child_process");
+  const child = spawn3(cmd.command, cmd.args, {
     stdio: "inherit",
     cwd: factoryDir,
     env: {
@@ -11735,16 +11735,16 @@ async function runDaemon(opts) {
     console.log(JSON.stringify(daemonConfig, null, 2));
     return;
   }
-  const { execSync: execSync10 } = await import("child_process");
+  const { execSync: execSync11 } = await import("child_process");
   let pythonCmd = "python";
   let pythonAvailable = false;
   try {
-    execSync10("python --version", { timeout: 5e3, encoding: "utf-8" });
+    execSync11("python --version", { timeout: 5e3, encoding: "utf-8" });
     pythonAvailable = true;
     pythonCmd = "python";
   } catch {
     try {
-      execSync10("python3 --version", { timeout: 5e3, encoding: "utf-8" });
+      execSync11("python3 --version", { timeout: 5e3, encoding: "utf-8" });
       pythonAvailable = true;
       pythonCmd = "python3";
     } catch {
@@ -11762,8 +11762,8 @@ async function runDaemon(opts) {
   info(`Starting daemon: ${pythonCmd} ${cmd.args.join(" ")}`);
   console.log();
   const pidFile = join28(bmDir, "daemon.pid");
-  const { spawn } = await import("child_process");
-  const child = spawn(pythonCmd, cmd.args, {
+  const { spawn: spawn3 } = await import("child_process");
+  const child = spawn3(pythonCmd, cmd.args, {
     stdio: "inherit",
     cwd: factoryDir,
     env: {
@@ -11783,8 +11783,8 @@ async function runDaemon(opts) {
   const exitCode = await new Promise((resolvePromise) => {
     child.on("exit", (code) => {
       try {
-        const { unlinkSync: unlinkSync5 } = __require("fs");
-        unlinkSync5(pidFile);
+        const { unlinkSync: unlinkSync6 } = __require("fs");
+        unlinkSync6(pidFile);
       } catch {
       }
       resolvePromise(code ?? 1);
@@ -12422,9 +12422,422 @@ var updateCommand = new Command22("update").description("Pull latest BeastMode i
 // src/cli/commands/runner-cmd.ts
 init_display();
 import { Command as Command23 } from "commander";
+import { spawn as spawn2 } from "child_process";
+import { resolve as resolve20 } from "path";
+
+// src/cli/github-runners.ts
+var GitHubRunnerApiError = class extends Error {
+  status;
+  endpoint;
+  constructor(status, endpoint, message) {
+    super(message);
+    this.name = "GitHubRunnerApiError";
+    this.status = status;
+    this.endpoint = endpoint;
+  }
+};
+var GITHUB_API_BASE = "https://api.github.com";
+function buildHeaders(token) {
+  return {
+    Authorization: `token ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "beastmode-cli"
+  };
+}
+function runnersUrl(owner, repo) {
+  return `${GITHUB_API_BASE}/repos/${owner}/${repo}/actions/runners`;
+}
+async function githubFetch(url, token, method = "GET", body) {
+  const resp = await fetch(url, {
+    method,
+    headers: buildHeaders(token),
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    const endpoint = url.replace(GITHUB_API_BASE, "");
+    throw new GitHubRunnerApiError(
+      resp.status,
+      endpoint,
+      `GitHub API ${method} ${endpoint} \u2192 ${resp.status}: ${text}`
+    );
+  }
+  if (resp.status === 204) return void 0;
+  return await resp.json();
+}
+async function createRegistrationToken(config) {
+  const url = `${runnersUrl(config.owner, config.repo)}/registration-token`;
+  return githubFetch(url, config.token, "POST");
+}
+async function listRunners(config) {
+  const url = runnersUrl(config.owner, config.repo);
+  return githubFetch(url, config.token);
+}
+function resolveGitHubConfig() {
+  const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+  if (!token) {
+    throw new Error(
+      "GITHUB_TOKEN (or GH_TOKEN) not set. Add it to .env or export it."
+    );
+  }
+  const repo = process.env.PROJECT_REPO;
+  if (!repo || !repo.includes("/")) {
+    throw new Error(
+      "PROJECT_REPO not set or invalid (expected 'owner/repo'). Add it to .env."
+    );
+  }
+  const [owner, repoName] = repo.split("/", 2);
+  return { owner, repo: repoName, token };
+}
+
+// src/cli/runner-helpers.ts
+import { execSync as execSync10, spawn, spawnSync as spawnSync5 } from "child_process";
+import { promises as fs } from "fs";
+init_display();
+function resolveRepoSlug() {
+  let rawUrl;
+  try {
+    rawUrl = execSync10("git remote get-url origin", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    throw new Error(
+      "Could not determine repo from git remote. Use --repo owner/repo."
+    );
+  }
+  const match = rawUrl.match(/github\.com[:/](.+?)(?:\.git)?$/) || rawUrl.match(/github\.com\/(.+?)(?:\.git)?$/);
+  if (!match) {
+    throw new Error(
+      `Could not parse GitHub repo from remote URL: ${rawUrl}`
+    );
+  }
+  return match[1];
+}
+async function pullImageIfNeeded(image) {
+  const inspect = spawnSync5("docker", ["image", "inspect", image], {
+    stdio: ["ignore", "ignore", "ignore"]
+  });
+  if (inspect.error && inspect.error.code === "ENOENT") {
+    throw new Error(
+      "Docker is required for the default runner. Install Docker, or use --native."
+    );
+  }
+  if (inspect.status === 0) return;
+  await new Promise((resolve21, reject) => {
+    const child = spawn("docker", ["pull", image], {
+      stdio: ["ignore", "inherit", "inherit"]
+    });
+    child.on("error", (err) => {
+      const e = err;
+      if (e.code === "ENOENT") {
+        reject(
+          new Error(
+            "Docker is required for the default runner. Install Docker, or use --native."
+          )
+        );
+      } else {
+        reject(err);
+      }
+    });
+    child.on("exit", (code) => {
+      if (code === 0) resolve21();
+      else reject(new Error(`docker pull ${image} exited with code ${code}`));
+    });
+  });
+}
+async function findContainerByName(name) {
+  const result = spawnSync5(
+    "docker",
+    ["inspect", name, "--format", "{{.State.Status}}"],
+    { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }
+  );
+  if (result.error && result.error.code === "ENOENT") {
+    throw new Error(
+      "Docker is required for the default runner. Install Docker, or use --native."
+    );
+  }
+  if (result.status !== 0) return null;
+  const status = (result.stdout || "").trim();
+  if (!status) return null;
+  return { name, status };
+}
+function containerIsHealthy(infoArg) {
+  return infoArg.status === "running";
+}
+async function removeContainer(name) {
+  const result = spawnSync5("docker", ["rm", "-f", name], {
+    stdio: ["ignore", "ignore", "pipe"],
+    encoding: "utf-8"
+  });
+  if (result.error && result.error.code === "ENOENT") {
+    throw new Error(
+      "Docker is required for the default runner. Install Docker, or use --native."
+    );
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      `docker rm -f ${name} failed (exit ${result.status}): ${result.stderr || ""}`
+    );
+  }
+}
+async function startRunnerContainer(opts) {
+  const labelStr = opts.labels.join(",");
+  const args = [
+    "run",
+    "-d",
+    "--restart=unless-stopped",
+    "--name",
+    opts.name,
+    "-e",
+    `REPO_URL=${opts.repoUrl}`,
+    "-e",
+    `RUNNER_TOKEN=${opts.token}`,
+    "-e",
+    `LABELS=${labelStr}`,
+    "-e",
+    `RUNNER_NAME=${opts.name}`,
+    "-v",
+    "/var/run/docker.sock:/var/run/docker.sock",
+    "myoung34/github-runner:latest"
+  ];
+  const result = spawnSync5("docker", args, {
+    stdio: ["ignore", "ignore", "pipe"],
+    encoding: "utf-8"
+  });
+  if (result.error && result.error.code === "ENOENT") {
+    throw new Error(
+      "Docker is required for the default runner. Install Docker, or use --native."
+    );
+  }
+  if (result.status !== 0) {
+    const stderr = (result.stderr || "").replace(opts.token, "<REDACTED>");
+    throw new Error(
+      `docker run failed (exit ${result.status}): ${stderr}`
+    );
+  }
+}
+async function writeEnvEntries(entries, envPath = ".env") {
+  let existing = "";
+  try {
+    existing = await fs.readFile(envPath, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const lines = existing === "" ? [] : existing.split("\n");
+  const remainingKeys = new Set(Object.keys(entries));
+  const updated = lines.map((line) => {
+    for (const key of remainingKeys) {
+      if (line.startsWith(`${key}=`)) {
+        remainingKeys.delete(key);
+        return `${key}=${entries[key]}`;
+      }
+    }
+    return line;
+  });
+  for (const key of remainingKeys) {
+    updated.push(`${key}=${entries[key]}`);
+  }
+  let output = updated.join("\n");
+  if (existing !== "" && !existing.endsWith("\n") && !output.endsWith("\n")) {
+    output += "\n";
+  } else if (existing === "" && !output.endsWith("\n")) {
+    output += "\n";
+  }
+  await fs.writeFile(envPath, output, "utf-8");
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function pollUntilOnline(config, name, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const list = await listRunners(config);
+      const runner = list.runners.find((r) => r.name === name);
+      if (runner && runner.status === "online") return;
+    } catch {
+    }
+    if (Date.now() + 3e3 >= deadline) break;
+    await sleep(3e3);
+  }
+  throw new Error(
+    `Runner '${name}' did not appear online within ${Math.floor(
+      timeoutMs / 1e3
+    )}s \u2014 check container logs with: docker logs ${name}`
+  );
+}
+function setupStep(text) {
+  info(text);
+}
+
+// src/cli/workflow-switcher.ts
+import {
+  existsSync as existsSync33,
+  mkdirSync as mkdirSync20,
+  readFileSync as readFileSync31,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync27
+} from "fs";
+import { dirname as dirname8, join as join31 } from "path";
+var TARGET_LABEL = "[self-hosted, beastmode]";
+var TARGET_WORKFLOWS = [
+  ".github/workflows/test.yml",
+  ".github/workflows/dogfood-e2e.yml"
+];
+var STATE_FILE = ".beastmode/runner-workflow-state.json";
+var RUNS_ON_REGEX = /^(\s+runs-on:\s*)(.+)$/;
+function replaceRunsOn(content, targetLabel) {
+  const lines = content.split("\n");
+  const originals = [];
+  const newLines = lines.map((line) => {
+    const match = line.match(RUNS_ON_REGEX);
+    if (match) {
+      originals.push({ line });
+      return `${match[1]}${targetLabel}`;
+    }
+    return line;
+  });
+  return {
+    newContent: newLines.join("\n"),
+    originals
+  };
+}
+function restoreRunsOn(content, originals) {
+  const lines = content.split("\n");
+  let idx = 0;
+  const newLines = lines.map((line) => {
+    const match = line.match(RUNS_ON_REGEX);
+    if (match && idx < originals.length) {
+      const restored = originals[idx].line;
+      idx++;
+      return restored;
+    }
+    return line;
+  });
+  return newLines.join("\n");
+}
+async function switchWorkflows(projectDir) {
+  const statePath = join31(projectDir, STATE_FILE);
+  if (existsSync33(statePath)) {
+    return { alreadySwitched: true, files: [] };
+  }
+  const state = {
+    switched_at: (/* @__PURE__ */ new Date()).toISOString(),
+    target_label: TARGET_LABEL,
+    files: []
+  };
+  const resultFiles = [];
+  for (const relPath of TARGET_WORKFLOWS) {
+    const absPath = join31(projectDir, relPath);
+    if (!existsSync33(absPath)) {
+      throw new Error(`Workflow file not found: ${relPath}`);
+    }
+    const content = readFileSync31(absPath, "utf-8");
+    const { newContent, originals } = replaceRunsOn(content, TARGET_LABEL);
+    if (originals.length === 0) {
+      throw new Error(`No runs-on found in ${relPath}`);
+    }
+    writeFileSync27(absPath, newContent, "utf-8");
+    state.files.push({ relativePath: relPath, originals });
+    resultFiles.push({ relativePath: relPath, jobCount: originals.length });
+  }
+  mkdirSync20(dirname8(statePath), { recursive: true });
+  writeFileSync27(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  return { alreadySwitched: false, files: resultFiles };
+}
+async function restoreWorkflows(projectDir) {
+  const statePath = join31(projectDir, STATE_FILE);
+  if (!existsSync33(statePath)) {
+    return { nothingToRestore: true, files: [] };
+  }
+  const state = JSON.parse(
+    readFileSync31(statePath, "utf-8")
+  );
+  const resultFiles = [];
+  for (const fileState of state.files) {
+    const absPath = join31(projectDir, fileState.relativePath);
+    if (!existsSync33(absPath)) {
+      throw new Error(`Workflow file not found: ${fileState.relativePath}`);
+    }
+    const content = readFileSync31(absPath, "utf-8");
+    const newContent = restoreRunsOn(content, fileState.originals);
+    writeFileSync27(absPath, newContent, "utf-8");
+    resultFiles.push({
+      relativePath: fileState.relativePath,
+      jobCount: fileState.originals.length
+    });
+  }
+  unlinkSync5(statePath);
+  return { nothingToRestore: false, files: resultFiles };
+}
+
+// src/cli/commands/runner-cmd.ts
 var runnerCommand = new Command23("runner").description("Manage self-hosted GitHub Actions runners");
-runnerCommand.command("setup").description("Set up a self-hosted GitHub Actions runner").option("--native", "Use native install instead of Docker").action(() => {
-  warn("runner setup is not implemented yet (Story 2)");
+async function runnerSetupAction(opts) {
+  if (opts.native) {
+    warn("--native is not implemented yet (Story 5)");
+    return;
+  }
+  const ghConfig = resolveGitHubConfig();
+  const repoSlug = opts.repo ?? resolveRepoSlug();
+  setupStep("Generating registration token via GitHub API...");
+  if (opts.dryRun) {
+    info(`[dry-run] Would start container '${opts.name}' for repo ${repoSlug}`);
+    return;
+  }
+  const { token: regToken } = await createRegistrationToken(ghConfig);
+  setupStep("Pulling myoung34/github-runner:latest...");
+  await pullImageIfNeeded("myoung34/github-runner:latest");
+  const existing = await findContainerByName(opts.name);
+  if (existing) {
+    if (containerIsHealthy(existing)) {
+      success(`Runner container '${opts.name}' already running \u2014 reusing.`);
+      return;
+    }
+    setupStep(
+      `Container '${opts.name}' exists but is dead \u2014 removing and recreating...`
+    );
+    await removeContainer(opts.name);
+  }
+  const repoUrl = `https://github.com/${ghConfig.owner}/${ghConfig.repo}`;
+  setupStep("Starting runner container...");
+  await startRunnerContainer({
+    name: opts.name,
+    repoUrl,
+    token: regToken,
+    labels: ["self-hosted", opts.label]
+  });
+  await writeEnvEntries({
+    RUNNER_REPO_URL: repoUrl,
+    RUNNER_TOKEN: regToken,
+    RUNNER_NAME: opts.name
+  });
+  setupStep("Waiting for runner to appear online on GitHub (timeout 60s)...");
+  await pollUntilOnline(ghConfig, opts.name, 6e4);
+  setupStep("Adding runner to docker-compose...");
+  await composeUpRunner();
+  success(`Runner '${opts.name}' registered and online.`);
+}
+async function composeUpRunner() {
+  await new Promise((resolve21, reject) => {
+    const child = spawn2(
+      "docker",
+      ["compose", "--profile", "runner", "up", "-d", "runner"],
+      { stdio: ["ignore", "inherit", "inherit"] }
+    );
+    child.on("error", (err) => reject(err));
+    child.on("exit", (code) => {
+      if (code === 0) resolve21();
+      else
+        reject(
+          new Error(
+            `docker compose --profile runner up -d runner exited with code ${code}`
+          )
+        );
+    });
+  });
+}
+runnerCommand.command("setup").description("Set up a self-hosted GitHub Actions runner").option("--repo <owner/repo>", "GitHub repo for runner registration").option("--name <name>", "Container + runner name", "beastmode-runner").option("--label <label>", "Additional runner label", "beastmode").option("--dry-run", "Print what would happen without mutating state").option("--native", "Use native install instead of Docker").action(async (opts) => {
+  await runnerSetupAction(opts);
 });
 runnerCommand.command("status").description("Show runner status (container + GitHub registration)").action(() => {
   warn("runner status is not implemented yet (Story 3)");
@@ -12432,11 +12845,41 @@ runnerCommand.command("status").description("Show runner status (container + Git
 runnerCommand.command("remove").description("Remove the runner (container + GitHub deregistration)").action(() => {
   warn("runner remove is not implemented yet (Story 3)");
 });
-runnerCommand.command("switch-workflows").description("Switch workflow runs-on to self-hosted runner").action(() => {
-  warn("runner switch-workflows is not implemented yet (Story 4)");
+runnerCommand.command("switch-workflows").description("Switch workflow runs-on to self-hosted runner").option("--project-dir <path>", "Project root directory", process.cwd()).action(async (opts) => {
+  const projectDir = resolve20(opts.projectDir);
+  try {
+    const result = await switchWorkflows(projectDir);
+    if (result.alreadySwitched) {
+      info("Workflows already switched \u2014 nothing to do.");
+      return;
+    }
+    header("Switched workflows to self-hosted runner");
+    for (const file of result.files) {
+      success(`${file.relativePath}: ${file.jobCount} job(s) switched`);
+    }
+    info("State saved to .beastmode/runner-workflow-state.json");
+  } catch (err) {
+    error(err.message);
+    process.exitCode = 1;
+  }
 });
-runnerCommand.command("restore-workflows").description("Restore workflows to original runs-on values").action(() => {
-  warn("runner restore-workflows is not implemented yet (Story 4)");
+runnerCommand.command("restore-workflows").description("Restore workflows to original runs-on values").option("--project-dir <path>", "Project root directory", process.cwd()).action(async (opts) => {
+  const projectDir = resolve20(opts.projectDir);
+  try {
+    const result = await restoreWorkflows(projectDir);
+    if (result.nothingToRestore) {
+      info("Nothing to restore.");
+      return;
+    }
+    header("Restored workflows to original runs-on values");
+    for (const file of result.files) {
+      success(`${file.relativePath}: ${file.jobCount} job(s) restored`);
+    }
+    info("State file removed.");
+  } catch (err) {
+    error(err.message);
+    process.exitCode = 1;
+  }
 });
 
 // src/index.ts