@cydm/pie 2.7.4 → 2.7.6

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));

package/dist/chunks/{chunk-P2B62ZPU.js → chunk-5YWEUFLM.js}

@@ -4,7 +4,7 @@ import {
   disposeModelTransports,
   streamSimple,
   validateToolArguments
-} from "./chunk-Z4EIBY2E.js";
+} from "./chunk-ZF5FHTES.js";
 
 // ../../packages/agent-core/src/agent-loop.ts
 function createLoopErrorMessage(error, config, signal) {
@@ -290,6 +290,7 @@ async function executeToolCalls(tools, assistantMessage, signal, stream, getStee
     } catch (e) {
       console.warn(`[AgentLoop] beforeToolCall hook failed for ${toolCall.name}:`, e);
     }
+    if (signal?.aborted) break;
     let result;
     let isError = false;
     let executionArgs = toolCall.arguments;
@@ -637,6 +638,8 @@ var Agent = class {
     return this.runningPrompt ?? Promise.resolve();
   }
   reset() {
+    this.abortController?.abort();
+    this.abortController = void 0;
     this.releaseTransport();
     this._state.messages = [];
     this._state.isStreaming = false;
@@ -660,6 +663,7 @@ var Agent = class {
    * Useful when resuming a session that was saved mid-processing.
    */
   resetProcessingState() {
+    this.abortController?.abort();
     this._state.isStreaming = false;
     this._state.streamMessage = null;
     this._state.pendingToolCalls = /* @__PURE__ */ new Set();
@@ -766,8 +770,10 @@ var Agent = class {
   async _runLoop(messages, options) {
     const model = this._state.model;
     if (!model) throw new Error("No model configured");
-    this.abortController = new AbortController();
-    bindToolCallerIdentity(this.abortController.signal, this.toolCallerIdentity);
+    const runController = new AbortController();
+    this.abortController = runController;
+    const ownsRun = () => this.abortController === runController;
+    bindToolCallerIdentity(runController.signal, this.toolCallerIdentity);
     this._state.isStreaming = true;
     this._state.streamMessage = null;
     this._state.error = void 0;
@@ -791,7 +797,7 @@ var Agent = class {
       getApiKey: this.getApiKey,
       hooks: this.hooks,
       getSteeringMessages: async () => {
-        if (options?.suppressSteeringPolls) {
+        if (!ownsRun() || options?.suppressSteeringPolls) {
           return [];
         }
         if (skipInitialSteeringPoll) {
@@ -801,7 +807,7 @@ var Agent = class {
         return this.dequeueSteeringMessages();
       },
       getFollowUpMessages: async () => {
-        if (options?.suppressFollowUpPolls) {
+        if (!ownsRun() || options?.suppressFollowUpPolls) {
           return [];
         }
         return this.dequeueFollowUpMessages();
@@ -809,8 +815,9 @@ var Agent = class {
     };
     let partial = null;
     try {
-      const stream = messages ? agentLoop(messages, context, config, this.abortController.signal, this.streamFn) : agentLoopContinue(context, config, this.abortController.signal, this.streamFn);
+      const stream = messages ? agentLoop(messages, context, config, runController.signal, this.streamFn) : agentLoopContinue(context, config, runController.signal, this.streamFn);
       for await (const event of stream) {
+        if (!ownsRun()) return;
         switch (event.type) {
           case "message_start":
             partial = event.message;
@@ -847,9 +854,9 @@ var Agent = class {
             this._state.streamMessage = null;
             break;
         }
-        this.emit(event);
+        this.emit(event, ownsRun);
       }
-      if (partial && partial.role === "assistant" && partial.content?.length > 0) {
+      if (ownsRun() && partial && partial.role === "assistant" && partial.content?.length > 0) {
         const onlyEmpty = !partial.content.some(
           (c) => c.type === "thinking" && c.thinking?.trim().length > 0 || c.type === "text" && c.text?.trim().length > 0 || c.type === "toolCall" && c.name?.trim().length > 0
         );
@@ -859,6 +866,7 @@ var Agent = class {
         }
       }
     } catch (err) {
+      if (!ownsRun()) return;
       const errorMsg = {
         role: "assistant",
         content: [{ type: "text", text: "" }],
@@ -879,19 +887,22 @@ var Agent = class {
       };
       this.appendMessage(errorMsg);
       this._state.error = err?.message || String(err);
-      this.emit({ type: "agent_end", messages: [errorMsg] });
+      this.emit({ type: "agent_end", messages: [errorMsg] }, ownsRun);
     } finally {
-      this._state.isStreaming = false;
-      this._state.streamMessage = null;
-      this._state.pendingToolCalls = /* @__PURE__ */ new Set();
-      this.abortController = void 0;
+      if (ownsRun()) {
+        this._state.isStreaming = false;
+        this._state.streamMessage = null;
+        this._state.pendingToolCalls = /* @__PURE__ */ new Set();
+        this.abortController = void 0;
+      }
     }
   }
   reportObserverError(kind, eventType, error) {
     console.warn(`[Agent] ${kind} failed while handling ${eventType}:`, error);
   }
-  emit(e) {
+  emit(e, ownsRun = () => true) {
     for (const listener of this.listeners) {
+      if (!ownsRun()) return;
       try {
         listener(e);
       } catch (error) {
@@ -899,13 +910,14 @@ var Agent = class {
       }
     }
     try {
-      this.emitDerivedSemanticEvents(e);
+      if (ownsRun()) this.emitDerivedSemanticEvents(e, ownsRun);
     } catch (error) {
       this.reportObserverError("derived semantic event", e.type, error);
     }
   }
-  emitSemantic(e) {
+  emitSemantic(e, ownsRun = () => true) {
     for (const listener of this.semanticListeners) {
+      if (!ownsRun()) return;
       try {
         listener(e);
       } catch (error) {
@@ -913,7 +925,8 @@ var Agent = class {
       }
     }
   }
-  updateStatusSnapshot(next) {
+  updateStatusSnapshot(next, ownsRun = () => true) {
+    if (!ownsRun()) return;
     const snapshot = {
       ...this.statusSnapshot,
       ...next
@@ -922,26 +935,32 @@ var Agent = class {
       return;
     }
     this.statusSnapshot = snapshot;
-    this.emitSemantic({ type: "status_snapshot_changed", snapshot: { ...snapshot } });
+    this.emitSemantic({ type: "status_snapshot_changed", snapshot: { ...snapshot } }, ownsRun);
   }
-  emitDerivedSemanticEvents(event) {
+  emitDerivedSemanticEvents(event, ownsRun) {
+    const publish = {
+      updateStatusSnapshot: (next) => this.updateStatusSnapshot(next, ownsRun),
+      emitSemantic: (event2) => {
+        if (ownsRun()) this.emitSemantic(event2, ownsRun);
+      }
+    };
     switch (event.type) {
       case "message_start":
         if (event.message.role === "assistant") {
-          this.updateStatusSnapshot({
+          publish.updateStatusSnapshot({
             phase: "responding",
             turnState: "continuing",
             activeToolName: void 0,
             lastStopReason: void 0,
             hasPendingToolContinuation: false
           });
-          this.emitSemantic({ type: "assistant_response_started", message: event.message });
+          publish.emitSemantic({ type: "assistant_response_started", message: event.message });
         }
         break;
       case "message_update":
         if (event.message.role === "assistant" && event.assistantMessageEvent.type === "text_delta") {
-          this.updateStatusSnapshot({ phase: "responding" });
-          this.emitSemantic({
+          publish.updateStatusSnapshot({ phase: "responding" });
+          publish.emitSemantic({
             type: "assistant_response_delta",
             message: event.message,
             delta: event.assistantMessageEvent.delta
@@ -950,18 +969,18 @@ var Agent = class {
         break;
       case "message_end":
         if (event.message.role === "assistant") {
-          this.emitSemantic({ type: "assistant_response_finished", message: event.message });
+          publish.emitSemantic({ type: "assistant_response_finished", message: event.message });
         }
         break;
       case "tool_execution_start":
-        this.updateStatusSnapshot({
+        publish.updateStatusSnapshot({
           phase: "running_tool",
           turnState: "continuing",
           activeToolName: event.toolName,
           lastStopReason: void 0,
           hasPendingToolContinuation: false
         });
-        this.emitSemantic({
+        publish.emitSemantic({
           type: "tool_started",
           toolCallId: event.toolCallId,
           toolName: event.toolName,
@@ -969,7 +988,7 @@ var Agent = class {
         });
         break;
       case "tool_execution_update":
-        this.emitSemantic({
+        publish.emitSemantic({
           type: "tool_progressed",
           toolCallId: event.toolCallId,
           toolName: event.toolName,
@@ -978,11 +997,11 @@ var Agent = class {
         });
         break;
       case "tool_execution_end":
-        this.updateStatusSnapshot({
+        publish.updateStatusSnapshot({
           phase: this._state.isStreaming ? "responding" : "completed",
           activeToolName: void 0
         });
-        this.emitSemantic({
+        publish.emitSemantic({
           type: "tool_finished",
           toolCallId: event.toolCallId,
           toolName: event.toolName,
@@ -996,40 +1015,40 @@ var Agent = class {
         const hasToolCalls = event.message.role === "assistant" && Array.isArray(event.message.content) && event.message.content.some((block) => block.type === "toolCall");
         if (stopReason === "error" || stopReason === "aborted") {
           this.reportedFailureMessage = event.message;
-          this.updateStatusSnapshot({
+          publish.updateStatusSnapshot({
             phase: "failed",
             turnState: "failed",
             lastStopReason: stopReason,
             hasPendingToolContinuation: false,
             activeToolName: void 0
           });
-          this.emitSemantic({
+          publish.emitSemantic({
             type: "turn_failed",
             message: event.message,
             toolResults: event.toolResults
           });
         } else if (hasToolCalls) {
-          this.updateStatusSnapshot({
+          publish.updateStatusSnapshot({
             phase: "responding",
             turnState: "continuing",
             lastStopReason: stopReason,
             hasPendingToolContinuation: true,
             activeToolName: void 0
           });
-          this.emitSemantic({
+          publish.emitSemantic({
             type: "turn_continues",
             message: event.message,
             toolResults: event.toolResults
           });
         } else {
-          this.updateStatusSnapshot({
+          publish.updateStatusSnapshot({
             phase: "completed",
             turnState: "completed",
             lastStopReason: stopReason,
             hasPendingToolContinuation: false,
             activeToolName: void 0
           });
-          this.emitSemantic({
+          publish.emitSemantic({
             type: "turn_completed",
             message: event.message,
             toolResults: event.toolResults
@@ -1042,20 +1061,20 @@ var Agent = class {
         const alreadyReported = lastMessage !== void 0 && lastMessage === this.reportedFailureMessage;
         this.reportedFailureMessage = void 0;
         if (!alreadyReported && lastMessage?.role === "assistant" && (lastMessage.stopReason === "error" || lastMessage.stopReason === "aborted")) {
-          this.updateStatusSnapshot({
+          publish.updateStatusSnapshot({
             phase: "failed",
             turnState: "failed",
             lastStopReason: lastMessage.stopReason,
             hasPendingToolContinuation: false,
             activeToolName: void 0
           });
-          this.emitSemantic({
+          publish.emitSemantic({
             type: "turn_failed",
             message: lastMessage,
             toolResults: []
           });
         }
-        this.updateStatusSnapshot({
+        publish.updateStatusSnapshot({
           phase: "idle",
           activeToolName: void 0,
           hasPendingToolContinuation: false

package/dist/chunks/{chunk-VGVCDW7P.js → chunk-GAUIKMBA.js}

@@ -6,10 +6,10 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-FIE3SSLW.js";
+} from "./chunk-YWWLRZSG.js";
 import {
   getLogger
-} from "./chunk-Z4EIBY2E.js";
+} from "./chunk-ZF5FHTES.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";