@cydm/pie 2.7.4 → 2.7.5

package/dist/builtin/skills/computer-use-axi/computer-use-axi-runtime.js

@@ -5,18 +5,37 @@ import { createRequire as __createRequire } from "node:module"; const require =
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { pathToFileURL } from "node:url";
 
+// vendor/computer-use-axi/src/test-backend-guard.ts
+function requireFakeBackend(env = process.env) {
+  return env.PIE_COMPUTER_USE_REQUIRE_FAKE_BACKEND === "1";
+}
+function resolveTestOnlyBackend(env = process.env) {
+  if (requireFakeBackend(env) && (env.PIE_COMPUTER_USE_FAKE_BACKEND !== "1" || env.PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS !== "1")) {
+    throw new Error("Required fake backend needs PIE_COMPUTER_USE_FAKE_BACKEND=1 and PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS=1.");
+  }
+  if (env.PIE_COMPUTER_USE_FAKE_BACKEND !== "1") return { enabled: false };
+  if (env.PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS !== "1") {
+    return {
+      enabled: false,
+      warning: "PIE_COMPUTER_USE_FAKE_BACKEND is test-only and was ignored: it requires PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS=1 as well."
+    };
+  }
+  return { enabled: true };
+}
+
 // vendor/computer-use-axi/src/broker-client.ts
 import { spawn } from "node:child_process";
 import { closeSync, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync } from "node:fs";
 import net from "node:net";
-import path3 from "node:path";
+import path4 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // vendor/computer-use-axi/src/broker-protocol.ts
 import { createHash, randomUUID } from "node:crypto";
-import path2 from "node:path";
+import path3 from "node:path";
 
-// vendor/computer-use-axi/src/persist.ts
+// vendor/computer-use-axi/src/config.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import path from "node:path";
 
 // src/config.ts
@@ -60,11 +79,59 @@ function getConfigDir() {
   return join(homedir(), CONFIG_DIR_NAME);
 }
 
+// vendor/computer-use-axi/src/config.ts
+var DEFAULT_CONFIG = {
+  browser_use: true,
+  headless: false,
+  cursor_overlay: true,
+  managed_browser: "chrome"
+};
+var REQUEST_ENV_KEYS = ["PIE_COMPUTER_USE_BROWSER_USE", "PIE_COMPUTER_USE_HEADLESS", "PIE_COMPUTER_USE_CURSOR_OVERLAY", "PIE_COMPUTER_USE_MANAGED_BROWSER", "PIE_COMPUTER_USE_HELIUM_EXECUTABLE", "PIE_COMPUTER_USE_CHROME_EXECUTABLE", "PIE_COMPUTER_USE_CDP_PORT", "PIE_COMPUTER_USE_DELIVERY_POLICY", "PIE_COMPUTER_USE_EVENT_DELIVERY"];
+function captureComputerUseEnvironment(env = process.env) {
+  const out = {};
+  for (const key of REQUEST_ENV_KEYS) {
+    const value = env[key]?.trim();
+    if (!value) continue;
+    if (Buffer.byteLength(value) > 4096 || value.includes("\0")) throw new Error(`Invalid ${key}`);
+    if (["PIE_COMPUTER_USE_BROWSER_USE", "PIE_COMPUTER_USE_HEADLESS", "PIE_COMPUTER_USE_CURSOR_OVERLAY"].includes(key)) {
+      const parsed = parseBoolean(value);
+      if (parsed === void 0) throw new Error(`Invalid ${key}`);
+      out[key] = String(parsed);
+    } else if (key === "PIE_COMPUTER_USE_MANAGED_BROWSER") {
+      if (value !== "helium" && value !== "chrome") throw new Error(`Invalid ${key}`);
+      out[key] = value;
+    } else if (key === "PIE_COMPUTER_USE_DELIVERY_POLICY" || key === "PIE_COMPUTER_USE_EVENT_DELIVERY") {
+      const policy = value.toLowerCase();
+      if (!["default", "background", "pid", "foreground", "hid", "ax_only", "ax-only"].includes(policy)) throw new Error(`Invalid ${key}`);
+      out[key] = policy;
+    } else if (key === "PIE_COMPUTER_USE_CDP_PORT") {
+      if (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > 65535) throw new Error(`Invalid ${key}`);
+      out[key] = String(Number(value));
+    } else {
+      if (!path.isAbsolute(value)) throw new Error(`Invalid ${key}: expected absolute path`);
+      out[key] = value;
+    }
+  }
+  return Object.freeze(out);
+}
+var operationConfig = new AsyncLocalStorage();
+var defaultLoaded = Object.freeze({ config: Object.freeze({ ...DEFAULT_CONFIG }), sources: [], env: {}, environment: {} });
+function parseBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value === 1 ? true : value === 0 ? false : void 0;
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on", "enabled"].includes(normalized)) return true;
+  if (["0", "false", "no", "off", "disabled"].includes(normalized)) return false;
+  return void 0;
+}
+
 // vendor/computer-use-axi/src/persist.ts
