@ricsam/r5d-worker 0.0.1 → 0.0.3

package/dist/cjs/main.cjs

@@ -0,0 +1,1420 @@
+#!/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 import_node_child_process = require("node:child_process");
+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 defaultProjectsRoot() {
+  return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "projects");
+}
+function defaultSyncRoot() {
+  return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "sync");
+}
+function printHelp() {
+  process.stdout.write(`Usage:
+  r5d-worker start --label <label> [--base-url <url>] [--token <token>] [--api-key <key>]
+
+Options:
+  --label <label>       Required unique worker label for this user, 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 projects checkout root (default ~/.r5d/projects)
+  --sync-root <dir>     Override r5d internal sync git root (default ~/.r5d/sync)
+  -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;
+    }
+    const syncRoot = readOption("--sync-root");
+    if (syncRoot !== void 0) {
+      options.syncRoot = syncRoot;
+      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",
+    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 gitExtraHeaderConfigKey(extraHeaderUrl) {
+  return `http.${normalizeBaseUrl(extraHeaderUrl)}/.extraHeader`;
+}
+function gitAuthArgs(auth) {
+  if (!auth) {
+    return [];
+  }
+  return ["-c", `${gitExtraHeaderConfigKey(auth.extraHeaderUrl)}=${auth.header}`];
+}
+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 runInternalGit(context, args) {
+  return runGit(["--git-dir", context.gitDir, "--work-tree", context.workTree, ...args], { auth: context.auth });
+}
+function runInternalGitDir(context, args) {
+  return runGit(["--git-dir", context.gitDir, ...args], { auth: context.auth });
+}
+function tryInternalGit(context, args) {
+  try {
+    runInternalGit(context, args);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getInternalCommitHash(context) {
+  return runInternalGit(context, ["rev-parse", "HEAD"]);
+}
+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 getInternalStatus(context) {
+  return runInternalGit(context, ["status", "--porcelain", "--", ".", ":(exclude).git"]);
+}
+function hasInternalWorktreeChanges(context) {
+  return getInternalStatus(context).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(projectId, branchName) {
+  return `${projectId}:${branchName}`;
+}
+async function withBranchLock(projectId, branchName, fn) {
+  const key = branchLockKey(projectId, 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 resolveRemoteUrl(baseUrl, remoteUrl) {
+  if (/^https?:\/\//i.test(remoteUrl)) {
+    return remoteUrl;
+  }
+  return new URL(remoteUrl, baseUrl).toString();
+}
+function fallbackInternalRemoteUrl(baseUrl, projectId) {
+  return new URL(`/git/${projectId}.git`, baseUrl).toString();
+}
+function internalGitAuth(baseUrl, token) {
+  return {
+    extraHeaderUrl: baseUrl,
+    header: `Authorization: Bearer ${token}`
+  };
+}
+function internalRemoteUrlFor(baseUrl, projectId, manifest) {
+  return resolveRemoteUrl(baseUrl, manifest?.internalRemoteUrl ?? fallbackInternalRemoteUrl(baseUrl, projectId));
+}
+function githubRemoteUrlFor(baseUrl, projectId, manifest) {
+  return manifest?.repoHttpUrl ?? internalRemoteUrlFor(baseUrl, projectId, manifest);
+}
+function gitExtraHeaderUrlForRemote(remoteUrl) {
+  try {
+    return new URL(remoteUrl).origin;
+  } catch {
+    return remoteUrl;
+  }
+}
+function gitAuthForRemote(remoteUrl, authHeader) {
+  if (!authHeader) {
+    return void 0;
+  }
+  return {
+    extraHeaderUrl: gitExtraHeaderUrlForRemote(remoteUrl),
+    header: authHeader
+  };
+}
+function branchGitDirName(branchName) {
+  return `${encodeURIComponent(branchName)}.git`;
+}
+function internalGitDirFor(syncRoot, projectId, branchName) {
+  return import_node_path.default.join(syncRoot, projectId, branchGitDirName(branchName));
+}
+function hasNormalVisibleGitDir(branchPath) {
+  const gitPath = import_node_path.default.join(branchPath, ".git");
+  return import_node_fs.default.existsSync(gitPath) && import_node_fs.default.statSync(gitPath).isDirectory();
+}
+function ensureOriginRemote(branchPath, remoteUrl) {
+  if (tryGit(["remote", "get-url", "origin"], { cwd: branchPath })) {
+    runGit(["remote", "set-url", "origin", remoteUrl], { cwd: branchPath });
+  } else {
+    runGit(["remote", "add", "origin", remoteUrl], { cwd: branchPath });
+  }
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function githubCredentialsPath() {
+  return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "github-credentials");
+}
+function decodeBasicAuthHeader(authHeader) {
+  const match = /^Authorization:\s*Basic\s+(.+)$/i.exec(authHeader.trim());
+  if (!match) {
+    return null;
+  }
+  const decoded = Buffer.from(match[1], "base64").toString("utf8");
+  const separatorIndex = decoded.indexOf(":");
+  if (separatorIndex <= 0) {
+    return null;
+  }
+  return {
+    username: decoded.slice(0, separatorIndex),
+    password: decoded.slice(separatorIndex + 1)
+  };
+}
+function writeCredentialStoreEntry(remoteUrl, authHeader) {
+  const credentials = decodeBasicAuthHeader(authHeader);
+  if (!credentials) {
+    return null;
+  }
+  let remote;
+  try {
+    remote = new URL(remoteUrl);
+  } catch {
+    return null;
+  }
+  if (remote.protocol !== "https:") {
+    return null;
+  }
+  const storePath = githubCredentialsPath();
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(storePath), { recursive: true });
+  const hostKey = `${remote.protocol}//${remote.host}`;
+  const existing = import_node_fs.default.existsSync(storePath) ? import_node_fs.default.readFileSync(storePath, "utf8").split(/\r?\n/).filter(Boolean) : [];
+  const next = existing.filter((line) => {
+    try {
+      const parsed = new URL(line);
+      return `${parsed.protocol}//${parsed.host}` !== hostKey;
+    } catch {
+      return true;
+    }
+  });
+  const credentialUrl = new URL(hostKey);
+  credentialUrl.username = credentials.username;
+  credentialUrl.password = credentials.password;
+  next.push(credentialUrl.toString());
+  import_node_fs.default.writeFileSync(storePath, `${next.join("\n")}
+`, { mode: 384 });
+  import_node_fs.default.chmodSync(storePath, 384);
+  return storePath;
+}
+function configureVisibleGitHubAuth(branchPath, remoteUrl, authHeader) {
+  if (!authHeader) {
+    return;
+  }
+  const credentialStore = writeCredentialStoreEntry(remoteUrl, authHeader);
+  if (credentialStore) {
+    runGit(["config", "credential.helper", `store --file=${shellQuote(credentialStore)}`], { cwd: branchPath });
+    runGit(["config", "credential.useHttpPath", "false"], { cwd: branchPath });
+    return;
+  }
+  runGit(["config", `${gitExtraHeaderConfigKey(gitExtraHeaderUrlForRemote(remoteUrl))}`, authHeader], { cwd: branchPath });
+}
+function checkoutVisibleBranch(input) {
+  const branchExists = tryGit(["show-ref", "--verify", "--quiet", `refs/heads/${input.branchName}`], { cwd: input.branchPath });
+  const remoteBranchExists = tryGit(["show-ref", "--verify", "--quiet", `refs/remotes/origin/${input.branchName}`], {
+    cwd: input.branchPath
+  });
+  const defaultRemoteExists = tryGit(["show-ref", "--verify", "--quiet", `refs/remotes/origin/${input.defaultBranch}`], {
+    cwd: input.branchPath
+  });
+  const clean = !hasWorktreeChanges(input.branchPath);
+  if (remoteBranchExists && clean) {
+    runGit(["checkout", "-B", input.branchName, `origin/${input.branchName}`], { cwd: input.branchPath });
+    return;
+  }
+  if (branchExists) {
+    runGit(["checkout", input.branchName], { cwd: input.branchPath });
+    return;
+  }
+  if (defaultRemoteExists) {
+    runGit(["checkout", "-B", input.branchName, `origin/${input.defaultBranch}`], { cwd: input.branchPath });
+    return;
+  }
+  runGit(["checkout", "-B", input.branchName], { cwd: input.branchPath });
+}
+function ensureVisibleGitCheckout(input) {
+  validateBranchName(input.branchName);
+  import_node_fs.default.mkdirSync(input.projectRoot, { recursive: true });
+  const branchPath = import_node_path.default.join(input.projectRoot, input.branchName);
+  if (!hasNormalVisibleGitDir(branchPath)) {
+    import_node_fs.default.rmSync(branchPath, { recursive: true, force: true });
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(branchPath), { recursive: true });
+    if (!tryGit(["clone", "--origin", "origin", input.githubRemoteUrl, branchPath], { auth: input.githubAuth })) {
+      import_node_fs.default.mkdirSync(branchPath, { recursive: true });
+      runGit(["init"], { cwd: branchPath });
+    }
+  }
+  ensureOriginRemote(branchPath, input.githubRemoteUrl);
+  configureVisibleGitHubAuth(branchPath, input.githubRemoteUrl, input.githubAuthHeader);
+  tryGit(["fetch", "origin", "--prune"], { cwd: branchPath, auth: input.githubAuth });
+  checkoutVisibleBranch({ branchPath, branchName: input.branchName, defaultBranch: input.defaultBranch });
+  return branchPath;
+}
+function configureInternalRepo(context, remoteUrl) {
+  if (tryInternalGit(context, ["remote", "get-url", "build-it-now"])) {
+    runInternalGit(context, ["remote", "set-url", "build-it-now", remoteUrl]);
+  } else {
+    runInternalGit(context, ["remote", "add", "build-it-now", remoteUrl]);
+  }
+  runInternalGitDir(context, ["config", "user.name", "r5d.dev Worker"]);
+  runInternalGitDir(context, ["config", "user.email", "worker@r5d.dev"]);
+}
+function ensureInternalSyncGit(input) {
+  validateBranchName(input.branchName);
+  const gitDir = internalGitDirFor(input.syncRoot, input.projectId, input.branchName);
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(gitDir), { recursive: true });
+  if (!import_node_fs.default.existsSync(gitDir)) {
+    runGit(["init", "--bare", gitDir]);
+  }
+  const auth = internalGitAuth(input.baseUrl, input.token);
+  const context = { gitDir, workTree: input.branchPath, auth };
+  const remoteUrl = internalRemoteUrlFor(input.baseUrl, input.projectId, input.manifest);
+  configureInternalRepo(context, remoteUrl);
+  runInternalGit(context, ["fetch", "build-it-now", "--prune", "+refs/heads/*:refs/remotes/build-it-now/*"]);
+  const hasRemoteBranch = tryInternalGit(context, ["show-ref", "--verify", "--quiet", `refs/remotes/build-it-now/${input.branchName}`]);
+  const target = hasRemoteBranch ? `refs/remotes/build-it-now/${input.branchName}` : "refs/remotes/build-it-now/main";
+  const hasHead = tryInternalGit(context, ["rev-parse", "--verify", "HEAD"]);
+  if (!hasHead || !hasInternalWorktreeChanges(context)) {
+    runInternalGit(context, ["checkout", "-f", "-B", input.branchName, target]);
+  }
+  return context;
+}
+function ensureBranchWorkspace(input) {
+  const defaultBranch = input.manifest?.defaultBranch || "main";
+  const githubRemoteUrl = githubRemoteUrlFor(input.baseUrl, input.projectId, input.manifest);
+  const githubAuth = gitAuthForRemote(githubRemoteUrl, input.manifest?.repoAuthHeader);
+  const branchPath = ensureVisibleGitCheckout({
+    projectRoot: input.projectRoot,
+    branchName: input.branchName,
+    githubRemoteUrl,
+    githubAuth,
+    githubAuthHeader: input.manifest?.repoAuthHeader ?? null,
+    defaultBranch
+  });
+  const internalGit = ensureInternalSyncGit({
+    projectId: input.projectId,
+    baseUrl: input.baseUrl,
+    token: input.token,
+    syncRoot: input.syncRoot,
+    branchPath,
+    branchName: input.branchName,
+    manifest: input.manifest
+  });
+  return { branchPath, internalGit };
+}
+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 workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const resolved = resolveProjectFilePath(workspace.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 workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const resolved = resolveProjectFilePath(workspace.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 workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const resolved = resolveProjectFilePath(workspace.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 workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const resolved = resolveProjectFilePath(workspace.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(context) {
+  const names = runInternalGit(context, ["diff", "--cached", "--name-only", "-z", "--", ".", ":(exclude).git"]).split("\0").filter(Boolean);
+  let total = 0;
+  for (const name of names) {
+    try {
+      const sizeText = runInternalGit(context, ["cat-file", "-s", `:${name}`]);
+      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 workspace = ensureOperationBranch(input);
+  runInternalGit(workspace.internalGit, ["add", "-A", "--", ".", ":(exclude).git"]);
+  const hasStagedChanges = !tryInternalGit(workspace.internalGit, ["diff", "--cached", "--quiet", "--", ".", ":(exclude).git"]);
+  const status = getInternalStatus(workspace.internalGit);
+  const currentCommit = getInternalCommitHash(workspace.internalGit);
+  if (!hasStagedChanges) {
+    return {
+      type: "sync",
+      changed: false,
+      commitHash: currentCommit,
+      diffSizeBytes: 0,
+      status
+    };
+  }
+  const diffSizeBytes = stagedBlobSizeBytes(workspace.internalGit);
+  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 } : {}
+  });
+  runInternalGit(workspace.internalGit, ["commit", "-m", message]);
+  const commitHash = getInternalCommitHash(workspace.internalGit);
+  runInternalGit(workspace.internalGit, ["push", "build-it-now", `HEAD:refs/heads/${input.branchName}`]);
+  return {
+    type: "sync",
+    changed: true,
+    commitHash,
+    diffSizeBytes,
+    status: getInternalStatus(workspace.internalGit),
+    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 workspace = ensureOperationBranch(input);
+  runInternalGit(workspace.internalGit, ["fetch", "build-it-now", "--prune", "+refs/heads/*:refs/remotes/build-it-now/*"]);
+  const target = input.commitHash ?? `build-it-now/${input.branchName}`;
+  runInternalGit(workspace.internalGit, ["reset", "--hard", target]);
+  runInternalGit(workspace.internalGit, ["clean", "-fd", "--", ".", ":(exclude).git"]);
+  return {
+    type: "pull_branch",
+    commitHash: getInternalCommitHash(workspace.internalGit)
+  };
+}
+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,
+        syncRoot: input.syncRoot,
+        branchName: input.message.branchName,
+        sessionId: input.message.sessionId,
+        parentNodeId: input.message.parentNodeId,
+        trigger: input.message.trigger,
+        manifest: input.manifest
+      });
+    case "confirm_large_diff":
+      return confirmLargeDiff({
+        projectId: input.projectId,
+        baseUrl: input.baseUrl,
+        token: input.token,
+        projectRoot: input.projectRoot,
+        syncRoot: input.syncRoot,
+        branchName: input.message.branchName,
+        sessionId: input.message.sessionId,
+        parentNodeId: input.message.parentNodeId,
+        reason: input.message.reason,
+        manifest: input.manifest
+      });
+    case "pull_branch":
+      return pullBranch({
+        projectId: input.projectId,
+        baseUrl: input.baseUrl,
+        token: input.token,
+        projectRoot: input.projectRoot,
+        syncRoot: input.syncRoot,
+        branchName: input.message.branchName,
+        commitHash: input.message.commitHash,
+        manifest: input.manifest
+      });
+  }
+}
+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,
+      syncRoot: input.syncRoot,
+      branchName: input.message.branchName,
+      manifest: input.manifest
+    });
+    const cwd = resolveCommandCwd(branchPath.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));
+}
+const PTY_BRIDGE_SCRIPT = String.raw`
+const readline = require("node:readline");
+const nodePty = require("node-pty");
+
+let ptyProcess = null;
+
+function send(message, callback) {
+  process.stdout.write(JSON.stringify(message) + "\n", callback);
+}
+
+function decode(data) {
+  return Buffer.from(data, "base64").toString("utf8");
+}
+
+const rl = readline.createInterface({ input: process.stdin });
+
+rl.on("line", (line) => {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch (error) {
+    send({ type: "error", error: error instanceof Error ? error.message : String(error) });
+    return;
+  }
+
+  try {
+    if (message.type === "open") {
+      ptyProcess = nodePty.spawn(message.file, message.args, message.options);
+      ptyProcess.onData((data) => {
+        send({ type: "output", data: Buffer.from(data, "utf8").toString("base64") });
+      });
+      ptyProcess.onExit((event) => {
+        send({ type: "exit", exitCode: event.exitCode, signal: event.signal }, () => process.exit(0));
+      });
+      send({ type: "opened" });
+      return;
+    }
+
+    if (!ptyProcess) {
+      send({ type: "error", error: "PTY has not been opened" });
+      return;
+    }
+
+    if (message.type === "input") {
+      ptyProcess.write(decode(message.data));
+      return;
+    }
+
+    if (message.type === "resize") {
+      ptyProcess.resize(message.cols, message.rows);
+      return;
+    }
+
+    if (message.type === "close") {
+      ptyProcess.kill();
+    }
+  } catch (error) {
+    send({ type: "error", error: error instanceof Error ? error.message : String(error) });
+  }
+});
+`;
+function nodePtyModulePaths() {
+  const candidates = [];
+  const entrypoint = process.argv[1];
+  if (entrypoint) {
+    try {
+      let current = import_node_path.default.dirname(import_node_fs.default.realpathSync(entrypoint));
+      for (let index = 0; index < 8; index += 1) {
+        candidates.push(import_node_path.default.join(current, "node_modules"));
+        const parent = import_node_path.default.dirname(current);
+        if (parent === current) {
+          break;
+        }
+        current = parent;
+      }
+    } catch {
+    }
+  }
+  candidates.push(import_node_path.default.join(process.cwd(), "node_modules"), "/usr/local/lib/node_modules", "/usr/lib/node_modules");
+  if (process.env.NODE_PATH) {
+    candidates.push(...process.env.NODE_PATH.split(import_node_path.default.delimiter));
+  }
+  return [...new Set(candidates.filter(Boolean))].join(import_node_path.default.delimiter);
+}
+function createNodePtyBridge(options) {
+  const child = (0, import_node_child_process.spawn)("node", ["-e", PTY_BRIDGE_SCRIPT], {
+    env: {
+      ...process.env,
+      NODE_PATH: nodePtyModulePaths()
+    }
+  });
+  let lineBuffer = "";
+  let emittedTerminalEvent = false;
+  let stderr = "";
+  const sendToChild = (message) => {
+    if (child.stdin.writable) {
+      child.stdin.write(`${JSON.stringify(message)}
+`);
+    }
+  };
+  const handleEvent = (event) => {
+    if (event.type === "opened") {
+      options.onOpened();
+      return;
+    }
+    if (event.type === "output") {
+      options.onOutput(Buffer.from(event.data, "base64").toString("utf8"));
+      return;
+    }
+    if (event.type === "exit") {
+      emittedTerminalEvent = true;
+      options.onExit({ exitCode: event.exitCode, signal: event.signal });
+      return;
+    }
+    if (event.type === "error") {
+      emittedTerminalEvent = true;
+      options.onError(new Error(event.error));
+    }
+  };
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    lineBuffer += chunk;
+    let newlineIndex = lineBuffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = lineBuffer.slice(0, newlineIndex).trim();
+      lineBuffer = lineBuffer.slice(newlineIndex + 1);
+      if (line) {
+        try {
+          handleEvent(JSON.parse(line));
+        } catch (error) {
+          emittedTerminalEvent = true;
+          options.onError(new Error(error instanceof Error ? error.message : String(error)));
+        }
+      }
+      newlineIndex = lineBuffer.indexOf("\n");
+    }
+  });
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk;
+    process.stderr.write(`[r5d-worker] pty helper: ${chunk}`);
+  });
+  child.on("error", (error) => {
+    emittedTerminalEvent = true;
+    options.onError(error);
+  });
+  child.on("exit", (code, signal) => {
+    if (emittedTerminalEvent) {
+      return;
+    }
+    const detail = stderr.trim() || `node pty helper exited with code ${code ?? "unknown"}${signal ? ` signal ${signal}` : ""}`;
+    options.onError(new Error(detail));
+  });
+  sendToChild({
+    type: "open",
+    file: options.file,
+    args: options.args,
+    options: options.ptyOptions
+  });
+  return {
+    write(data) {
+      sendToChild({ type: "input", data: Buffer.from(data, "utf8").toString("base64") });
+    },
+    resize(cols, rows) {
+      sendToChild({ type: "resize", cols, rows });
+    },
+    kill() {
+      sendToChild({ type: "close" });
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill();
+        }
+      }, 500);
+    }
+  };
+}
+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,
+      syncRoot: input.syncRoot,
+      branchName: input.message.branchName,
+      manifest: input.manifest
+    });
+    const shell = resolveHostShell();
+    const ptyProcess = createNodePtyBridge({
+      file: shell.file,
+      args: shell.args,
+      ptyOptions: {
+        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.branchPath,
+        env: {
+          ...process.env,
+          ...input.message.env ?? {},
+          BUILD_IT_NOW_PROJECT_ID: input.projectId,
+          BUILD_IT_NOW_BRANCH_NAME: input.message.branchName
+        }
+      },
+      onOpened: () => {
+        sendWorkerMessage(input.ws, {
+          type: "pty_opened",
+          requestId: input.message.requestId,
+          ptyId: input.message.ptyId
+        });
+      },
+      onOutput: (data) => {
+        sendWorkerMessage(input.ws, {
+          type: "pty_output",
+          ptyId: input.message.ptyId,
+          data
+        });
+      },
+      onExit: (event) => {
+        activePtys.delete(input.message.ptyId);
+        sendWorkerMessage(input.ws, {
+          type: "pty_exit",
+          ptyId: input.message.ptyId,
+          exitCode: event.exitCode,
+          signal: event.signal
+        });
+      },
+      onError: (error) => {
+        activePtys.delete(input.message.ptyId);
+        sendWorkerMessage(input.ws, {
+          type: "pty_error",
+          requestId: input.message.requestId,
+          ptyId: input.message.ptyId,
+          error: error.message
+        });
+      }
+    });
+    activePtys.set(input.message.ptyId, ptyProcess);
+  } 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, label) {
+  const url = new URL("/worker/ws", baseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("label", label);
+  return url.toString();
+}
+function projectRootFor(projectsRoot, projectId, manifestByProjectId) {
+  return import_node_path.default.join(projectsRoot, manifestByProjectId.get(projectId)?.repoSlug ?? projectId);
+}
+async function startWorker(options) {
+  const config = readConfig(options.configPath);
+  const { baseUrl, token } = resolveCredentials(options, config);
+  const label = requireValue(options.label, "Missing required --label <label>");
+  validateLabel(label);
+  const projectsRoot = import_node_path.default.resolve(options.projectRoot ?? defaultProjectsRoot());
+  const syncRoot = import_node_path.default.resolve(options.syncRoot ?? process.env.R5D_SYNC_ROOT ?? defaultSyncRoot());
+  process.stdout.write(`[r5d-worker] label: ${label}
+`);
+  process.stdout.write(`[r5d-worker] projects root: ${projectsRoot}
+`);
+  process.stdout.write(`[r5d-worker] sync root: ${syncRoot}
+`);
+  process.stdout.write(`[r5d-worker] server: ${baseUrl}
+`);
+  runGit(["--version"]);
+  await verifyBinctlAuth(baseUrl, token);
+  import_node_fs.default.mkdirSync(projectsRoot, { recursive: true });
+  import_node_fs.default.mkdirSync(syncRoot, { recursive: true });
+  const manifestByProjectId = /* @__PURE__ */ new Map();
+  const ws = new WebSocket(websocketUrl(baseUrl, 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: projectsRoot
+      }
+    };
+    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 === "project_manifest") {
+        manifestByProjectId.clear();
+        for (const project of message.projects) {
+          manifestByProjectId.set(project.projectId, project);
+        }
+        process.stdout.write(`[r5d-worker] project manifest: ${message.projects.length} projects
+`);
+        for (const project of message.projects) {
+          const projectRoot = projectRootFor(projectsRoot, project.projectId, manifestByProjectId);
+          const branches = project.branches.length > 0 ? project.branches : [project.defaultBranch || "main"];
+          for (const branchName of branches) {
+            try {
+              await withBranchLock(project.projectId, branchName, async () => {
+                ensureBranchWorkspace({
+                  projectId: project.projectId,
+                  baseUrl,
+                  token,
+                  projectRoot,
+                  syncRoot,
+                  branchName,
+                  manifest: project
+                });
+              });
+            } catch (error) {
+              process.stderr.write(
+                `[r5d-worker] failed to sync ${project.repoSlug}/${branchName}: ${error instanceof Error ? error.message : String(error)}
+`
+              );
+            }
+          }
+        }
+        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") {
+        const manifest = manifestByProjectId.get(message.projectId);
+        const projectRoot = projectRootFor(projectsRoot, message.projectId, manifestByProjectId);
+        process.stdout.write(`[r5d-worker] pty ${message.ptyId}: ${message.projectId}/${message.branchName}
+`);
+        openPty({ ws, message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, manifest });
+        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") {
+        const manifest = manifestByProjectId.get(message.projectId);
+        const projectRoot = projectRootFor(projectsRoot, message.projectId, manifestByProjectId);
+        process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
+`);
+        const result = await withBranchLock(
+          message.projectId,
+          message.branchName,
+          () => executeCommand({ message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, manifest })
+        );
+        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 === "confirm_large_diff" || message.type === "pull_branch") {
+        try {
+          const manifest = manifestByProjectId.get(message.projectId);
+          const projectRoot = projectRootFor(projectsRoot, message.projectId, manifestByProjectId);
+          const result = await withBranchLock(
+            message.projectId,
+            message.branchName,
+            () => executeOperation({ message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, manifest })
+          );
+          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.options);
+}
+main().catch((error) => {
+  process.stderr.write(`[r5d-worker] ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exit(1);
+});