0sec-cli 0.23.0 → 0.24.0

package/chunks/{chunk-PIR6BNE7.js → chunk-TOFIGQ63.js}

@@ -3,10 +3,10 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   executeWorkflow
-} from "./chunk-4HGGNBKK.js";
+} from "./chunk-V5I5GAQH.js";
 import {
   SecurityWorkflowStore
-} from "./chunk-T7ZEVY5G.js";
+} from "./chunk-RCHAFSWS.js";
 
 // packages/cli/src/managed-operation.ts
 async function executeManagedOperation(options, dependencies = { store: (path) => new SecurityWorkflowStore(path) }) {

package/chunks/{chunk-V2BWXPZP.js → chunk-TTDFBFNZ.js}

@@ -6,22 +6,22 @@ import {
 } from "./chunk-HLFS6WV2.js";
 import {
   agenticScan
-} from "./chunk-4HGGNBKK.js";
+} from "./chunk-V5I5GAQH.js";
 import {
   runAgentLoop
-} from "./chunk-P7KDN5PK.js";
+} from "./chunk-CSPF47S3.js";
 import {
   getToolsForRole
-} from "./chunk-EH2WTNY7.js";
+} from "./chunk-A3EKBUEM.js";
 import {
   createRuntime
-} from "./chunk-UZUELPFW.js";
+} from "./chunk-EXTN4SQV.js";
 import {
   osecDB
-} from "./chunk-T7ZEVY5G.js";
+} from "./chunk-RCHAFSWS.js";
 import {
   LlmApiRuntime
-} from "./chunk-BF5FIK7H.js";
+} from "./chunk-EYBMTELO.js";
 
 // packages/cli/src/commands/orchestrate.ts
 import { randomUUID } from "node:crypto";

package/chunks/{chunk-WYNZFNMF.js → chunk-TZRHWP7R.js}

@@ -3,7 +3,7 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   resolveOsecDbPath
-} from "./chunk-T7ZEVY5G.js";
+} from "./chunk-RCHAFSWS.js";
 import {
   BACKEND_PROTOCOL_VERSION,
   BackendDescriptorSchema,
@@ -12,15 +12,215 @@ import {
   backendCapabilitiesForApiPath,
   homeStateDir,
   parseBackendHandshake
-} from "./chunk-LTEE2JWK.js";
+} from "./chunk-RZR2XXAK.js";
 import {
   external_exports
 } from "./chunk-VIT5ALXF.js";
 