+import path2 from "node:path";
 function stateRootDir(env = process.env) {
   const override = env.PIE_COMPUTER_USE_STATE_DIR?.trim();
   if (override) return override;
-  return path.join(getConfigDir(), "computer-use");
+  return path2.join(getConfigDir(), "computer-use");
 }
 
 // src/runtime/computer-use-owner.ts
@@ -83,8 +150,8 @@ function computerUseOwnerFromEnv(env = process.env) {
 }
 
 // vendor/computer-use-axi/src/broker-protocol.ts
-var BROKER_PROTOCOL_VERSION = 1;
-var BROKER_ENGINE_VERSION = 2;
+var BROKER_PROTOCOL_VERSION = 3;
+var BROKER_ENGINE_VERSION = 4;
 var BROKER_PACKAGE_VERSION = "0.5.1-pie.1";
 var BROKER_MAX_FRAME_BYTES = 4 * 1024 * 1024;
 var BROKER_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
@@ -132,6 +199,7 @@ var FrameDecoder = class {
     for (; ; ) {
       const newline = this.buffer.indexOf(10);
       if (newline < 0) break;
+      if (newline > this.maxBytes) throw new BrokerProtocolError("frame_too_large", `Frame exceeds the ${this.maxBytes}-byte limit.`);
       const line = this.buffer.subarray(0, newline).toString("utf8").trim();
       this.buffer = this.buffer.subarray(newline + 1);
       if (!line) continue;
@@ -156,11 +224,11 @@ function resolveBrokerEndpoint(env = process.env) {
     const key = createHash("sha256").update(seed).digest("hex").slice(0, 16);
     return { kind: "named-pipe", path: `\\\\.\\pipe\\pie-computer-use-axi-${key}` };
   }
-  const socketPath = socketOverride || path2.join(stateRootDir(env), "run", "broker.sock");
+  const socketPath = socketOverride || path3.join(stateRootDir(env), "run", "broker.sock");
   if (Buffer.byteLength(socketPath, "utf8") > 100) {
     throw new BrokerProtocolError("endpoint_too_long", `Unix socket path is ${Buffer.byteLength(socketPath)} bytes (limit ~104): ${socketPath}. Set PIE_COMPUTER_USE_BROKER_SOCKET to a shorter path.`);
   }
-  return { kind: "unix-socket", path: socketPath, directory: path2.dirname(socketPath) };
+  return { kind: "unix-socket", path: socketPath, directory: path3.dirname(socketPath) };
 }
 
 // vendor/computer-use-axi/src/broker-client.ts
@@ -192,7 +260,7 @@ var SocketFrames = class {
     socket.on("close", () => this.close());
   }
   socket;
-  decoder = new FrameDecoder();
+  decoder = new FrameDecoder(BROKER_MAX_RESPONSE_BYTES);
   queue = [];
   waiters = [];
   closed = false;
@@ -240,12 +308,12 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function resolveBrokerSpawn() {
-  const here = path3.dirname(fileURLToPath2(import.meta.url));
+  const here = path4.dirname(fileURLToPath2(import.meta.url));
   const override = process.env.PIE_COMPUTER_USE_BROKER_ENTRY?.trim();
   const candidates = [
     override,
-    path3.join(here, "computer-use-axi-broker.js"),
-    path3.join(here, "broker-main.ts")
+    path4.join(here, "computer-use-axi-broker.js"),
+    path4.join(here, "broker-main.ts")
   ].filter((candidate) => Boolean(candidate));
   for (const candidate of candidates) {
     if (!existsSync2(candidate)) continue;
@@ -259,9 +327,9 @@ function spawnBroker() {
   let stdio = "ignore";
   let logFd;
   try {
-    const logDir = path3.join(stateRootDir(), "broker");
+    const logDir = path4.join(stateRootDir(), "broker");
     mkdirSync2(logDir, { recursive: true, mode: 448 });
-    logFd = openSync(path3.join(logDir, "broker.log"), "a", 384);
+    logFd = openSync(path4.join(logDir, "broker.log"), "a", 384);
     stdio = ["ignore", logFd, logFd];
   } catch {
     stdio = "ignore";
@@ -309,6 +377,8 @@ function isBrokerResponse(value) {
   return Boolean(value) && typeof value === "object" && value.type === "response";
 }
 async function callBroker(options) {
+  if (options.command !== "stop") resolveTestOnlyBackend();
+  const environment = captureComputerUseEnvironment();
   const endpoint = resolveBrokerEndpoint();
   const budgetMs = Math.min(Math.max(options.budgetMs ?? BROKER_DEFAULT_REQUEST_BUDGET_MS, 100), 15 * 6e4);
   const spawnState = { spawned: false };
@@ -318,7 +388,7 @@ async function callBroker(options) {
     const socket = await connectOrSpawn(endpoint, options.spawnIfMissing !== false, spawnState);
     const frames = new SocketFrames(socket);
     try {
-      socket.write(encodeFrame({ type: "hello", protocolVersion: BROKER_PROTOCOL_VERSION, clientVersion: "cli" }));
+      socket.write(encodeFrame({ type: "hello", protocolVersion: BROKER_PROTOCOL_VERSION, clientVersion: "cli", buildIdentity: BROKER_BUILD.identity }));
       const helloFrame = await frames.next(BROKER_HANDSHAKE_TIMEOUT_MS);
       if (!helloFrame || typeof helloFrame !== "object" || helloFrame.type !== "hello") {
         throw new BrokerCallError("broker_no_handshake", "The computer-use broker did not answer the protocol handshake.", { exitCode: 1 });
@@ -347,6 +417,12 @@ async function callBroker(options) {
           );
         }
       }
+      if (options.command !== "stop" && (hello.protocolVersion !== BROKER_PROTOCOL_VERSION || hello.build?.identity !== BROKER_BUILD.identity)) {
+        throw new BrokerCallError("broker_incompatible", "The running broker protocol or engine build differs. Run 'computer-use-axi stop' before retrying; no request was sent.", { exitCode: 3, incompatible: true, brokerPid: hello.pid });
+      }
+      if (options.command !== "stop" && requireFakeBackend() && (!hello.ok || hello.backend?.fakeInstalled !== true || hello.backend.requireFake !== true)) {
+        throw new BrokerCallError("broker_incompatible", "Required fake backend: running broker does not attest installed fake and enforced requirement; no request was sent.", { exitCode: 3, incompatible: true, brokerPid: hello.pid });
+      }
       const brokerProtocol = hello.protocolVersion ?? BROKER_PROTOCOL_VERSION;
       const request = {
         type: "request",
@@ -358,6 +434,7 @@ async function callBroker(options) {
         command: options.command,
         params: options.params,
         cwd: options.cwd,
+        environment,
         budgetMs
       };
       socket.write(encodeFrame(request));