@ricsam/r5d-worker 0.0.1 → 0.0.2

package/dist/cjs/main.cjs

@@ -0,0 +1,990 @@
+#!/usr/bin/env bun
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_crypto = require("node:crypto");
+var import_node_os2 = require("node:os");
+var nodePty = __toESM(require("node-pty"), 1);
+const DEFAULT_BASE_URL = "https://r5d.dev";
+const LABEL_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,62}$/;
+const BRANCH_RE = /^[A-Za-z0-9][A-Za-z0-9-]*[A-Za-z0-9]$|^[A-Za-z0-9]$/;
+const DEFAULT_READ_LIMIT = 2e3;
+const MAX_LINE_LENGTH = 2e3;
+const MAX_SYNC_DIFF_BYTES = 5 * 1024 * 1024;
+const activeProcesses = /* @__PURE__ */ new Map();
+const activePtys = /* @__PURE__ */ new Map();
+const branchLocks = /* @__PURE__ */ new Map();
+function defaultConfigPath() {
+  return import_node_path.default.join(import_node_os.default.homedir(), ".config", "r5d", "r5dctl", "config.json");
+}
+function defaultProjectRoot(projectId) {
+  return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "projects", projectId);
+}
+function printHelp() {
+  process.stdout.write(`Usage:
+  r5d-worker start <project-id> --label <label> [--base-url <url>] [--token <token>] [--api-key <key>]
+
+Options:
+  --label <label>       Required unique worker label for this project, e.g. macos or ec2-build
+  --base-url <url>      r5d.dev base URL (default from r5d config, R5D_BASE_URL, or ${DEFAULT_BASE_URL})
+  --token <token>       r5d worker token
+  --api-key <key>       r5d API key
+  --config <path>       Config path (default ~/.config/r5d/r5dctl/config.json)
+  --project-root <dir>  Override checkout root (default ~/.r5d/projects/<project-id>)
+  -h, --help            Show this help
+`);
+}
+function requireValue(value, message) {
+  if (!value) {
+    throw new Error(message);
+  }
+  return value;
+}
+function parseArgs(argv) {
+  const options = {
+    configPath: defaultConfigPath(),
+    help: false
+  };
+  const rest = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+      continue;
+    }
+    const readOption = (name) => {
+      if (arg === name) {
+        index += 1;
+        return requireValue(argv[index], `Missing value for ${name}`);
+      }
+      const prefix = `${name}=`;
+      return arg.startsWith(prefix) ? arg.slice(prefix.length) : void 0;
+    };
+    const baseUrl = readOption("--base-url");
+    if (baseUrl !== void 0) {
+      options.baseUrl = baseUrl;
+      continue;
+    }
+    const token = readOption("--token");
+    if (token !== void 0) {
+      options.token = token;
+      continue;
+    }
+    const apiKey = readOption("--api-key");
+    if (apiKey !== void 0) {
+      options.apiKey = apiKey;
+      continue;
+    }
+    const configPath = readOption("--config");
+    if (configPath !== void 0) {
+      options.configPath = configPath;
+      continue;
+    }
+    const label = readOption("--label");
+    if (label !== void 0) {
+      options.label = label;
+      continue;
+    }
+    const projectRoot = readOption("--project-root");
+    if (projectRoot !== void 0) {
+      options.projectRoot = projectRoot;
+      continue;
+    }
+    rest.push(arg);
+  }
+  if (options.help || rest.length === 0) {
+    return { command: "help", options };
+  }
+  const command = rest[0];
+  if (command !== "start") {
+    throw new Error(`Unknown command: ${command}`);
+  }
+  return {
+    command: "start",
+    projectId: requireValue(rest[1], "Missing project id"),
+    options
+  };
+}
+function readConfig(configPath) {
+  if (!import_node_fs.default.existsSync(configPath)) {
+    return {};
+  }
+  const raw = import_node_fs.default.readFileSync(configPath, "utf8").trim();
+  if (!raw) {
+    return {};
+  }
+  const parsed = JSON.parse(raw);
+  return {
+    baseUrl: typeof parsed.baseUrl === "string" ? parsed.baseUrl : void 0,
+    token: typeof parsed.token === "string" ? parsed.token : void 0,
+    apiKey: typeof parsed.apiKey === "string" ? parsed.apiKey : void 0
+  };
+}
+function normalizeBaseUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+async function readResponseText(response) {
+  try {
+    return await response.text();
+  } catch {
+    return "";
+  }
+}
+async function verifyBinctlAuth(baseUrl, token) {
+  const statusUrl = new URL("/api/binctl/auth/status", baseUrl);
+  let response;
+  try {
+    response = await fetch(statusUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+  } catch (error) {
+    throw new Error(`Could not reach ${baseUrl}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (response.ok) {
+    return;
+  }
+  const responseText = await readResponseText(response);
+  let serverMessage = responseText.trim();
+  try {
+    const parsed = JSON.parse(responseText);
+    if (typeof parsed.error === "string" && parsed.error.trim()) {
+      serverMessage = parsed.error.trim();
+    }
+  } catch {
+  }
+  const detail = serverMessage ? `: ${serverMessage}` : "";
+  throw new Error(
+    `Authentication failed against ${baseUrl} (${response.status})${detail}. Run \`r5dctl auth login --base-url ${baseUrl}\` or pass --token/--api-key for this server.`
+  );
+}
+function resolveCredentials(options, config) {
+  const token = options.token ?? process.env.R5D_WORKER_TOKEN ?? process.env.R5D_TOKEN ?? process.env.BINCTL_TOKEN ?? config.token ?? options.apiKey ?? process.env.R5D_API_KEY ?? process.env.BINCTL_API_KEY ?? config.apiKey;
+  if (!token) {
+    throw new Error("Authentication required. Run `r5dctl auth login` or set R5D_WORKER_TOKEN/R5D_API_KEY.");
+  }
+  return {
+    baseUrl: normalizeBaseUrl(options.baseUrl ?? process.env.R5D_BASE_URL ?? process.env.BINCTL_BASE_URL ?? config.baseUrl ?? DEFAULT_BASE_URL),
+    token
+  };
+}
+function validateLabel(label) {
+  if (!LABEL_RE.test(label)) {
+    throw new Error("Worker label must start with a letter or number and may contain letters, numbers, dots, underscores, and hyphens");
+  }
+}
+function validateBranchName(branchName) {
+  if (branchName !== "main" && !BRANCH_RE.test(branchName)) {
+    throw new Error(`Invalid branch name from server: ${branchName}`);
+  }
+}
+function gitRemoteUrl(baseUrl, projectId) {
+  return `${baseUrl}/git/${projectId}.git`;
+}
+function gitExtraHeaderConfigKey(baseUrl) {
+  return `http.${normalizeBaseUrl(baseUrl)}/.extraHeader`;
+}
+function gitAuthArgs(auth) {
+  if (!auth) {
+    return [];
+  }
+  return ["-c", `${gitExtraHeaderConfigKey(auth.baseUrl)}=Authorization: Bearer ${auth.token}`];
+}
+function runGit(args, options = {}) {
+  const command = ["git", ...gitAuthArgs(options.auth), ...args];
+  const result = Bun.spawnSync(command, {
+    cwd: options.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0"
+    }
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `git ${args.join(" ")} failed: ${result.stderr.toString().trim() || result.stdout.toString().trim() || `exit ${result.exitCode}`}`
+    );
+  }
+  return result.stdout.toString().trim();
+}
+function tryGit(args, options = {}) {
+  try {
+    runGit(args, options);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getCurrentCommitHash(cwd) {
+  return runGit(["rev-parse", "HEAD"], { cwd });
+}
+function getGitBlobHashForContent(content) {
+  const buffer = typeof content === "string" ? Buffer.from(content, "utf8") : content;
+  return (0, import_node_crypto.createHash)("sha1").update(`blob ${buffer.length}\0`).update(buffer).digest("hex");
+}
+function hasWorktreeChanges(cwd) {
+  return runGit(["status", "--porcelain"], { cwd }).trim().length > 0;
+}
+function assertInsideBranch(branchPath, filePath) {
+  const relative = import_node_path.default.relative(branchPath, filePath);
+  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
+    throw new Error("File path escapes the project branch");
+  }
+}
+function resolveProjectFilePath(branchPath, virtualPath) {
+  if (typeof virtualPath !== "string" || !virtualPath.startsWith("/") || virtualPath.includes("\0")) {
+    throw new Error(`File path must be an absolute project path starting with /. Got: ${JSON.stringify(virtualPath)}`);
+  }
+  const normalized = import_node_path.default.posix.normalize(virtualPath);
+  if (normalized === "/" || normalized.startsWith("/../")) {
+    throw new Error(`Invalid project file path: ${virtualPath}`);
+  }
+  const repoRelativePath = normalized.slice(1);
+  if (repoRelativePath === ".git" || repoRelativePath.startsWith(".git/")) {
+    throw new Error("Refusing to access .git through worker file tools");
+  }
+  const absolutePath = import_node_path.default.resolve(branchPath, ...repoRelativePath.split("/"));
+  assertInsideBranch(branchPath, absolutePath);
+  return { absolutePath, virtualPath: `/${repoRelativePath}`, repoRelativePath };
+}
+function branchLockKey(projectRoot, branchName) {
+  return `${projectRoot}:${branchName}`;
+}
+async function withBranchLock(projectRoot, branchName, fn) {
+  const key = branchLockKey(projectRoot, branchName);
+  const previous = branchLocks.get(key) ?? Promise.resolve();
+  let release = () => {
+  };
+  const next = new Promise((resolve) => {
+    release = resolve;
+  });
+  const queued = previous.catch(() => {
+  }).then(() => next);
+  branchLocks.set(key, queued);
+  await previous.catch(() => {
+  });
+  try {
+    return await fn();
+  } finally {
+    release();
+    if (branchLocks.get(key) === queued) {
+      branchLocks.delete(key);
+    }
+  }
+}
+function configureRepo(pathName, auth) {
+  const authHeaderKey = gitExtraHeaderConfigKey(auth.baseUrl);
+  tryGit(["config", "--unset-all", "http.extraHeader"], { cwd: pathName });
+  tryGit(["config", "--unset-all", authHeaderKey], { cwd: pathName });
+  runGit(["config", "--add", authHeaderKey, `Authorization: Bearer ${auth.token}`], { cwd: pathName });
+  runGit(["config", "user.name", "r5d.dev Worker"], { cwd: pathName });
+  runGit(["config", "user.email", "worker@r5d.dev"], { cwd: pathName });
+}
+function ensureMainClone(input) {
+  const mainPath = import_node_path.default.join(input.projectRoot, "main");
+  const remoteUrl = gitRemoteUrl(input.baseUrl, input.projectId);
+  import_node_fs.default.mkdirSync(input.projectRoot, { recursive: true });
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(mainPath, ".git"))) {
+    import_node_fs.default.rmSync(mainPath, { recursive: true, force: true });
+    runGit(["clone", "--origin", "build-it-now", remoteUrl, mainPath], { auth: input });
+  }
+  configureRepo(mainPath, input);
+  runGit(["remote", "set-url", "build-it-now", remoteUrl], { cwd: mainPath });
+  runGit(["fetch", "build-it-now", "--prune"], { cwd: mainPath });
+  runGit(["checkout", "main"], { cwd: mainPath });
+  if (!hasWorktreeChanges(mainPath)) {
+    tryGit(["pull", "--ff-only", "build-it-now", "main"], { cwd: mainPath });
+  }
+  return mainPath;
+}
+function ensureBranchWorkspace(input) {
+  validateBranchName(input.branchName);
+  const mainPath = ensureMainClone(input);
+  if (input.branchName === "main") {
+    return mainPath;
+  }
+  const branchPath = import_node_path.default.join(input.projectRoot, input.branchName);
+  runGit(["fetch", "build-it-now", "--prune"], { cwd: mainPath });
+  const hasRemoteBranch = tryGit(["show-ref", "--verify", "--quiet", `refs/remotes/build-it-now/${input.branchName}`], {
+    cwd: mainPath
+  });
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(branchPath, ".git"))) {
+    import_node_fs.default.rmSync(branchPath, { recursive: true, force: true });
+    if (hasRemoteBranch) {
+      runGit(["worktree", "add", "-B", input.branchName, branchPath, `build-it-now/${input.branchName}`], {
+        cwd: mainPath
+      });
+    } else {
+      runGit(["worktree", "add", "-b", input.branchName, branchPath, "build-it-now/main"], {
+        cwd: mainPath
+      });
+    }
+  }
+  configureRepo(branchPath, input);
+  if (hasRemoteBranch && !hasWorktreeChanges(branchPath)) {
+    tryGit(["pull", "--ff-only", "build-it-now", input.branchName], { cwd: branchPath });
+  }
+  return branchPath;
+}
+function resolveCommandCwd(branchPath, cwd) {
+  if (!cwd) {
+    return branchPath;
+  }
+  if (import_node_path.default.isAbsolute(cwd)) {
+    return cwd;
+  }
+  const resolved = import_node_path.default.resolve(branchPath, cwd);
+  const relative = import_node_path.default.relative(branchPath, resolved);
+  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
+    throw new Error(`Relative cwd escapes the project branch: ${cwd}`);
+  }
+  return resolved;
+}
+async function collectStream(stream) {
+  if (!stream) {
+    return "";
+  }
+  return await new Response(stream).text();
+}
+function ensureOperationBranch(input) {
+  return ensureBranchWorkspace(input);
+}
+function formatLineNumberedContent(content, offset, limit) {
+  const allLines = content.split("\n");
+  const totalLines = allLines.length;
+  const startLine = Math.max(1, Math.floor(offset ?? 1));
+  const readLimit = Math.max(1, Math.floor(limit ?? DEFAULT_READ_LIMIT));
+  const endLine = Math.min(startLine + readLimit - 1, totalLines);
+  const selectedLines = allLines.slice(startLine - 1, endLine);
+  const padWidth = String(endLine).length;
+  const formattedLines = selectedLines.map((line, index) => {
+    const lineNumber = startLine + index;
+    const truncatedLine = line.length > MAX_LINE_LENGTH ? `${line.slice(0, MAX_LINE_LENGTH)}...` : line;
+    return `${String(lineNumber).padStart(padWidth, " ")}\u2192${truncatedLine}`;
+  });
+  return {
+    content: formattedLines.join("\n"),
+    totalLines,
+    startLine,
+    endLine
+  };
+}
+function readPngDimensions(bytes) {
+  if (bytes.length < 24) {
+    return null;
+  }
+  const pngSignature = "89504e470d0a1a0a";
+  if (bytes.subarray(0, 8).toString("hex") !== pngSignature || bytes.subarray(12, 16).toString("ascii") !== "IHDR") {
+    return null;
+  }
+  return {
+    width: bytes.readUInt32BE(16),
+    height: bytes.readUInt32BE(20)
+  };
+}
+function readJpegDimensions(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) {
+    return null;
+  }
+  const startOfFrameMarkers = /* @__PURE__ */ new Set([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207]);
+  let offset = 2;
+  while (offset < bytes.length) {
+    while (offset < bytes.length && bytes[offset] !== 255) {
+      offset += 1;
+    }
+    while (offset < bytes.length && bytes[offset] === 255) {
+      offset += 1;
+    }
+    if (offset >= bytes.length) {
+      return null;
+    }
+    const marker = bytes[offset];
+    offset += 1;
+    if (marker === 217 || marker === 218) {
+      return null;
+    }
+    if (marker >= 208 && marker <= 215) {
+      continue;
+    }
+    if (offset + 2 > bytes.length) {
+      return null;
+    }
+    const length = bytes.readUInt16BE(offset);
+    if (length < 2 || offset + length > bytes.length) {
+      return null;
+    }
+    if (startOfFrameMarkers.has(marker)) {
+      if (length < 7) {
+        return null;
+      }
+      return {
+        height: bytes.readUInt16BE(offset + 3),
+        width: bytes.readUInt16BE(offset + 5)
+      };
+    }
+    offset += length;
+  }
+  return null;
+}
+function readImageDimensions(bytes, mediaType) {
+  const dimensions = mediaType === "image/png" ? readPngDimensions(bytes) : readJpegDimensions(bytes);
+  if (!dimensions || dimensions.width <= 0 || dimensions.height <= 0) {
+    throw new Error("Could not determine image dimensions");
+  }
+  return dimensions;
+}
+async function executeReadFileOperation(input) {
+  const branchPath = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const resolved = resolveProjectFilePath(branchPath, input.message.filePath);
+  if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isFile()) {
+    throw new Error(`File not found: ${resolved.virtualPath}`);
+  }
+  const buffer = import_node_fs.default.readFileSync(resolved.absolutePath);
+  const formatted = formatLineNumberedContent(buffer.toString("utf8"), input.message.offset, input.message.limit);
+  return {
+    type: "read_file",
+    file: resolved.virtualPath,
+    gitBlobHash: getGitBlobHashForContent(buffer),
+    ...formatted
+  };
+}
+async function executeCreateFileOperation(input) {
+  const branchPath = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const resolved = resolveProjectFilePath(branchPath, input.message.filePath);
+  if (import_node_fs.default.existsSync(resolved.absolutePath)) {
+    throw new Error(`File "${resolved.virtualPath}" already exists. Use edit_file to modify existing files.`);
+  }
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(resolved.absolutePath), { recursive: true });
+  import_node_fs.default.writeFileSync(resolved.absolutePath, input.message.content, "utf8");
+  return {
+    type: "create_file",
+    file: resolved.virtualPath,
+    gitBlobHash: getGitBlobHashForContent(input.message.content)
+  };
+}
+async function executeEditFileOperation(input) {
+  const branchPath = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const resolved = resolveProjectFilePath(branchPath, input.message.filePath);
+  if (input.message.oldString === input.message.newString) {
+    throw new Error("old_string and new_string must be different");
+  }
+  if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isFile()) {
+    throw new Error(`File not found: ${resolved.virtualPath}`);
+  }
+  const content = import_node_fs.default.readFileSync(resolved.absolutePath, "utf8");
+  if (!content.includes(input.message.oldString)) {
+    throw new Error(
+      `Could not find old_string: "${input.message.oldString.slice(0, 100)}${input.message.oldString.length > 100 ? "..." : ""}"`
+    );
+  }
+  if (!input.message.replaceAll) {
+    const occurrences = content.split(input.message.oldString).length - 1;
+    if (occurrences > 1) {
+      throw new Error(
+        `old_string is not unique in the file (found ${occurrences} occurrences). Provide more context or use replace_all: true.`
+      );
+    }
+  }
+  const nextContent = input.message.replaceAll ? content.split(input.message.oldString).join(input.message.newString) : content.replace(input.message.oldString, input.message.newString);
+  import_node_fs.default.writeFileSync(resolved.absolutePath, nextContent, "utf8");
+  return {
+    type: "edit_file",
+    file: resolved.virtualPath
+  };
+}
+async function executeViewFileBytesOperation(input) {
+  const branchPath = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const resolved = resolveProjectFilePath(branchPath, input.message.filePath);
+  if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isFile()) {
+    throw new Error(`File not found: ${resolved.virtualPath}`);
+  }
+  const extension = import_node_path.default.extname(resolved.absolutePath).toLowerCase();
+  const mediaType = extension === ".jpg" || extension === ".jpeg" ? "image/jpeg" : extension === ".png" ? "image/png" : null;
+  if (!mediaType) {
+    throw new Error("view_image supports PNG and JPEG files only");
+  }
+  const bytes = import_node_fs.default.readFileSync(resolved.absolutePath);
+  const dimensions = readImageDimensions(bytes, mediaType);
+  return {
+    type: "view_file_bytes",
+    filePath: resolved.virtualPath,
+    mediaType,
+    base64: bytes.toString("base64"),
+    fileSizeBytes: bytes.length,
+    width: dimensions.width,
+    height: dimensions.height
+  };
+}
+function stagedBlobSizeBytes(cwd) {
+  const names = runGit(["diff", "--cached", "--name-only", "-z"], { cwd }).split("\0").filter(Boolean);
+  let total = 0;
+  for (const name of names) {
+    try {
+      const sizeText = runGit(["cat-file", "-s", `:${name}`], { cwd });
+      total += Number.parseInt(sizeText, 10) || 0;
+    } catch {
+    }
+    if (total > MAX_SYNC_DIFF_BYTES) {
+      return MAX_SYNC_DIFF_BYTES + 1;
+    }
+  }
+  return total;
+}
+function syncBranch(input) {
+  const branchPath = ensureOperationBranch(input);
+  runGit(["add", "-A"], { cwd: branchPath });
+  const hasStagedChanges = !tryGit(["diff", "--cached", "--quiet"], { cwd: branchPath });
+  const status = runGit(["status", "--porcelain"], { cwd: branchPath });
+  const currentCommit = getCurrentCommitHash(branchPath);
+  if (!hasStagedChanges) {
+    return {
+      type: "sync",
+      changed: false,
+      commitHash: currentCommit,
+      diffSizeBytes: 0,
+      status
+    };
+  }
+  const diffSizeBytes = stagedBlobSizeBytes(branchPath);
+  if (diffSizeBytes > MAX_SYNC_DIFF_BYTES && !input.confirmedLargeDiff) {
+    return {
+      type: "sync",
+      changed: true,
+      commitHash: currentCommit,
+      diffSizeBytes,
+      status,
+      largeDiffBlocked: true,
+      trigger: input.trigger
+    };
+  }
+  const message = JSON.stringify({
+    type: "agent_changes",
+    sessionId: input.sessionId,
+    parentNodeId: input.parentNodeId,
+    ...input.confirmedLargeDiff ? { confirmedLargeDiff: true, confirmationReason: input.confirmationReason } : {}
+  });
+  runGit(["commit", "-m", message], { cwd: branchPath });
+  const commitHash = getCurrentCommitHash(branchPath);
+  runGit(["push", "build-it-now", `HEAD:refs/heads/${input.branchName}`], { cwd: branchPath });
+  return {
+    type: "sync",
+    changed: true,
+    commitHash,
+    diffSizeBytes,
+    status: runGit(["status", "--porcelain"], { cwd: branchPath }),
+    trigger: input.trigger
+  };
+}
+function confirmLargeDiff(input) {
+  const reason = input.reason.trim();
+  if (!reason) {
+    throw new Error("confirm_large_diff requires a non-empty reason");
+  }
+  const result = syncBranch({
+    ...input,
+    confirmedLargeDiff: true,
+    confirmationReason: reason
+  });
+  return {
+    type: "confirm_large_diff",
+    changed: result.changed,
+    commitHash: result.commitHash,
+    diffSizeBytes: result.diffSizeBytes,
+    status: result.status,
+    reason
+  };
+}
+function pullBranch(input) {
+  const branchPath = ensureOperationBranch(input);
+  runGit(["fetch", "build-it-now", "--prune"], { cwd: branchPath });
+  const target = input.commitHash ?? `build-it-now/${input.branchName}`;
+  runGit(["reset", "--hard", target], { cwd: branchPath });
+  runGit(["clean", "-fd"], { cwd: branchPath });
+  return {
+    type: "pull_branch",
+    commitHash: getCurrentCommitHash(branchPath)
+  };
+}
+async function executeOperation(input) {
+  switch (input.message.type) {
+    case "read_file":
+      return executeReadFileOperation({ ...input, message: input.message });
+    case "create_file":
+      return executeCreateFileOperation({ ...input, message: input.message });
+    case "edit_file":
+      return executeEditFileOperation({ ...input, message: input.message });
+    case "view_file_bytes":
+      return executeViewFileBytesOperation({ ...input, message: input.message });
+    case "sync":
+      return syncBranch({
+        projectId: input.projectId,
+        baseUrl: input.baseUrl,
+        token: input.token,
+        projectRoot: input.projectRoot,
+        branchName: input.message.branchName,
+        sessionId: input.message.sessionId,
+        parentNodeId: input.message.parentNodeId,
+        trigger: input.message.trigger
+      });
+    case "confirm_large_diff":
+      return confirmLargeDiff({
+        projectId: input.projectId,
+        baseUrl: input.baseUrl,
+        token: input.token,
+        projectRoot: input.projectRoot,
+        branchName: input.message.branchName,
+        sessionId: input.message.sessionId,
+        parentNodeId: input.message.parentNodeId,
+        reason: input.message.reason
+      });
+    case "pull_branch":
+      return pullBranch({
+        projectId: input.projectId,
+        baseUrl: input.baseUrl,
+        token: input.token,
+        projectRoot: input.projectRoot,
+        branchName: input.message.branchName,
+        commitHash: input.message.commitHash
+      });
+  }
+}
+async function executeCommand(input) {
+  const startedAt = Date.now();
+  let timeout;
+  try {
+    const branchPath = ensureBranchWorkspace({
+      projectId: input.projectId,
+      baseUrl: input.baseUrl,
+      token: input.token,
+      projectRoot: input.projectRoot,
+      branchName: input.message.branchName
+    });
+    const cwd = resolveCommandCwd(branchPath, input.message.cwd);
+    const subprocess = Bun.spawn(input.message.argv, {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        ...input.message.env ?? {}
+      }
+    });
+    activeProcesses.set(input.message.runId, { process: subprocess, command: input.message.argv });
+    if (input.message.timeoutMs) {
+      timeout = setTimeout(() => {
+        subprocess.kill("SIGTERM");
+      }, input.message.timeoutMs);
+    }
+    const [stdout, stderr, exitCode] = await Promise.all([
+      collectStream(subprocess.stdout),
+      collectStream(subprocess.stderr),
+      subprocess.exited
+    ]);
+    return {
+      type: "exec_result",
+      requestId: input.message.requestId,
+      stdout,
+      stderr,
+      exitCode,
+      durationMs: Date.now() - startedAt
+    };
+  } catch (error) {
+    return {
+      type: "exec_result",
+      requestId: input.message.requestId,
+      stdout: "",
+      stderr: "",
+      exitCode: 1,
+      durationMs: Date.now() - startedAt,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    activeProcesses.delete(input.message.runId);
+  }
+}
+function sendWorkerMessage(ws, message) {
+  ws.send(JSON.stringify(message));
+}
+function resolveHostShell() {
+  if (process.platform === "win32") {
+    return { file: process.env.COMSPEC || "powershell.exe", args: [] };
+  }
+  return { file: process.env.SHELL || "/bin/bash", args: ["-l"] };
+}
+function openPty(input) {
+  try {
+    const branchPath = ensureBranchWorkspace({
+      projectId: input.projectId,
+      baseUrl: input.baseUrl,
+      token: input.token,
+      projectRoot: input.projectRoot,
+      branchName: input.message.branchName
+    });
+    const shell = resolveHostShell();
+    const ptyProcess = nodePty.spawn(shell.file, shell.args, {
+      name: "xterm-256color",
+      cols: Math.max(1, Math.min(Math.floor(input.message.cols || 80), 500)),
+      rows: Math.max(1, Math.min(Math.floor(input.message.rows || 24), 500)),
+      cwd: branchPath,
+      env: {
+        ...process.env,
+        ...input.message.env ?? {},
+        BUILD_IT_NOW_PROJECT_ID: input.projectId,
+        BUILD_IT_NOW_BRANCH_NAME: input.message.branchName
+      }
+    });
+    activePtys.set(input.message.ptyId, ptyProcess);
+    ptyProcess.onData((data) => {
+      sendWorkerMessage(input.ws, {
+        type: "pty_output",
+        ptyId: input.message.ptyId,
+        data
+      });
+    });
+    ptyProcess.onExit((event) => {
+      activePtys.delete(input.message.ptyId);
+      sendWorkerMessage(input.ws, {
+        type: "pty_exit",
+        ptyId: input.message.ptyId,
+        exitCode: event.exitCode,
+        signal: event.signal
+      });
+    });
+    sendWorkerMessage(input.ws, {
+      type: "pty_opened",
+      requestId: input.message.requestId,
+      ptyId: input.message.ptyId
+    });
+  } catch (error) {
+    sendWorkerMessage(input.ws, {
+      type: "pty_error",
+      requestId: input.message.requestId,
+      ptyId: input.message.ptyId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function writePty(ws, message) {
+  const ptyProcess = activePtys.get(message.ptyId);
+  if (!ptyProcess) {
+    sendWorkerMessage(ws, {
+      type: "pty_error",
+      ptyId: message.ptyId,
+      error: "Shell is not open"
+    });
+    return;
+  }
+  ptyProcess.write(message.data);
+}
+function resizePty(message) {
+  const ptyProcess = activePtys.get(message.ptyId);
+  if (!ptyProcess) {
+    return;
+  }
+  ptyProcess.resize(
+    Math.max(1, Math.min(Math.floor(message.cols || 80), 500)),
+    Math.max(1, Math.min(Math.floor(message.rows || 24), 500))
+  );
+}
+function closePty(message) {
+  const ptyProcess = activePtys.get(message.ptyId);
+  if (!ptyProcess) {
+    return;
+  }
+  activePtys.delete(message.ptyId);
+  ptyProcess.kill();
+}
+function closeAllPtys() {
+  for (const ptyProcess of activePtys.values()) {
+    ptyProcess.kill();
+  }
+  activePtys.clear();
+}
+function websocketUrl(baseUrl, projectId, label) {
+  const url = new URL("/worker/ws", baseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("projectId", projectId);
+  url.searchParams.set("label", label);
+  return url.toString();
+}
+async function startWorker(projectId, options) {
+  const config = readConfig(options.configPath);
+  const { baseUrl, token } = resolveCredentials(options, config);
+  const label = requireValue(options.label, "Missing required --label <label>");
+  validateLabel(label);
+  const projectRoot = import_node_path.default.resolve(options.projectRoot ?? defaultProjectRoot(projectId));
+  process.stdout.write(`[r5d-worker] project: ${projectId}
+`);
+  process.stdout.write(`[r5d-worker] label: ${label}
+`);
+  process.stdout.write(`[r5d-worker] root: ${projectRoot}
+`);
+  process.stdout.write(`[r5d-worker] server: ${baseUrl}
+`);
+  runGit(["--version"]);
+  await verifyBinctlAuth(baseUrl, token);
+  process.stdout.write("[r5d-worker] preparing local checkout...\n");
+  ensureMainClone({ projectId, baseUrl, token, projectRoot });
+  const ws = new WebSocket(websocketUrl(baseUrl, projectId, label), {
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  ws.addEventListener("open", () => {
+    const hello = {
+      type: "hello",
+      hostInfo: {
+        hostname: (0, import_node_os2.hostname)(),
+        platform: process.platform,
+        arch: process.arch,
+        pid: process.pid,
+        version: "0.1.0",
+        projectRoot
+      }
+    };
+    ws.send(JSON.stringify(hello));
+    process.stdout.write("[r5d-worker] connected\n");
+  });
+  ws.addEventListener("message", (event) => {
+    void (async () => {
+      const message = JSON.parse(String(event.data));
+      if (message.type === "connected") {
+        return;
+      }
+      if (message.type === "ping") {
+        ws.send(JSON.stringify({ type: "pong" }));
+        return;
+      }
+      if (message.type === "cancel") {
+        const active = activeProcesses.get(message.runId);
+        if (active) {
+          active.process.kill("SIGTERM");
+        }
+        ws.send(
+          JSON.stringify({
+            type: "cancel_result",
+            requestId: message.requestId,
+            runId: message.runId,
+            cancelled: !!active,
+            message: active ? `Sent SIGTERM to ${active.command.join(" ")}` : "No active command with that run id"
+          })
+        );
+        return;
+      }
+      if (message.type === "pty_open") {
+        process.stdout.write(`[r5d-worker] pty ${message.ptyId}: ${message.branchName}
+`);
+        openPty({ ws, message, projectId, baseUrl, token, projectRoot });
+        return;
+      }
+      if (message.type === "pty_input") {
+        writePty(ws, message);
+        return;
+      }
+      if (message.type === "pty_resize") {
+        resizePty(message);
+        return;
+      }
+      if (message.type === "pty_close") {
+        closePty(message);
+        return;
+      }
+      if (message.type === "exec") {
+        process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
+`);
+        const result = await withBranchLock(
+          projectRoot,
+          message.branchName,
+          () => executeCommand({ message, projectId, baseUrl, token, projectRoot })
+        );
+        ws.send(JSON.stringify(result));
+        return;
+      }
+      if (message.type === "read_file" || message.type === "create_file" || message.type === "edit_file" || message.type === "view_file_bytes" || message.type === "sync" || message.type === "pull_branch") {
+        try {
+          const result = await withBranchLock(
+            projectRoot,
+            message.branchName,
+            () => executeOperation({ message, projectId, baseUrl, token, projectRoot })
+          );
+          ws.send(
+            JSON.stringify({
+              type: "operation_result",
+              requestId: message.requestId,
+              result
+            })
+          );
+        } catch (error) {
+          ws.send(
+            JSON.stringify({
+              type: "operation_result",
+              requestId: message.requestId,
+              error: error instanceof Error ? error.message : String(error)
+            })
+          );
+        }
+      }
+    })().catch((error) => {
+      process.stderr.write(`[r5d-worker] message handling failed: ${error instanceof Error ? error.message : String(error)}
+`);
+    });
+  });
+  ws.addEventListener("close", (event) => {
+    closeAllPtys();
+    const reason = event.reason ? `: ${event.reason}` : "";
+    process.stderr.write(`[r5d-worker] disconnected (${event.code}${reason})
+`);
+    process.exit(event.code === 1e3 ? 0 : 1);
+  });
+  ws.addEventListener("error", (event) => {
+    const message = "message" in event && typeof event.message === "string" && event.message.trim() ? `: ${event.message.trim()}` : "";
+    process.stderr.write(`[r5d-worker] websocket error${message}
+`);
+  });
+  await new Promise(() => {
+  });
+}
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (parsed.command === "help") {
+    printHelp();
+    return;
+  }
+  await startWorker(parsed.projectId, parsed.options);
+}
+main().catch((error) => {
+  process.stderr.write(`[r5d-worker] ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exit(1);
+});