+// packages/cli/src/worker-deploy.ts
+import { execFileSync, spawn, spawnSync } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+var REMOTE_DIR = "/tmp/zero-engine";
+var REMOTE_DEPS = {
+  "drizzle-orm": "^0.45.2",
+  "node-sqlite3-wasm": "^0.8.55",
+  "pdfkit": "^0.15.2",
+  "playwright": "1.60.0",
+  "react": "^19.2.4",
+  "react-dom": "^19.2.4",
+  "tree-sitter": `file:${REMOTE_DIR}/vendor/tree-sitter-0.21.1-node24.tgz`,
+  "tree-sitter-c": "0.21.4",
+  "@opentui/core": "0.5.4",
+  "@opentui/react": "0.5.4"
+};
+var SSH_HOST_PATTERN = /^[A-Za-z0-9._@-]+$/;
+var LIMA_NAME_PATTERN = /^[\w.-]+$/;
+var TARGET_GIT_PATTERN = /^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^\s'"]+$/;
+var sq = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+function resolveWorkerRepoRoot(moduleUrl = import.meta.url) {
+  let directory = dirname(fileURLToPath(moduleUrl));
+  while (true) {
+    if ((existsSync(join(directory, "dist/0.js")) || existsSync(join(directory, "0.js"))) && existsSync(join(directory, "vendor/tree-sitter-0.21.1-node24.tgz"))) return directory;
+    const parent = dirname(directory);
+    if (parent === directory) throw new Error("Worker deployment requires the built CLI dist/ and vendor/ assets. Run pnpm build first.");
+    directory = parent;
+  }
+}
+function validateWorkerOptions(options) {
+  if (options.enginePort !== void 0 && (!Number.isInteger(options.enginePort) || options.enginePort < 1 || options.enginePort > 65535)) throw new Error("enginePort must be 1-65535");
+  if (options.ssh && (!SSH_HOST_PATTERN.test(options.ssh) || options.ssh.startsWith("-"))) {
+    throw new Error("--ssh must be an OpenSSH host name or user@host (no options or shell characters)");
+  }
+  if (options.lima && !LIMA_NAME_PATTERN.test(options.lima)) throw new Error("--lima must be an instance name (letters, digits, ., _, -)");
+  if (options.targetGit && !TARGET_GIT_PATTERN.test(options.targetGit)) throw new Error("--target-git must be a URL without whitespace or quotes");
+}
+function createRunner(options) {
+  if (options.ssh) {
+    const host = options.ssh;
+    const configArgs = options.sshConfig ? ["-F", options.sshConfig] : [];
+    return {
+      label: host,
+      shell: (command, timeout = 3e5) => execFileSync("ssh", ["-o", "BatchMode=yes", "-o", "ConnectTimeout=15", ...configArgs, "--", host, "bash", "-s"], { input: command, encoding: "utf8", timeout }),
+      copy: (local, remote) => execFileSync("scp", ["-q", "-o", "BatchMode=yes", ...configArgs, "--", local, `${host}:${remote}`], { stdio: "inherit", timeout: 6e5 }),
+      tunnel: (port) => {
+        const child = spawn("ssh", ["-o", "BatchMode=yes", ...configArgs, "-N", "-L", `${port}:127.0.0.1:${port}`, "--", host], { stdio: "ignore", detached: true });
+        child.unref();
+        return child.pid;
+      }
+    };
+  }
+  const vm = options.lima ?? "zero-worker";
+  return {
+    label: vm,
+    shell: (command, timeout = 3e5) => execFileSync("limactl", ["shell", vm, "--", "bash", "-s"], { input: command, encoding: "utf8", timeout }),
+    copy: (local, remote) => execFileSync("limactl", ["copy", local, `${vm}:${remote}`], { stdio: "inherit", timeout: 6e5 }),
+    tunnel: (port) => {
+      const configPath = "/tmp/zero-worker-ssh.conf";
+      writeFileSync(configPath, execFileSync("limactl", ["show-ssh", "--format", "config", vm], { encoding: "utf8" }), { mode: 384 });
+      const child = spawn("ssh", ["-F", configPath, "-N", "-L", `${port}:127.0.0.1:${port}`, `lima-${vm}`], { stdio: "ignore", detached: true });
+      child.unref();
+      return child.pid;
+    }
+  };
+}
+async function deployWorker(options, runner = createRunner(options)) {
+  validateWorkerOptions(options);
+  const repoRoot = options.repoRoot ?? resolveWorkerRepoRoot();
+  const port = options.enginePort ?? 2e4 + Number.parseInt(createHash("sha256").update(runner.label).digest("hex").slice(0, 4), 16) % 2e4;
+  const token = createHash("sha256").update(randomBytes(32)).digest("hex");
+  const identity = createHash("sha256").update(`${options.ssh ? "ssh" : "lima"}:${runner.label}`).digest("hex").slice(0, 12);
+  const backendId = `${options.ssh ? "ssh" : "lima"}-worker-${identity}`;
+  const tokenEnv = `ZERO_WORKER_${identity.toUpperCase()}_TOKEN`;
+  const { shell } = runner;
+  if (!options.ssh) {
+    const status = execFileSync("limactl", ["list", "--format", "{{.Status}}", runner.label], { encoding: "utf8" }).trim();
+    if (status !== "Running") throw new Error(`VM ${runner.label} is ${status}; start it first`);
+  }
+  shell("uname -srm");
+  const nodeVersion = shell("command -v node >/dev/null && node --version || echo none").trim();
+  if (!(nodeVersion.startsWith("v2") && Number(nodeVersion.slice(1).split(".")[0]) >= 24)) {
+    const arch = shell("uname -m").trim() === "aarch64" ? "arm64" : "x64";
+    shell(`cd /tmp && curl -fsSL https://nodejs.org/dist/v24.14.0/node-v24.14.0-linux-${arch}.tar.xz -o node.tar.xz && sudo tar -xJf node.tar.xz -C /usr/local --strip-components=1 && node --version`, 6e5);
+  }
+  const clangVersion = shell("command -v clang >/dev/null && clang --version | head -1 || echo none").trim();
+  if (clangVersion === "none") {
+    shell("sudo apt-get update -qq && sudo apt-get install -y -qq clang build-essential python3 >/dev/null && clang --version | head -1", 9e5);
+  }
+  const staging = mkdtempSync(join(tmpdir(), "zero-worker-"));
+  try {
+    const bundleRoot = existsSync(join(repoRoot, "dist/0.js")) ? repoRoot : staging;
+    if (bundleRoot === staging) {
+      mkdirSync(join(staging, "dist"));
+      for (const asset of ["0.js", "cli-path-traversal-fixture.js", "chunks", "attacks", "dashboard", "worker-assets"]) {
+        if (existsSync(join(repoRoot, asset))) cpSync(join(repoRoot, asset), join(staging, "dist", asset), { recursive: true });
+      }
+    }
+    execFileSync("tar", ["-czf", join(staging, "bundle.tar.gz"), "-C", bundleRoot, "dist"], { stdio: "inherit", env: { ...process.env, COPYFILE_DISABLE: "1" } });
+    const demoRoot = existsSync(join(bundleRoot, "dist/worker-assets/demo-target")) ? join(bundleRoot, "dist/worker-assets") : join(repoRoot, "research/counterexample-decoder");
+    if (!options.targetGit) execFileSync("tar", ["-czf", join(staging, "demo-target.tar.gz"), "-C", demoRoot, "demo-target"], { stdio: "inherit", env: { ...process.env, COPYFILE_DISABLE: "1" } });
+    shell(`for entry in /proc/[0-9]*/cwd; do
+    test "$(readlink "$entry" 2>/dev/null)" = "${REMOTE_DIR}" || continue
+    pid=$(echo "$entry" | cut -d/ -f3)
+    command=$(tr '\\000' ' ' < /proc/$pid/cmdline 2>/dev/null) || continue
+    case "$command" in 'node dist/0.js dashboard '*|'node /tmp/zero-engine/dist/0.js dashboard '*) kill "$pid" || true;; esac
+  done`);
+    shell(`rm -rf ${REMOTE_DIR} && mkdir -p ${REMOTE_DIR}/vendor`);
+    runner.copy(join(staging, "bundle.tar.gz"), `${REMOTE_DIR}/bundle.tar.gz`);
+    if (!options.targetGit) runner.copy(join(staging, "demo-target.tar.gz"), `${REMOTE_DIR}/demo-target.tar.gz`);
+    runner.copy(join(repoRoot, "vendor/tree-sitter-0.21.1-node24.tgz"), `${REMOTE_DIR}/vendor/tree-sitter-0.21.1-node24.tgz`);
+    shell(`cd ${REMOTE_DIR} && tar -xzf bundle.tar.gz && ${options.targetGit ? "ls dist/0.js" : "tar -xzf demo-target.tar.gz && ls dist/0.js demo-target/src/decoder.c"}`);
+    writeFileSync(join(staging, "package.json"), JSON.stringify({ name: "zero-engine-remote", private: true, dependencies: REMOTE_DEPS }, null, 2));
+    runner.copy(join(staging, "package.json"), `${REMOTE_DIR}/package.json`);
+    shell(`cd ${REMOTE_DIR} && PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 npm install --omit=dev --no-audit --no-fund > install.log 2>&1 || { tail -20 install.log; exit 1; }`, 9e5);
+    let targetPath;
+    if (options.targetGit) {
+      shell(`rm -rf ${REMOTE_DIR}/work && mkdir -p ${REMOTE_DIR}/work && git clone --depth 1 ${sq(options.targetGit)} ${REMOTE_DIR}/work/target`, 9e5);
+      targetPath = `${REMOTE_DIR}/work/target`;
+    } else {
+      shell(`rm -rf ${REMOTE_DIR}/work && mkdir -p ${REMOTE_DIR}/work && cp -R ${REMOTE_DIR}/demo-target ${REMOTE_DIR}/work/demo-target`);
+      targetPath = `${REMOTE_DIR}/work/demo-target`;
+    }
+    const providerEnv = options.forwardProviderKey && process.env.OPENAI_API_KEY ? `OPENAI_API_KEY=${sq(process.env.OPENAI_API_KEY)} ` : "";
+    try {
+      shell(`cd ${REMOTE_DIR} || exit 1; ${providerEnv}ZERO_WORKER_TOKEN=${token} setsid nohup node dist/0.js dashboard --host 127.0.0.1 --port ${port} --no-open --ready-json --engine-token-env ZERO_WORKER_TOKEN --engine-workspace ${REMOTE_DIR}/work > engine.log 2>&1 < /dev/null & echo $! > ${REMOTE_DIR}/engine.pid; echo started`, 3e4);
+    } catch {
+    }
+    const ready = shell(`for i in $(seq 1 30); do grep -q ZERO_DASHBOARD_READY ${REMOTE_DIR}/engine.log 2>/dev/null && echo ready && break; sleep 1; done; tail -2 ${REMOTE_DIR}/engine.log`, 6e4);
+    if (!ready.includes("ready")) throw new Error(`engine did not become ready: ${ready.trim()}`);
+    const tunnelPid = runner.tunnel(port);
+    const tunnelReady = Promise.withResolvers();
+    setTimeout(tunnelReady.resolve, 2e3);
+    await tunnelReady.promise;
+    execFileSync("curl", ["-sf", `http://127.0.0.1:${port}/`], { stdio: "ignore" });
+    const stateDir = join(homeStateDir(), "workers");
+    mkdirSync(stateDir, { recursive: true, mode: 448 });
+    const backendsConfig = options.backendsConfig ?? join(homeStateDir(), "backends.json");
+    let registry = { schemaVersion: 1, backends: [] };
+    try {
+      registry = JSON.parse(await (await import("node:fs/promises")).readFile(backendsConfig, "utf8"));
+    } catch {
+    }
+    registry.backends = [...registry.backends.filter((row) => row.id !== backendId), { id: backendId, name: `${runner.label} worker`, url: `http://127.0.0.1:${port}/`, bearerTokenEnv: tokenEnv }];
+    writeFileSync(backendsConfig, JSON.stringify(registry, null, 2) + "\n", { mode: 384 });
+    writeFileSync(join(stateDir, `${backendId}.env`), `${tokenEnv}=${token}
+`, { mode: 384 });
+    writeFileSync(join(stateDir, `${backendId}.json`), JSON.stringify({ schemaVersion: 1, backendId, ssh: options.ssh, lima: options.ssh ? void 0 : options.lima ?? "zero-worker", sshConfig: options.sshConfig, port, tunnelPid, remoteDir: REMOTE_DIR }, null, 2) + "\n", { mode: 384 });
+    process.env[tokenEnv] = token;
+    return { backendId, engine: `http://127.0.0.1:${port}/`, target: targetPath, backendsConfig, tokenEnv };
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}
+function loadManagedWorker(backendId) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(backendId)) throw new Error("Invalid worker ID.");
+  let worker;
+  try {
+    worker = JSON.parse(readFileSync(join(homeStateDir(), "workers", `${backendId}.json`), "utf8"));
+  } catch {
+    throw new Error("This connection has no managed deployment metadata. Stop its engine directly on the host.");
+  }
+  if (worker.schemaVersion !== 1 || worker.backendId !== backendId || worker.remoteDir !== REMOTE_DIR || !!worker.ssh === !!worker.lima) throw new Error("Invalid managed deployment metadata.");
+  validateWorkerOptions({ ...worker, enginePort: worker.port });
+  return worker;
+}
+function stopManagedTunnel(worker) {
+  if (!Number.isSafeInteger(worker.tunnelPid) || worker.tunnelPid <= 1) return false;
+  const result = spawnSync("ps", ["-p", String(worker.tunnelPid), "-o", "comm=", "-o", "args="], { encoding: "utf8" });
+  const command = result.stdout?.trim() ?? "";
+  const destination = worker.ssh ?? `lima-${worker.lima}`;
+  if (!/^\S*ssh\s/.test(command) || !command.includes(` ${worker.port}:127.0.0.1:${worker.port} `) || !command.endsWith(` ${destination}`)) return false;
+  try {
+    process.kill(worker.tunnelPid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stopWorker(backendId, suppliedRunner) {
+  const worker = loadManagedWorker(backendId);
+  const runner = suppliedRunner ?? createRunner(worker);
+  runner.shell(`set -eu
+if test ! -f ${REMOTE_DIR}/engine.pid; then echo 'Managed engine PID is unavailable; engine was not stopped.' >&2; exit 1; fi
+pid=$(cat ${REMOTE_DIR}/engine.pid)
+case "$pid" in ''|*[!0-9]*) echo 'Invalid engine PID' >&2; exit 1;; esac
+if test "$pid" -le 1; then echo 'Invalid engine PID' >&2; exit 1; fi
+if test -e /proc/$pid/cmdline; then
+  if test "$(readlink /proc/$pid/cwd)" != "${REMOTE_DIR}"; then echo 'Engine working directory does not match managed Zero engine' >&2; exit 1; fi
+  command=$(tr '\\000' ' ' < /proc/$pid/cmdline)
+  case "$command" in 'node dist/0.js dashboard '*|'node /tmp/zero-engine/dist/0.js dashboard '*) kill "$pid";; *) echo 'Engine PID does not match managed Zero engine' >&2; exit 1;; esac
+fi
+rm -f ${REMOTE_DIR}/engine.pid`, 3e4);
+  return { stopped: true, tunnelStopped: stopManagedTunnel(worker), remoteFilesRemoved: false };
+}
+
 // packages/cli/src/web/backend-connections.ts
 import { randomUUID } from "node:crypto";
-import { constants, closeSync, fstatSync, mkdirSync, openSync, readSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { constants, closeSync, fstatSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, readSync, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2, resolve } from "node:path";
 var BackendConnectionError = class extends Error {
   constructor(message, statusCode = 502) {
     super(message);
@@ -55,7 +255,7 @@ function endpoint(value) {
   return url;
 }
 function loadBackendConnectionConfig(configPath) {
-  const path = configPath ?? join(homeStateDir(), "backends.json");
+  const path = configPath ?? join2(homeStateDir(), "backends.json");
   let fd;
   try {
     fd = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK);
@@ -87,9 +287,9 @@ function createBackendHandshake(dbPath, capabilities2 = []) {
   let engineId = `engine-${randomUUID()}`;
   if (db !== ":memory:") {
     const path = `${resolve(db)}.engine-id`;
-    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
     try {
-      writeFileSync(path, `${engineId}
+      writeFileSync2(path, `${engineId}
 `, { flag: "wx", mode: 384 });
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
@@ -170,9 +370,13 @@ var BackendConnectionRegistry = class {
   #fetch;
   #local;
   #timeoutMs;
+  #configPath;
+  #reloadFromDisk;
   #abort = new AbortController();
   #active = 0;
   constructor(options = {}) {
+    this.#configPath = options.configPath;
+    this.#reloadFromDisk = options.connections === void 0;
     const rows = options.connections ?? loadBackendConnectionConfig(options.configPath);
     const parsed = configSchema.parse({ schemaVersion: 1, backends: rows }).backends;
     if (new Set(parsed.map((row) => row.id)).size !== parsed.length) throw new BackendConnectionError("Backend IDs must be unique.", 400);
@@ -182,7 +386,65 @@ var BackendConnectionRegistry = class {
     this.#timeoutMs = options.timeoutMs ?? 3e4;
     this.#local = parseBackendHandshake(options.localHandshake ?? createBackendHandshake());
     this.#descriptors.set("local", { id: "local", name: "Local engine", transport: "local", status: "connected", protocolVersion: this.#local.protocolVersion, capabilities: this.#local.capabilities, platform: this.#local.platform });
-    for (const row of parsed) this.#descriptors.set(row.id, { id: row.id, name: row.name, transport: "http", status: "disconnected", capabilities: [] });
+    this.reload();
+    for (const row of parsed) if (!this.#descriptors.has(row.id)) this.#descriptors.set(row.id, { id: row.id, name: row.name, transport: "http", status: "disconnected", capabilities: [] });
+  }
+  reload() {
+    if (!this.#reloadFromDisk) return;
+    const rows = loadBackendConnectionConfig(this.#configPath);
+    for (const id of this.#connections.keys()) if (!rows.some((row) => row.id === id)) {
+      this.#connections.delete(id);
+      this.#descriptors.delete(id);
+      this.#handshakes.delete(id);
+      this.#pins.delete(id);
+    }
+    for (const row of rows) {
+      const normalized = { ...row, url: endpoint(row.url).href };
+      const previous = this.#connections.get(row.id);
+      if (JSON.stringify(previous) !== JSON.stringify(normalized)) {
+        this.#connections.set(row.id, normalized);
+        this.#handshakes.delete(row.id);
+        this.#pins.delete(row.id);
+        this.#descriptors.set(row.id, { id: row.id, name: row.name, transport: "http", status: "disconnected", capabilities: [] });
+      }
+      {
+        try {
+          const value = readFileSync2(join2(homeStateDir(), "workers", `${row.id}.env`), "utf8");
+          const token = value.split("\n").find((line) => line.startsWith(`${row.bearerTokenEnv}=`))?.slice(row.bearerTokenEnv.length + 1);
+          if (token) this.#env[row.bearerTokenEnv] = backendBearerFromEnv(row.bearerTokenEnv, { [row.bearerTokenEnv]: token });
+        } catch {
+        }
+      }
+    }
+  }
+  /** Remove this dashboard's trusted connection; remote engine files are untouched. */
+  remove(id) {
+    id = BackendDescriptorSchema.shape.id.parse(id);
+    if (id === "local") throw new BackendConnectionError("The local engine cannot be removed.", 400);
+    if (!this.#reloadFromDisk) throw new BackendConnectionError("This backend registry is not persisted.", 409);
+    const rows = loadBackendConnectionConfig(this.#configPath);
+    const row = rows.find((value) => value.id === id);
+    if (!row) throw new BackendConnectionError("Backend is not registered.", 404);
+    const path = this.#configPath ?? join2(homeStateDir(), "backends.json");
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync2(temporary, `${JSON.stringify({ schemaVersion: 1, backends: rows.filter((value) => value.id !== id) }, null, 2)}
+`, { mode: 384, flag: "wx" });
+      renameSync(temporary, path);
+    } finally {
+      rmSync2(temporary, { force: true });
+    }
+    try {
+      stopManagedTunnel(loadManagedWorker(id));
+    } catch {
+    }
+    rmSync2(join2(homeStateDir(), "workers", `${id}.json`), { force: true });
+    rmSync2(join2(homeStateDir(), "workers", `${id}.env`), { force: true });
+    if (!rows.some((value) => value.id !== id && value.bearerTokenEnv === row.bearerTokenEnv)) delete this.#env[row.bearerTokenEnv];
+    this.#connections.delete(id);
+    this.#descriptors.delete(id);
+    this.#handshakes.delete(id);
+    this.#pins.delete(id);
   }
   list() {
     return structuredClone([...this.#descriptors.values()]);
@@ -337,7 +599,7 @@ var BackendConnectionRegistry = class {
         return new Response(body2, { status: response.status, headers: { "Content-Type": type, "X-0-Request-ID": requestId, ...response.headers.get("x-0-engine-id") ? { "X-0-Engine-ID": response.headers.get("x-0-engine-id") } : {} } });
       }
       const data = await boundedResponse(response, MAX_RESPONSE, signal);
-      return new Response([204, 205, 304].includes(response.status) || method === "HEAD" ? null : data, { status: response.status, headers: { "Content-Type": type, "X-0-Request-ID": requestId, ...response.headers.get("x-0-engine-id") ? { "X-0-Engine-ID": response.headers.get("x-0-engine-id") } : {} } });
+      return new Response([204, 205, 304].includes(response.status) || method === "HEAD" ? null : data, { status: response.status, headers: { "Content-Type": type, ...attachmentHeaders(response.headers), "X-0-Request-ID": requestId, ...response.headers.get("x-0-engine-id") ? { "X-0-Engine-ID": response.headers.get("x-0-engine-id") } : {} } });
     } catch (error) {
       if (error instanceof BackendConnectionError) throw error;
       if (timeout.signal.aborted) throw new BackendConnectionError("Backend request timed out.", 504);
@@ -371,6 +633,11 @@ async function requestJson(req) {
     throw new BackendConnectionError("Backend request must contain valid JSON.", 400);
   }
 }
+function attachmentHeaders(headers) {
+  const value = headers.get("content-disposition");
+  const match = value?.match(/^attachment;\s*filename="([A-Za-z0-9][A-Za-z0-9_.-]{0,159})"$/i);
+  return match ? { "Content-Disposition": `attachment; filename="${match[1]}"` } : {};
+}
 function json(res, status, value) {
   res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
   res.end(JSON.stringify(value));
@@ -378,6 +645,7 @@ function json(res, status, value) {
 async function handleBackendConnectionRequest(req, res, url, registry) {
   if (url.pathname === "/api/backends") {
     if (req.method !== "GET") throw new BackendConnectionError("Backend registry is read-only.", 405);
+    registry.reload();
     json(res, 200, { backends: registry.list() });
     return { handled: true };
   }
@@ -386,6 +654,13 @@ async function handleBackendConnectionRequest(req, res, url, registry) {
     json(res, 200, (await registry.handshake("local")).handshake);
     return { handled: true };
   }
+  const removal = url.pathname.match(/^\/api\/backends\/([^/]+)$/);
+  if (removal) {
+    if (req.method !== "DELETE") throw new BackendConnectionError("Use DELETE to remove a backend registration.", 405);
+    registry.remove(decodeURIComponent(removal[1]));
+    json(res, 200, { removed: true, remoteEngineRemoved: false });
+    return { handled: true };
+  }
   const match = url.pathname.match(/^\/api\/backends\/([^/]+)\/(handshake|proxy(?:\/.*)?)$/);
   if (!match) return { handled: false };
   const id = decodeURIComponent(match[1]);
@@ -405,7 +680,7 @@ async function handleBackendConnectionRequest(req, res, url, registry) {
     const stream = req.headers.accept?.includes("text/event-stream") === true;
     const response = await registry.request(id, path, { method: req.method, body, stream, signal: abort.signal, lastEventId: typeof req.headers["last-event-id"] === "string" ? req.headers["last-event-id"] : void 0, requestId: typeof req.headers["x-0-request-id"] === "string" ? req.headers["x-0-request-id"] : void 0 });
     if (res.destroyed) return { handled: true };
-    res.writeHead(response.status, { "Content-Type": response.headers.get("content-type") ?? "application/json", "Cache-Control": "no-store", "X-0-Request-ID": response.headers.get("x-0-request-id") ?? randomUUID(), ...response.headers.get("x-0-engine-id") ? { "X-0-Engine-ID": response.headers.get("x-0-engine-id") } : {}, "X-Content-Type-Options": "nosniff", ...stream ? { "X-Accel-Buffering": "no" } : {} });
+    res.writeHead(response.status, { "Content-Type": response.headers.get("content-type") ?? "application/json", ...attachmentHeaders(response.headers), "Cache-Control": "no-store", "X-0-Request-ID": response.headers.get("x-0-request-id") ?? randomUUID(), ...response.headers.get("x-0-engine-id") ? { "X-0-Engine-ID": response.headers.get("x-0-engine-id") } : {}, "X-Content-Type-Options": "nosniff", ...stream ? { "X-Accel-Buffering": "no" } : {} });
     if (!response.body) {
       res.end();
       return { handled: true };
@@ -448,6 +723,10 @@ async function handleBackendConnectionRequest(req, res, url, registry) {
 }
 
 export {
+  validateWorkerOptions,
+  deployWorker,
+  loadManagedWorker,
+  stopWorker,
   BackendConnectionError,
   loadBackendConnectionConfig,
   createBackendHandshake,

package/chunks/chunk-UHUW45S3.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
+import {
+  createRemoteWorkflowRuntime
+} from "./chunk-ZPFBQ3SD.js";
+import {
+  BackendConnectionRegistry
+} from "./chunk-TZRHWP7R.js";
+import {
+  resolveOsecDbPath
+} from "./chunk-RCHAFSWS.js";
+import {
+  homeStateDir
+} from "./chunk-RZR2XXAK.js";
+import {
+  external_exports
+} from "./chunk-VIT5ALXF.js";
+
+// packages/cli/src/local-engine.ts
+import { createHash, randomUUID } from "node:crypto";
+import { constants, closeSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+var MAX_DESCRIPTOR = 16 * 1024;
+var HAS_POSIX_PERMISSIONS = process.platform !== "win32";
+var schema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  nonce: external_exports.string().uuid(),
+  url: external_exports.string().min(1).max(4096),
+  token: external_exports.string().min(32).max(4096).regex(/^[^\s\x00-\x1f\x7f]+$/),
+  engineId: external_exports.string().min(1).max(128),
+  serverInstanceId: external_exports.string().min(1).max(128),
+  pid: external_exports.number().int().positive(),
+  workspace: external_exports.string().min(1).max(4096)
+}).strict();
+function localEngineDescriptorPath(dbPath, homeDir) {
+  const db = resolveOsecDbPath(dbPath);
+  const key = createHash("sha256").update(db === ":memory:" ? db : resolve(db)).digest("hex");
+  return join(homeStateDir(homeDir), "engines", `${key}.json`);
+}
+function secureMetadata(path, create) {
+  const directory = dirname(path);
+  if (create) mkdirSync(directory, { recursive: true, mode: 448 });
+  let stat;
+  try {
+    stat = lstatSync(directory);
+  } catch (error) {
+    if (!create && error.code === "ENOENT") return false;
+    throw error;
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink() || HAS_POSIX_PERMISSIONS && (stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid()) throw new Error("Local engine discovery directory must be owned by this user with private permissions (0700).");
+  return true;
+}
+function loopbackUrl(value) {
+  const url = new URL(value);
+  if (!["http:", "https:"].includes(url.protocol) || !(url.hostname === "localhost" || url.hostname === "[::1]" || /^127\.(?:\d{1,3}\.){2}\d{1,3}$/.test(url.hostname)) || url.username || url.password || url.search || url.hash || url.pathname !== "/") throw new Error("Local engine discovery requires a credential-free loopback URL.");
+  return url.href;
+}
+function readDescriptor(path) {
+  if (!secureMetadata(path, false)) return null;
+  let fd;
+  try {
+    const entry = lstatSync(path);
+    if (entry.isSymbolicLink() || !entry.isFile()) throw new Error("Discovery metadata must be a regular file, never a symlink.");
+    fd = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw new Error("Cannot safely read local engine discovery metadata.", { cause: error });
+  }
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_DESCRIPTOR || HAS_POSIX_PERMISSIONS && (stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid()) throw new Error("Local engine descriptor must be a private regular file owned by this user, at most 16 KiB.");
+    const buffer = Buffer.alloc(MAX_DESCRIPTOR + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const bytes = readSync(fd, buffer, length, buffer.length - length, length);
+      if (!bytes) break;
+      length += bytes;
+    }
+    if (length > MAX_DESCRIPTOR) throw new Error("Local engine descriptor exceeds 16 KiB.");
+    const descriptor = schema.parse(JSON.parse(buffer.subarray(0, length).toString("utf8")));
+    loopbackUrl(descriptor.url);
+    if (!isAbsolute(descriptor.workspace) || /[\x00-\x1f]/.test(descriptor.workspace)) throw new Error("Local engine descriptor workspace must be an absolute path.");
+    return descriptor;
+  } finally {
+    closeSync(fd);
+  }
+}
+function deadPid(pid) {
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch (error) {
+    return error.code === "ESRCH";
+  }
+}
+function removeMatching(path, nonce) {
+  if (readDescriptor(path)?.nonce === nonce) unlinkSync(path);
+}
+function assertLocalEngineAvailable(dbPath, homeDir) {
+  if (resolveOsecDbPath(dbPath) === ":memory:") return;
+  const path = localEngineDescriptorPath(dbPath, homeDir);
+  const descriptor = readDescriptor(path);
+  if (!descriptor) return;
+  if (!deadPid(descriptor.pid)) throw new Error("A running local engine already owns this database. Attach to it or shut it down before starting another engine.");
+  removeMatching(path, descriptor.nonce);
+}
+function registerLocalEngine(input, dbPath, options = {}) {
+  if (resolveOsecDbPath(dbPath) === ":memory:") return () => {
+  };
+  const path = localEngineDescriptorPath(dbPath, options.homeDir);
+  secureMetadata(path, true);
+  const descriptor = schema.parse({ ...input, url: loopbackUrl(input.url), workspace: realpathSync(input.workspace), schemaVersion: 1, nonce: randomUUID() });
+  const previous = readDescriptor(path);
+  if (previous) {
+    if (!deadPid(previous.pid)) throw new Error("A local engine already owns this database. Attach to it or shut it down before starting another engine.");
+    removeMatching(path, previous.nonce);
+  }
+  writeFileSync(path, JSON.stringify(descriptor), { flag: "wx", mode: 384 });
+  return () => removeMatching(path, descriptor.nonce);
+}
+async function connectLocalEngine(options) {
+  if (resolveOsecDbPath(options.dbPath) === ":memory:") return null;
+  const path = localEngineDescriptorPath(options.dbPath, options.homeDir);
+  const descriptor = readDescriptor(path);
+  if (!descriptor) return null;
+  if (deadPid(descriptor.pid)) {
+    removeMatching(path, descriptor.nonce);
+    return null;
+  }
+  if (realpathSync(options.workspace) !== descriptor.workspace) throw new Error("The running local engine owns this database in another workspace. Select its workspace or a separate engine database.");
+  if (options.model !== void 0 || options.scopePath !== void 0 || options.allowApply === true) throw new Error("The running local engine owns model, scope and application permissions. Attach using its configuration instead of overriding it.");
+  const backendId = "discovered-local-engine";
+  const registry = new BackendConnectionRegistry({
+    connections: [{ id: backendId, name: "Running local engine", url: descriptor.url, bearerTokenEnv: "LOCAL_ENGINE_DISCOVERY_TOKEN", expectedEngineId: descriptor.engineId }],
+    env: { LOCAL_ENGINE_DISCOVERY_TOKEN: descriptor.token },
+    timeoutMs: 3e3,
+    localHandshake: { protocolVersion: 1, engineId: descriptor.engineId, serverInstanceId: descriptor.serverInstanceId, capabilities: [], platform: { os: process.platform, pathStyle: process.platform === "win32" ? "windows" : "posix" } }
+  });
+  try {
+    const runtime = await createRemoteWorkflowRuntime({ backendId }, {
+      handshake: async (id) => {
+        const connection = await registry.handshake(id);
+        if (connection.handshake?.serverInstanceId !== descriptor.serverInstanceId) throw new Error("The discovered local engine instance changed. Refresh its registration before attaching.");
+        return connection;
+      },
+      request: (id, path2, request) => registry.request(id, path2, request)
+    });
+    return { ...runtime, dispose: async () => {
+      await runtime.dispose();
+      registry.dispose();
+    } };
+  } catch (error) {
+    registry.dispose();
+    throw new Error("The registered local engine could not be reached or authenticated. Restart that engine; no replacement host was started.", { cause: error });
+  }
+}
+
+export {
+  localEngineDescriptorPath,
+  assertLocalEngineAvailable,
+  registerLocalEngine,
+  connectLocalEngine
+};

package/chunks/{chunk-NX4H6L4M.js → chunk-V4BD7GSP.js}

@@ -4,10 +4,10 @@ const require = __0CreateRequire(import.meta.url);
 import {
   getToolsForRole,
   runNativeAgentLoop
-} from "./chunk-EH2WTNY7.js";
+} from "./chunk-A3EKBUEM.js";
 import {
   LlmApiRuntime
-} from "./chunk-BF5FIK7H.js";
+} from "./chunk-EYBMTELO.js";
 
 // packages/core/dist/eval-runner.js
 import { randomUUID } from "node:crypto";