@odla-ai/harness 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,795 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli.ts
+var import_node_path4 = require("path");
+
+// src/client.ts
+var HarnessControlError = class extends Error {
+  constructor(message, status, code = "control_error") {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+  name = "HarnessControlError";
+};
+function createHarnessControlClient(options) {
+  const endpoint = options.endpoint.replace(/\/+$/, "");
+  let endpointUrl;
+  try {
+    endpointUrl = new URL(endpoint);
+  } catch {
+    throw new TypeError("endpoint must be an HTTPS URL");
+  }
+  const loopback = endpointUrl.hostname === "localhost" || endpointUrl.hostname === "127.0.0.1" || endpointUrl.hostname === "[::1]";
+  if (endpointUrl.username || endpointUrl.password || endpointUrl.protocol !== "https:" && !(loopback && endpointUrl.protocol === "http:")) {
+    throw new TypeError("endpoint must use HTTPS (HTTP is allowed only for loopback testing)");
+  }
+  if (!/^odla_hrn_[0-9a-f]{64}$/.test(options.token)) throw new TypeError("invalid harness runner credential");
+  const requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
+  if (!Number.isSafeInteger(requestTimeoutMs) || requestTimeoutMs < 1e3 || requestTimeoutMs > 12e4) {
+    throw new TypeError("requestTimeoutMs must be an integer from 1000 to 120000");
+  }
+  const request = options.fetch ?? fetch;
+  const call = async (path, body, allowEmpty = false) => {
+    const timeout = AbortSignal.timeout(requestTimeoutMs);
+    const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+    const response = await request(`${endpoint}${path}`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${options.token}`, "content-type": "application/json" },
+      body: JSON.stringify(body),
+      redirect: "error",
+      signal
+    });
+    if (allowEmpty && response.status === 204) return null;
+    const value = await response.json().catch(() => null);
+    if (!response.ok) throw new HarnessControlError(
+      value?.error?.message ?? `harness control request failed (${response.status})`,
+      response.status,
+      value?.error?.code
+    );
+    return value;
+  };
+  return {
+    lease: async (workspaces) => {
+      const body = await call("/registry/harness/lease", { workspaces }, true);
+      return body?.lease ?? null;
+    },
+    heartbeat: async (attemptId, leaseId) => {
+      const body = await call(
+        `/registry/harness/attempts/${encodeURIComponent(attemptId)}/heartbeat`,
+        { leaseId }
+      );
+      return body;
+    },
+    appendEvents: async (attemptId, leaseId, events) => {
+      await call(`/registry/harness/attempts/${encodeURIComponent(attemptId)}/events`, { leaseId, events });
+    },
+    infer: async (attemptId, leaseId, inference) => {
+      const body = await call(
+        `/registry/harness/attempts/${encodeURIComponent(attemptId)}/inference`,
+        { leaseId, ...inference }
+      );
+      return body;
+    },
+    complete: async (attemptId, leaseId, completion) => {
+      await call(`/registry/harness/attempts/${encodeURIComponent(attemptId)}/complete`, { leaseId, ...completion });
+    }
+  };
+}
+
+// src/container.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_process = require("process");
+
+// src/types.ts
+var HARNESS_PROTOCOL_VERSION = 1;
+
+// src/protocol.ts
+var CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/;
+var HarnessProtocolError = class extends Error {
+  name = "HarnessProtocolError";
+};
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function boundedText(value, label, max) {
+  if (typeof value !== "string" || !value || value.length > max || CONTROL.test(value)) {
+    throw new HarnessProtocolError(`${label} must be a non-empty string of at most ${max} characters`);
+  }
+  return value;
+}
+function parseAgentOutput(line) {
+  if (Buffer.byteLength(line, "utf8") > 1e6) throw new HarnessProtocolError("agent message exceeds 1 MB");
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    throw new HarnessProtocolError("agent emitted invalid JSON");
+  }
+  const message = record(value);
+  if (!message || message.protocolVersion !== HARNESS_PROTOCOL_VERSION) {
+    throw new HarnessProtocolError(`agent protocolVersion must be ${HARNESS_PROTOCOL_VERSION}`);
+  }
+  if (message.type === "event") {
+    return {
+      protocolVersion: HARNESS_PROTOCOL_VERSION,
+      type: "event",
+      kind: boundedText(message.kind, "event.kind", 120),
+      ...message.payload === void 0 ? {} : { payload: message.payload }
+    };
+  }
+  if (message.type === "inference.request") {
+    const call = record(message.call);
+    if (!call || !Array.isArray(call.messages) || !Number.isSafeInteger(call.maxTokens)) {
+      throw new HarnessProtocolError("inference.request.call requires messages and maxTokens");
+    }
+    return {
+      protocolVersion: HARNESS_PROTOCOL_VERSION,
+      type: "inference.request",
+      requestId: boundedText(message.requestId, "requestId", 180),
+      call
+    };
+  }
+  if (message.type === "tool.request") {
+    const input = record(message.input);
+    const tool = String(message.tool);
+    if (!input || !["sandbox.read", "sandbox.apply_patch", "sandbox.run_recipe"].includes(tool)) {
+      throw new HarnessProtocolError("tool.request requires a registered tool and object input");
+    }
+    return {
+      protocolVersion: HARNESS_PROTOCOL_VERSION,
+      type: "tool.request",
+      requestId: boundedText(message.requestId, "requestId", 180),
+      tool,
+      input
+    };
+  }
+  if (message.type === "attempt.complete") {
+    if (!(/* @__PURE__ */ new Set(["completed", "failed", "cancelled"])).has(String(message.status))) {
+      throw new HarnessProtocolError("attempt.complete.status is invalid");
+    }
+    return {
+      protocolVersion: HARNESS_PROTOCOL_VERSION,
+      type: "attempt.complete",
+      status: message.status,
+      ...message.result === void 0 ? {} : { result: message.result }
+    };
+  }
+  throw new HarnessProtocolError("agent message type is unsupported");
+}
+function encodeAgentInput(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+function makeHarnessEvent(kind, actor, payload, now = Date.now(), id = crypto.randomUUID()) {
+  boundedText(kind, "event.kind", 120);
+  return { eventId: id, kind, actor, payload, createdAt: now };
+}
+
+// src/container.ts
+var DIGEST_IMAGE = /^[a-z0-9][a-z0-9._/-]*(?::[a-zA-Z0-9._-]+)?@sha256:[0-9a-f]{64}$/;
+function assertPinnedImage(image) {
+  if (!DIGEST_IMAGE.test(image)) throw new TypeError("container image must be pinned by sha256 digest");
+}
+async function commandAvailable(engine) {
+  for (const directory of (process.env.PATH ?? "").split(import_node_path.delimiter).filter(Boolean)) {
+    try {
+      await (0, import_promises.access)((0, import_node_path.join)(directory, engine), import_node_fs.constants.X_OK);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function selectContainerEngine(requested = "auto", options = {}) {
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const uid = options.uid ?? (typeof import_node_process.getuid === "function" ? (0, import_node_process.getuid)() : 1e3);
+  const available = options.available ?? commandAvailable;
+  const validate = async (engine) => {
+    if (engine === "container" && (platform !== "darwin" || arch !== "arm64")) {
+      throw new TypeError("Apple container requires Apple Silicon macOS");
+    }
+    if (engine === "podman" && platform === "linux" && uid === 0) {
+      throw new TypeError("the Linux harness requires rootless Podman; do not run the runner as root");
+    }
+    if (!await available(engine)) throw new TypeError(`${engine} is not installed or executable`);
+    return engine;
+  };
+  if (requested !== "auto") return validate(requested);
+  const candidates = platform === "darwin" ? arch === "arm64" ? ["container", "podman"] : ["podman"] : platform === "linux" ? ["podman"] : [];
+  for (const engine of candidates) {
+    if (await available(engine)) return validate(engine);
+  }
+  if (platform === "linux") {
+    throw new TypeError("no rootless Podman found; install Podman or explicitly choose --engine docker after reviewing its daemon boundary");
+  }
+  if (platform === "darwin") {
+    throw new TypeError("Apple container is not installed; on Apple Silicon macOS 26 run `brew install container`, then retry (Podman Machine is the fallback)");
+  }
+  throw new TypeError("no supported container engine found");
+}
+function inspectRootlessPodman() {
+  return new Promise((resolve3, reject) => {
+    (0, import_node_child_process.execFile)(
+      "podman",
+      ["info", "--format", "{{.Host.Security.Rootless}}"],
+      { encoding: "utf8", maxBuffer: 16 * 1024, timeout: 1e4 },
+      (error, stdout) => {
+        if (error) {
+          reject(new TypeError("could not verify that the active Podman service is rootless"));
+          return;
+        }
+        resolve3(stdout.trim() === "true");
+      }
+    );
+  });
+}
+async function verifyContainerEngineBoundary(engine, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const uid = options.uid ?? (typeof import_node_process.getuid === "function" ? (0, import_node_process.getuid)() : 1e3);
+  if (engine === "container" && (platform !== "darwin" || arch !== "arm64")) {
+    throw new TypeError("Apple container requires Apple Silicon macOS");
+  }
+  if (engine !== "podman" || platform !== "linux") return;
+  if (uid === 0) throw new TypeError("the Linux harness requires rootless Podman; do not run the runner as root");
+  const rootless = await (options.podmanRootless ?? inspectRootlessPodman)();
+  if (!rootless) throw new TypeError("the active Podman service is not rootless; refusing to run the harness");
+}
+function buildContainerRunArgs(options) {
+  if (!options.allowUnpinnedImage) assertPinnedImage(options.image);
+  if (/[,\r\n]/.test(options.workspaceDir)) throw new TypeError("workspace path contains unsupported mount characters");
+  const uid = typeof import_node_process.getuid === "function" ? (0, import_node_process.getuid)() : 1e3;
+  const gid = typeof import_node_process.getgid === "function" ? (0, import_node_process.getgid)() : 1e3;
+  const safeAttempt = options.task.attemptId.toLowerCase().replace(/[^a-z0-9_.-]/g, "-").slice(0, 40);
+  const name = `odla-harness-${safeAttempt}-${crypto.randomUUID().slice(0, 8)}`;
+  const limits = options.limits ?? {};
+  const access2 = options.workspaceAccess ?? "read-write";
+  const appleMount = access2 === "none" ? [] : [`--mount=type=bind,source=${options.workspaceDir},target=/workspace${access2 === "read-only" ? ",readonly" : ""}`];
+  const ociMount = access2 === "none" ? [] : [`--mount=type=bind,src=${options.workspaceDir},dst=/workspace${access2 === "read-only" ? ",readonly" : ""}`];
+  if (options.engine === "container") {
+    return [
+      "run",
+      "--rm",
+      "--interactive",
+      `--name=${name}`,
+      "--network=none",
+      "--read-only",
+      "--cap-drop=ALL",
+      `--memory=${limits.memory ?? "1g"}`,
+      `--cpus=${limits.cpus ?? 1}`,
+      `--user=${uid}:${gid}`,
+      "--tmpfs=/tmp",
+      ...appleMount,
+      "--workdir=/workspace",
+      `--env=ODLA_HARNESS_PROTOCOL=${HARNESS_PROTOCOL_VERSION}`,
+      `--label=ai.odla.harness.attempt=${options.task.attemptId}`,
+      options.image
+    ];
+  }
+  return [
+    "run",
+    "--rm",
+    "--interactive",
+    `--name=${name}`,
+    "--pull=never",
+    "--network=none",
+    "--read-only",
+    "--cap-drop=ALL",
+    "--security-opt=no-new-privileges",
+    `--pids-limit=${limits.pids ?? 256}`,
+    `--memory=${limits.memory ?? "1g"}`,
+    `--cpus=${limits.cpus ?? 1}`,
+    `--user=${uid}:${gid}`,
+    `--tmpfs=/tmp:rw,noexec,nosuid,nodev,size=${limits.tmpfsBytes ?? 64 * 1024 * 1024}`,
+    ...ociMount,
+    "--workdir=/workspace",
+    `--env=ODLA_HARNESS_PROTOCOL=${HARNESS_PROTOCOL_VERSION}`,
+    `--label=ai.odla.harness.attempt=${options.task.attemptId}`,
+    options.image
+  ];
+}
+function containerName(args) {
+  return args.find((arg) => arg.startsWith("--name=")).slice("--name=".length);
+}
+async function runContainerAttempt(options) {
+  if (options.signal?.aborted) return { exitCode: 1, status: "cancelled", stderr: "" };
+  await verifyContainerEngineBoundary(options.engine);
+  const args = buildContainerRunArgs(options);
+  const name = containerName(args);
+  const child = (0, import_node_child_process.spawn)(options.engine, args, { stdio: ["pipe", "pipe", "pipe"], shell: false });
+  let stderr = "";
+  let outputBytes = 0;
+  let complete = null;
+  let stopped = false;
+  let exited = false;
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (text) => {
+    if (stderr.length < 64 * 1024) stderr += text.slice(0, 64 * 1024 - stderr.length);
+  });
+  const stop = (reason) => {
+    if (stopped || exited) return;
+    stopped = true;
+    if (!child.stdin.destroyed) {
+      const cancel = { protocolVersion: HARNESS_PROTOCOL_VERSION, type: "attempt.cancel", reason };
+      child.stdin.write(encodeAgentInput(cancel));
+    }
+    const removeArgs = options.engine === "container" ? ["delete", "--force", name] : ["rm", "-f", name];
+    const killer = (0, import_node_child_process.spawn)(options.engine, removeArgs, { stdio: "ignore", shell: false });
+    killer.unref();
+  };
+  const abort = () => stop("runner_cancelled");
+  options.signal?.addEventListener("abort", abort, { once: true });
+  const timeout = setTimeout(() => stop("timeout"), options.task.policy.timeoutMs);
+  const start = { protocolVersion: HARNESS_PROTOCOL_VERSION, type: "task.start", task: options.task };
+  if (!stopped && !options.signal?.aborted) child.stdin.write(encodeAgentInput(start));
+  const consume = (async () => {
+    let pending = Buffer.alloc(0);
+    const handleLine = async (raw) => {
+      const bytes = raw.at(-1) === 13 ? raw.subarray(0, -1) : raw;
+      if (bytes.byteLength > 1e6) throw new Error("agent message exceeds 1 MB");
+      const line = bytes.toString("utf8");
+      if (!line.trim()) return;
+      const message = parseAgentOutput(line);
+      if (message.type === "attempt.complete") complete = message;
+      const response = await options.onMessage(message);
+      if (response && !child.stdin.destroyed) child.stdin.write(encodeAgentInput(response));
+    };
+    try {
+      for await (const raw of child.stdout) {
+        const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+        outputBytes += chunk.byteLength;
+        if (outputBytes > options.task.policy.maxOutputBytes) {
+          throw new Error(`agent output exceeds ${options.task.policy.maxOutputBytes} bytes`);
+        }
+        pending = Buffer.concat([pending, chunk]);
+        let newline = pending.indexOf(10);
+        while (newline >= 0) {
+          await handleLine(pending.subarray(0, newline));
+          pending = pending.subarray(newline + 1);
+          newline = pending.indexOf(10);
+        }
+        if (pending.byteLength > 1e6) throw new Error("agent message exceeds 1 MB");
+      }
+      if (pending.byteLength) await handleLine(pending);
+    } catch (error) {
+      stop("protocol_error");
+      throw error;
+    }
+  })();
+  const exit = new Promise((accept, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      exited = true;
+      accept(code ?? 1);
+    });
+  });
+  try {
+    const [exitCode] = await Promise.all([exit, consume]);
+    if (stderr && options.onStderr) await options.onStderr(stderr);
+    if (options.signal?.aborted) return { exitCode, status: "cancelled", stderr };
+    const terminal = complete;
+    if (!terminal) return { exitCode, status: "failed", result: { error: "agent exited without completion" }, stderr };
+    return { exitCode, status: exitCode === 0 ? terminal.status : "failed", result: terminal.result, stderr };
+  } catch (error) {
+    stop("runner_error");
+    await exit.catch(() => 1);
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+    options.signal?.removeEventListener("abort", abort);
+  }
+}
+
+// src/runner.ts
+var import_promises3 = require("timers/promises");
+
+// src/workspace.ts
+var import_promises2 = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path3 = require("path");
+var import_node_child_process2 = require("child_process");
+
+// src/workspace-policy.ts
+var import_node_path2 = require("path");
+var SKIP_WORKSPACE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".odla",
+  ".wrangler",
+  "node_modules",
+  "dist",
+  "coverage"
+]);
+var SECRET_WORKSPACE_FILE = /^(?:\.env(?:\..+)?|\.dev\.vars|\.dev-token(?:\..+)?|credentials(?:\..+)?\.json|dev-token(?:\..+)?(?:\.json)?)$/i;
+function allowedWorkspacePath(relativePath) {
+  const parts = relativePath.split("/");
+  return !(0, import_node_path2.isAbsolute)(relativePath) && !relativePath.includes("\\") && !relativePath.includes("\0") && !parts.some((part) => !part || part === "." || part === ".." || SKIP_WORKSPACE_DIRS.has(part)) && !SECRET_WORKSPACE_FILE.test(parts.at(-1) ?? "");
+}
+
+// src/workspace.ts
+async function sourceFiles(sourceDir, maxFiles, maxBytes) {
+  const files = [];
+  let bytes = 0;
+  const walk = async (dir) => {
+    for (const entry of await (0, import_promises2.readdir)(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && SKIP_WORKSPACE_DIRS.has(entry.name)) continue;
+      if (!entry.isDirectory() && SECRET_WORKSPACE_FILE.test(entry.name)) continue;
+      const path = (0, import_node_path3.join)(dir, entry.name);
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) {
+        await walk(path);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const metadata = await (0, import_promises2.stat)(path);
+      bytes += metadata.size;
+      if (files.length + 1 > maxFiles) throw new Error(`workspace exceeds ${maxFiles} files`);
+      if (bytes > maxBytes) throw new Error(`workspace exceeds ${maxBytes} bytes`);
+      files.push({
+        source: path,
+        relativePath: (0, import_node_path3.relative)(sourceDir, path),
+        mode: metadata.mode & 511,
+        bytes: metadata.size
+      });
+    }
+  };
+  await walk(sourceDir);
+  return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+async function gitSourceFiles(sourceDir, maxFiles, maxBytes) {
+  const child = (0, import_node_child_process2.spawn)("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    cwd: sourceDir,
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false
+  });
+  const stdout = [];
+  const stderr = [];
+  let outputBytes = 0;
+  child.stdout.on("data", (chunk) => {
+    outputBytes += chunk.byteLength;
+    if (outputBytes > 8 * 1024 * 1024) child.kill("SIGKILL");
+    else stdout.push(chunk);
+  });
+  child.stderr.on("data", (chunk) => {
+    if (stderr.reduce((sum, value) => sum + value.byteLength, 0) < 16384) stderr.push(chunk);
+  });
+  const code = await new Promise((accept, reject) => {
+    child.once("error", reject);
+    child.once("exit", accept);
+  });
+  if (outputBytes > 8 * 1024 * 1024) throw new Error("git file inventory exceeds 8 MiB");
+  if (code !== 0) throw new Error(`git file inventory failed: ${Buffer.concat(stderr).toString("utf8").slice(0, 1e3)}`);
+  const paths = Buffer.concat(stdout).toString("utf8").split("\0").filter(Boolean).sort();
+  if (paths.length > maxFiles) throw new Error(`workspace exceeds ${maxFiles} files`);
+  const root = (0, import_node_path3.resolve)(sourceDir);
+  const files = [];
+  let bytes = 0;
+  for (const relativePath of paths) {
+    if (!allowedWorkspacePath(relativePath)) continue;
+    const source = (0, import_node_path3.resolve)(root, relativePath);
+    if (!source.startsWith(`${root}${import_node_path3.sep}`)) throw new TypeError("git file path escapes workspace");
+    let metadata;
+    try {
+      metadata = await (0, import_promises2.lstat)(source);
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    if (metadata.isSymbolicLink() || !metadata.isFile()) continue;
+    bytes += metadata.size;
+    if (bytes > maxBytes) throw new Error(`workspace exceeds ${maxBytes} bytes`);
+    files.push({ source, relativePath, mode: metadata.mode & 511, bytes: metadata.size });
+  }
+  return files;
+}
+async function copyTree(files, destination) {
+  for (const file of files) {
+    const target = (0, import_node_path3.join)(destination, file.relativePath);
+    await (0, import_promises2.mkdir)((0, import_node_path3.resolve)(target, ".."), { recursive: true });
+    await (0, import_promises2.copyFile)(file.source, target);
+    await (0, import_promises2.chmod)(target, file.mode);
+  }
+}
+async function captureGitDiff(root, maxBytes) {
+  const child = (0, import_node_child_process2.spawn)("git", [
+    "diff",
+    "--no-index",
+    "--binary",
+    "--no-ext-diff",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    "--",
+    "baseline",
+    "workspace"
+  ], { cwd: root, stdio: ["ignore", "pipe", "pipe"], shell: false });
+  const stdout = [];
+  const stderr = [];
+  let bytes = 0;
+  child.stdout.on("data", (chunk) => {
+    bytes += chunk.byteLength;
+    if (bytes > maxBytes) child.kill("SIGKILL");
+    else stdout.push(chunk);
+  });
+  child.stderr.on("data", (chunk) => {
+    if (stderr.reduce((sum, value) => sum + value.byteLength, 0) < 16384) stderr.push(chunk);
+  });
+  const code = await new Promise((accept, reject) => {
+    child.once("error", reject);
+    child.once("exit", accept);
+  });
+  if (bytes > maxBytes) throw new Error(`patch exceeds ${maxBytes} bytes`);
+  if (code !== 0 && code !== 1) {
+    throw new Error(`git diff failed: ${Buffer.concat(stderr).toString("utf8").slice(0, 1e3)}`);
+  }
+  return Buffer.concat(stdout).toString("utf8").replaceAll("a/baseline/", "a/").replaceAll("a/workspace/", "a/").replaceAll("b/baseline/", "b/").replaceAll("b/workspace/", "b/").replaceAll("--- a/baseline", "--- a").replaceAll("+++ b/workspace", "+++ b");
+}
+async function stageWorkspace(source, options = {}) {
+  const sourceDir = await (0, import_promises2.realpath)((0, import_node_path3.resolve)(source));
+  const sourceStat = await (0, import_promises2.stat)(sourceDir);
+  if (!sourceStat.isDirectory()) throw new TypeError("workspace source must be a directory");
+  const root = await (0, import_promises2.mkdtemp)((0, import_node_path3.join)(options.tempRoot ?? (0, import_node_os.tmpdir)(), "odla-harness-"));
+  const baselineDir = (0, import_node_path3.join)(root, "baseline");
+  const workspaceDir = (0, import_node_path3.join)(root, "workspace");
+  await Promise.all([(0, import_promises2.mkdir)(baselineDir), (0, import_promises2.mkdir)(workspaceDir)]);
+  try {
+    const maxFiles = options.maxFiles ?? 2e4;
+    const maxBytes = options.maxBytes ?? 512 * 1024 * 1024;
+    const files = options.gitTrackedAndUnignored ? await gitSourceFiles(sourceDir, maxFiles, maxBytes) : await sourceFiles(sourceDir, maxFiles, maxBytes);
+    await Promise.all([copyTree(files, baselineDir), copyTree(files, workspaceDir)]);
+    return {
+      root,
+      baselineDir,
+      workspaceDir,
+      fileCount: files.length,
+      byteCount: files.reduce((sum, file) => sum + file.bytes, 0),
+      patch: (maxBytes2) => captureGitDiff(root, maxBytes2),
+      cleanup: () => (0, import_promises2.rm)(root, { recursive: true, force: true })
+    };
+  } catch (error) {
+    await (0, import_promises2.rm)(root, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+// src/runner.ts
+async function append(control, lease, kind, actor, payload) {
+  await control.appendEvents(lease.task.attemptId, lease.leaseId, [makeHarnessEvent(kind, actor, payload)]);
+}
+async function runLeasedAttempt(lease, options) {
+  const source = options.workspaces[lease.task.workspace];
+  if (!source) {
+    await options.control.complete(lease.task.attemptId, lease.leaseId, {
+      status: "failed",
+      error: `runner does not expose workspace "${lease.task.workspace}"`
+    });
+    return;
+  }
+  let staged = null;
+  const controller = new AbortController();
+  const cancelFromParent = () => controller.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", cancelFromParent, { once: true });
+  if (options.signal?.aborted) controller.abort(options.signal.reason);
+  let heartbeat;
+  let heartbeatInFlight = false;
+  const pulse = async () => {
+    if (heartbeatInFlight || controller.signal.aborted) return;
+    heartbeatInFlight = true;
+    try {
+      const value = await options.control.heartbeat(lease.task.attemptId, lease.leaseId);
+      if (value.cancelRequested) controller.abort("cancel_requested");
+    } catch {
+      controller.abort("heartbeat_failed");
+    } finally {
+      heartbeatInFlight = false;
+    }
+  };
+  try {
+    await pulse();
+    heartbeat = setInterval(() => {
+      void pulse();
+    }, options.heartbeatMs ?? 15e3);
+    if (controller.signal.aborted) throw new Error("lease was cancelled before workspace staging");
+    staged = await stageWorkspace(source);
+    if (controller.signal.aborted) throw new Error("lease was cancelled during workspace staging");
+    const stagedWorkspace = staged;
+    await append(options.control, lease, "runner.workspace_staged", "runner", {
+      workspace: lease.task.workspace,
+      files: stagedWorkspace.fileCount,
+      bytes: stagedWorkspace.byteCount
+    });
+    const result = await runContainerAttempt({
+      engine: options.engine,
+      image: options.image,
+      workspaceDir: stagedWorkspace.workspaceDir,
+      task: lease.task,
+      limits: options.limits,
+      allowUnpinnedImage: options.allowUnpinnedImage,
+      workspaceAccess: options.workspaceAccess ?? (options.toolBroker ? "none" : "read-write"),
+      signal: controller.signal,
+      onStderr: async (text) => {
+        await append(options.control, lease, "agent.stderr", "agent", { text: text.slice(0, 64 * 1024) });
+      },
+      onMessage: async (message) => {
+        if (message.type === "event") {
+          await append(options.control, lease, message.kind, "agent", message.payload ?? null);
+          return;
+        }
+        if (message.type === "attempt.complete") {
+          await append(options.control, lease, "agent.completed", "agent", {
+            status: message.status,
+            result: message.result ?? null
+          });
+          return;
+        }
+        if (message.type === "tool.request") {
+          await append(options.control, lease, "tool.requested", "agent", {
+            requestId: message.requestId,
+            tool: message.tool
+          });
+          const response2 = options.toolBroker ? await options.toolBroker.execute({
+            lease,
+            workspaceDir: stagedWorkspace.workspaceDir,
+            signal: controller.signal
+          }, message) : { requestId: message.requestId, ok: false, content: "tool denied: no trusted broker configured" };
+          await append(options.control, lease, "tool.responded", "system", {
+            requestId: message.requestId,
+            tool: message.tool,
+            ok: response2.ok,
+            contentBytes: Buffer.byteLength(response2.content)
+          });
+          return { protocolVersion: HARNESS_PROTOCOL_VERSION, type: "tool.response", ...response2 };
+        }
+        await append(options.control, lease, "model.requested", "agent", {
+          requestId: message.requestId,
+          messages: message.call.messages.length,
+          maxTokens: message.call.maxTokens
+        });
+        const response = await options.control.infer(lease.task.attemptId, lease.leaseId, {
+          requestId: message.requestId,
+          call: message.call
+        });
+        await append(options.control, lease, "model.responded", "model", {
+          requestId: message.requestId,
+          response: response.response,
+          receipt: response.receipt
+        });
+        return {
+          protocolVersion: HARNESS_PROTOCOL_VERSION,
+          type: "inference.response",
+          requestId: message.requestId,
+          response: response.response
+        };
+      }
+    });
+    const patch = await stagedWorkspace.patch(lease.task.policy.maxPatchBytes);
+    await options.control.complete(lease.task.attemptId, lease.leaseId, {
+      status: result.status,
+      result: result.result,
+      patch,
+      ...result.status === "failed" ? { error: result.stderr.slice(0, 4e3) || "container attempt failed" } : {}
+    });
+  } catch (reason) {
+    const message = reason instanceof Error ? reason.message : "runner failed";
+    try {
+      await append(options.control, lease, "runner.failed", "runner", { message });
+      await options.control.complete(lease.task.attemptId, lease.leaseId, {
+        status: controller.signal.aborted ? "cancelled" : "failed",
+        error: message
+      });
+    } catch {
+    }
+  } finally {
+    if (heartbeat) clearInterval(heartbeat);
+    options.signal?.removeEventListener("abort", cancelFromParent);
+    if (staged && !options.preserveWorkspace) await staged.cleanup();
+  }
+}
+async function runHarnessRunner(options) {
+  const workspaceNames = Object.keys(options.workspaces).sort();
+  if (!workspaceNames.length) throw new TypeError("at least one workspace mapping is required");
+  do {
+    if (options.signal?.aborted) return;
+    const lease = await options.control.lease(workspaceNames);
+    if (lease) {
+      options.log?.(`leased ${lease.task.taskId}/${lease.task.attemptId}`);
+      await runLeasedAttempt(lease, options);
+      if (options.once) return;
+      continue;
+    }
+    if (options.once) return;
+    await (0, import_promises3.setTimeout)(options.pollMs ?? 2e3, void 0, { signal: options.signal }).catch(() => {
+    });
+  } while (!options.signal?.aborted);
+}
+
+// src/cli.ts
+function usage() {
+  return `Usage:
+  ODLA_HARNESS_TOKEN=odla_hrn_... odla-harness runner \\
+    --endpoint https://odla.ai \\
+    --workspace my-repo=/absolute/path \\
+    --image registry.example/agent@sha256:<digest> [--engine auto|container|podman|docker] [--once]
+
+The token is read only from ODLA_HARNESS_TOKEN so it does not enter shell history.
+Images must be digest-pinned. Network is disabled inside the container.
+Auto prefers Apple container on macOS and rootless Podman on Linux.`;
+}
+function parse(argv) {
+  if (argv[0] !== "runner") throw new TypeError(usage());
+  const values = {};
+  const flags = /* @__PURE__ */ new Set();
+  for (let index = 1; index < argv.length; index++) {
+    const arg = argv[index];
+    if (["--once", "--preserve-workspace", "--allow-unpinned-image"].includes(arg)) {
+      flags.add(arg);
+      continue;
+    }
+    if (!arg.startsWith("--") || !argv[index + 1]) throw new TypeError(`missing value for ${arg}`);
+    (values[arg] ??= []).push(argv[++index]);
+  }
+  const endpoint = values["--endpoint"]?.at(-1);
+  const image = values["--image"]?.at(-1);
+  const engine = values["--engine"]?.at(-1) ?? "auto";
+  if (!endpoint || !image || !["auto", "container", "podman", "docker"].includes(engine)) throw new TypeError(usage());
+  const workspaces = {};
+  for (const mapping of values["--workspace"] ?? []) {
+    const equals = mapping.indexOf("=");
+    const key = mapping.slice(0, equals);
+    const path = mapping.slice(equals + 1);
+    if (equals < 1 || !/^[a-z0-9][a-z0-9_-]{0,79}$/.test(key) || !path) {
+      throw new TypeError(`invalid workspace mapping: ${mapping}`);
+    }
+    workspaces[key] = (0, import_node_path4.resolve)(path);
+  }
+  if (!Object.keys(workspaces).length) throw new TypeError("at least one --workspace key=/absolute/path is required");
+  const allowUnpinnedImage = flags.has("--allow-unpinned-image");
+  if (allowUnpinnedImage && process.env.ODLA_HARNESS_UNSAFE_TESTING !== "1") {
+    throw new TypeError("--allow-unpinned-image requires ODLA_HARNESS_UNSAFE_TESTING=1");
+  }
+  const pollMs = Number(values["--poll-ms"]?.at(-1) ?? 2e3);
+  if (!Number.isSafeInteger(pollMs) || pollMs < 250 || pollMs > 6e4) {
+    throw new TypeError("--poll-ms must be an integer from 250 to 60000");
+  }
+  return {
+    endpoint,
+    image,
+    engine,
+    workspaces,
+    once: flags.has("--once"),
+    pollMs,
+    preserveWorkspace: flags.has("--preserve-workspace"),
+    allowUnpinnedImage
+  };
+}
+async function main() {
+  const token = process.env.ODLA_HARNESS_TOKEN;
+  if (!token) throw new TypeError("ODLA_HARNESS_TOKEN is required");
+  const options = parse(process.argv.slice(2));
+  const controller = new AbortController();
+  for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => controller.abort(signal));
+  const engine = await selectContainerEngine(options.engine);
+  if (process.platform === "linux" && engine === "docker") {
+    process.stderr.write("[odla-harness] warning: explicit Docker on Linux may use a rootful daemon; rootless Podman is preferred\n");
+  }
+  await runHarnessRunner({
+    ...options,
+    engine,
+    control: createHarnessControlClient({ endpoint: options.endpoint, token, signal: controller.signal }),
+    signal: controller.signal,
+    log: (message) => process.stderr.write(`[odla-harness] ${message}
+`)
+  });
+}
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.cjs.map