@organizaone/o1-code 0.20.3 → 0.21.0

package/chunks/chunk-LRHUT6ZW.js

@@ -0,0 +1,880 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-S2467S6L.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/agent-view/protocol.ts
+init_esbuild_shims();
+var AGENT_VIEW_PROTOCOL_VERSION = 1;
+
+// packages/cli/src/agent-view/terminal-bridge.ts
+init_esbuild_shims();
+async function bridgeAgentViewTerminal(options) {
+  const disposables = [];
+  const bridgeAbort = new AbortController();
+  const onDetach = /* @__PURE__ */ __name(() => bridgeAbort.abort(), "onDetach");
+  const onStdoutError = /* @__PURE__ */ __name(() => bridgeAbort.abort(), "onStdoutError");
+  let outputWrites = Promise.resolve();
+  try {
+    if (options.detachSignal?.aborted) {
+      bridgeAbort.abort();
+    } else {
+      options.detachSignal?.addEventListener("abort", onDetach, { once: true });
+    }
+    options.stdout.on("error", onStdoutError);
+    const dataDisposable = options.pty.onData((data) => {
+      if (bridgeAbort.signal.aborted) return;
+      outputWrites = outputWrites.then(
+        () => writeWithBackpressure(
+          options.stdout,
+          options.pty,
+          toBuffer(data),
+          bridgeAbort.signal
+        )
+      ).catch(() => {
+        bridgeAbort.abort();
+      });
+    });
+    if (dataDisposable) {
+      disposables.push(dataDisposable);
+    }
+    const resizeDisposable = options.onResize?.((size) => {
+      if (bridgeAbort.signal.aborted) return;
+      void Promise.resolve(options.pty.resize?.(size)).catch(() => {
+      });
+    });
+    if (resizeDisposable) {
+      disposables.push(resizeDisposable);
+    }
+    const reason = await pumpInputToPty(
+      options.stdin,
+      options.pty,
+      bridgeAbort.signal
+    );
+    await outputWrites;
+    return { reason };
+  } finally {
+    bridgeAbort.abort();
+    await outputWrites;
+    options.detachSignal?.removeEventListener("abort", onDetach);
+    options.stdout.removeListener("error", onStdoutError);
+    for (const disposable of disposables.splice(0)) {
+      try {
+        disposable.dispose();
+      } catch {
+      }
+    }
+  }
+}
+__name(bridgeAgentViewTerminal, "bridgeAgentViewTerminal");
+async function pumpInputToPty(stdin, pty, detachSignal) {
+  const iterator = createInputIterator(stdin);
+  let detached = false;
+  try {
+    while (!detachSignal?.aborted) {
+      const next = await nextInputChunk(iterator, detachSignal);
+      if (next === "detached") {
+        detached = true;
+        return "detached";
+      }
+      if (next.done) {
+        return "stdin-ended";
+      }
+      try {
+        await pty.write(toBuffer(next.value));
+      } catch {
+        detached = true;
+        return "detached";
+      }
+    }
+    detached = true;
+    return "detached";
+  } finally {
+    const returned = iterator.return?.();
+    if (detached) {
+      void returned?.catch(() => {
+      });
+    } else {
+      await returned;
+    }
+  }
+}
+__name(pumpInputToPty, "pumpInputToPty");
+function createInputIterator(stdin) {
+  const readableIterator = stdin.iterator;
+  if (typeof readableIterator === "function") {
+    return readableIterator.call(stdin, { destroyOnReturn: false });
+  }
+  return stdin[Symbol.asyncIterator]();
+}
+__name(createInputIterator, "createInputIterator");
+async function nextInputChunk(iterator, detachSignal) {
+  const next = iterator.next();
+  if (!detachSignal) return next;
+  if (detachSignal.aborted) return "detached";
+  return new Promise((resolve, reject) => {
+    const onAbort = /* @__PURE__ */ __name(() => {
+      resolve("detached");
+    }, "onAbort");
+    detachSignal.addEventListener("abort", onAbort, {
+      once: true
+    });
+    void next.then(
+      (value) => {
+        detachSignal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        detachSignal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+__name(nextInputChunk, "nextInputChunk");
+function toBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (typeof data === "string") return Buffer.from(data, "utf8");
+  return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+}
+__name(toBuffer, "toBuffer");
+function writeWithBackpressure(stdout, pty, data, signal) {
+  return new Promise((resolve, reject) => {
+    let paused = false;
+    let settled = false;
+    const finish = /* @__PURE__ */ __name((error) => {
+      if (settled) return;
+      settled = true;
+      if (paused) pty.resume?.();
+      if (error) reject(error);
+      else resolve();
+    }, "finish");
+    const canContinue = stdout.write(data, (error) => {
+      if (error) {
+        finish(error);
+        return;
+      }
+      if (paused && stdout.writableNeedDrain && !signal.aborted) {
+        const onDrain = /* @__PURE__ */ __name(() => {
+          stdout.removeListener("drain", onDrain);
+          signal.removeEventListener("abort", onAbort);
+          finish();
+        }, "onDrain");
+        const onAbort = /* @__PURE__ */ __name(() => {
+          stdout.removeListener("drain", onDrain);
+          finish();
+        }, "onAbort");
+        stdout.once("drain", onDrain);
+        signal.addEventListener("abort", onAbort, { once: true });
+      } else {
+        finish();
+      }
+    });
+    if (!canContinue && !signal.aborted) {
+      paused = true;
+      pty.pause?.();
+    }
+  });
+}
+__name(writeWithBackpressure, "writeWithBackpressure");
+
+// packages/cli/src/agent-view/supervisor-client.ts
+init_esbuild_shims();
+import * as net from "node:net";
+var AgentViewSupervisorClientError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "AgentViewSupervisorClientError";
+  }
+  static {
+    __name(this, "AgentViewSupervisorClientError");
+  }
+};
+async function requestAgentViewSupervisor(socketPath, request, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const requestWithProtocol = {
+    ...request,
+    protocolVersion: request.protocolVersion ?? AGENT_VIEW_PROTOCOL_VERSION
+  };
+  if (options.authToken && requestWithProtocol.authToken === void 0) {
+    requestWithProtocol.authToken = options.authToken;
+  }
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    let buffer = "";
+    let settled = false;
+    const timeout = setTimeout(() => {
+      finish(
+        void 0,
+        new AgentViewSupervisorClientError(
+          "Timed out waiting for Agent View supervisor response.",
+          "timeout"
+        )
+      );
+      socket.destroy();
+    }, timeoutMs);
+    const finish = /* @__PURE__ */ __name((response, error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      socket.removeAllListeners();
+      if (error) {
+        reject(error);
+      } else {
+        resolve(response);
+      }
+    }, "finish");
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify(requestWithProtocol)}
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const newline = buffer.indexOf("\n");
+      if (newline === -1) return;
+      const line = buffer.slice(0, newline);
+      try {
+        finish(parseSupervisorResponse(line));
+      } catch (error) {
+        finish(void 0, error);
+      } finally {
+        socket.end();
+      }
+    });
+    socket.on("error", (error) => finish(void 0, error));
+    socket.on("end", () => {
+      finish(
+        void 0,
+        new AgentViewSupervisorClientError(
+          "Agent View supervisor closed before sending a response.",
+          "closed"
+        )
+      );
+    });
+  });
+}
+__name(requestAgentViewSupervisor, "requestAgentViewSupervisor");
+async function callAgentViewSupervisor(socketPath, op, ...args) {
+  const params = args[0];
+  const options = args[1];
+  const response = await requestAgentViewSupervisor(
+    socketPath,
+    {
+      id: createRequestId(),
+      op,
+      ...params ? { params } : {}
+    },
+    options
+  );
+  if (response.ok) return response.result;
+  throw new AgentViewSupervisorClientError(
+    response.error.message,
+    response.error.code
+  );
+}
+__name(callAgentViewSupervisor, "callAgentViewSupervisor");
+async function watchAgentViewOwner(socketPath, ownerId, options = {}) {
+  const socket = net.createConnection(socketPath);
+  const request = {
+    id: createRequestId(),
+    protocolVersion: AGENT_VIEW_PROTOCOL_VERSION,
+    ...options.authToken ? { authToken: options.authToken } : {},
+    op: "watchOwner",
+    params: { ownerId }
+  };
+  try {
+    const { response } = await openAttachStream(socket, request, options);
+    if (!response.ok) {
+      throw new AgentViewSupervisorClientError(
+        response.error.message,
+        response.error.code
+      );
+    }
+    socket.on("error", () => {
+    });
+    return { dispose: /* @__PURE__ */ __name(() => socket.destroy(), "dispose") };
+  } catch (error) {
+    socket.destroy();
+    throw error;
+  }
+}
+__name(watchAgentViewOwner, "watchAgentViewOwner");
+async function attachAgentViewSupervisorTerminal(socketPath, sessionId, options = {}) {
+  const socket = net.createConnection(socketPath);
+  const stdin = options.stdin ?? process.stdin;
+  const stdout = options.stdout ?? process.stdout;
+  const request = {
+    id: createRequestId(),
+    protocolVersion: AGENT_VIEW_PROTOCOL_VERSION,
+    ...options.authToken ? { authToken: options.authToken } : {},
+    op: "attachStream",
+    params: { sessionId }
+  };
+  const onDetach = /* @__PURE__ */ __name(() => socket.destroy(), "onDetach");
+  if (options.detachSignal?.aborted) {
+    socket.destroy();
+    return { reason: "detached" };
+  }
+  options.detachSignal?.addEventListener("abort", onDetach, { once: true });
+  try {
+    const { response, leftover } = await openAttachStream(socket, request, {
+      timeoutMs: options.timeoutMs ?? 3e4
+    });
+    if (!response.ok) {
+      throw new AgentViewSupervisorClientError(
+        response.error.message,
+        response.error.code
+      );
+    }
+    const controller = new AbortController();
+    socket.once("close", () => controller.abort());
+    socket.on("error", () => {
+    });
+    if (leftover.length > 0) {
+      socket.pause();
+      await writeToWritable(stdout, leftover);
+    }
+    options.onAttached?.();
+    const restoreRawMode = setRawMode(stdin, options.rawMode ?? true);
+    try {
+      return await bridgeAgentViewTerminal({
+        stdin,
+        stdout,
+        pty: {
+          write(data) {
+            socket.write(data);
+          },
+          onData(callback) {
+            socket.on("data", callback);
+            socket.resume();
+            return {
+              dispose: /* @__PURE__ */ __name(() => {
+                socket.off("data", callback);
+              }, "dispose")
+            };
+          },
+          pause() {
+            socket.pause();
+          },
+          resume() {
+            socket.resume();
+          },
+          resize: /* @__PURE__ */ __name((size) => {
+            void callAgentViewSupervisor(
+              socketPath,
+              "resize",
+              {
+                sessionId,
+                columns: size.columns,
+                rows: size.rows
+              },
+              options.authToken ? { authToken: options.authToken } : void 0
+            ).catch(() => {
+            });
+          }, "resize")
+        },
+        detachSignal: controller.signal,
+        onResize: createResizeSource(stdout)
+      });
+    } finally {
+      restoreRawMode();
+    }
+  } finally {
+    options.detachSignal?.removeEventListener("abort", onDetach);
+    socket.destroy();
+  }
+}
+__name(attachAgentViewSupervisorTerminal, "attachAgentViewSupervisorTerminal");
+function subscribeAgentViewSupervisor(socketPath, onEvent, options = {}) {
+  const socket = net.createConnection(socketPath);
+  let buffer = "";
+  let subscribed = false;
+  let disposed = false;
+  let errorNotified = false;
+  const request = {
+    id: createRequestId(),
+    protocolVersion: AGENT_VIEW_PROTOCOL_VERSION,
+    ...options.authToken ? { authToken: options.authToken } : {},
+    op: "subscribe"
+  };
+  const handshakeTimeout = setTimeout(() => {
+    notifySubscriptionError(
+      new AgentViewSupervisorClientError(
+        "Timed out waiting for Agent View subscription handshake.",
+        "timeout"
+      )
+    );
+    socket.destroy();
+  }, options.timeoutMs ?? 5e3);
+  socket.setEncoding("utf8");
+  socket.on("connect", () => {
+    socket.write(`${JSON.stringify(request)}
+`);
+  });
+  socket.on("data", (chunk) => {
+    buffer += chunk;
+    while (true) {
+      const newline = buffer.indexOf("\n");
+      if (newline === -1) return;
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      if (!line) continue;
+      if (!subscribed) {
+        let response;
+        try {
+          response = parseSupervisorResponse(line);
+        } catch (parseError) {
+          notifySubscriptionError(
+            new AgentViewSupervisorClientError(
+              `Invalid subscription response: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+              "invalid_response"
+            )
+          );
+          socket.destroy();
+          return;
+        }
+        if (!response.ok) {
+          notifySubscriptionError(
+            new AgentViewSupervisorClientError(
+              response.error.message,
+              response.error.code
+            )
+          );
+          socket.destroy();
+          return;
+        }
+        subscribed = true;
+        clearTimeout(handshakeTimeout);
+        continue;
+      }
+      let event;
+      try {
+        event = parseSupervisorEvent(line);
+      } catch {
+        continue;
+      }
+      if (event) {
+        try {
+          onEvent(event);
+        } catch {
+        }
+      }
+    }
+  });
+  socket.on("error", (error) => notifySubscriptionError(error));
+  socket.on("close", () => {
+    clearTimeout(handshakeTimeout);
+    notifySubscriptionError(
+      new AgentViewSupervisorClientError(
+        "Agent View supervisor subscription closed.",
+        "closed"
+      )
+    );
+  });
+  return {
+    dispose() {
+      disposed = true;
+      clearTimeout(handshakeTimeout);
+      socket.destroy();
+    }
+  };
+  function notifySubscriptionError(error) {
+    if (disposed || errorNotified) return;
+    errorNotified = true;
+    options.onError?.(error);
+  }
+  __name(notifySubscriptionError, "notifySubscriptionError");
+}
+__name(subscribeAgentViewSupervisor, "subscribeAgentViewSupervisor");
+function createRequestId() {
+  return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+__name(createRequestId, "createRequestId");
+function openAttachStream(socket, request, options = {}) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let settled = false;
+    const timeout = setTimeout(() => {
+      finishWithError(
+        new AgentViewSupervisorClientError(
+          "Timed out waiting for Agent View attach response.",
+          "timeout"
+        )
+      );
+      socket.destroy();
+    }, options.timeoutMs ?? 3e4);
+    timeout.unref?.();
+    const finish = /* @__PURE__ */ __name((result, error) => {
+      if (settled) return;
+      settled = true;
+      socket.off("connect", onConnect);
+      socket.off("data", onData);
+      socket.off("error", onError);
+      socket.off("end", onEnd);
+      clearTimeout(timeout);
+      if (error) {
+        reject(error);
+      } else {
+        resolve(result);
+      }
+    }, "finish");
+    const onConnect = /* @__PURE__ */ __name(() => {
+      socket.write(`${JSON.stringify(request)}
+`);
+    }, "onConnect");
+    const onData = /* @__PURE__ */ __name((chunk) => {
+      chunks.push(chunk);
+      const buffer = Buffer.concat(chunks);
+      const newline = buffer.indexOf(10);
+      if (newline === -1) return;
+      try {
+        finish({
+          response: parseSupervisorResponse(
+            buffer.subarray(0, newline).toString("utf8")
+          ),
+          leftover: buffer.subarray(newline + 1)
+        });
+      } catch (error) {
+        finishWithError(error);
+      }
+    }, "onData");
+    const onError = /* @__PURE__ */ __name((error) => {
+      finishWithError(error);
+    }, "onError");
+    const onEnd = /* @__PURE__ */ __name(() => {
+      finishWithError(
+        new AgentViewSupervisorClientError(
+          "Agent View supervisor closed before attach handshake.",
+          "closed"
+        )
+      );
+    }, "onEnd");
+    const finishWithError = /* @__PURE__ */ __name((error) => {
+      finish(
+        {
+          response: {
+            id: request.id,
+            ok: false,
+            error: { code: "error", message: error.message }
+          },
+          leftover: Buffer.alloc(0)
+        },
+        error
+      );
+    }, "finishWithError");
+    socket.on("connect", onConnect);
+    socket.on("data", onData);
+    socket.on("error", onError);
+    socket.on("end", onEnd);
+  });
+}
+__name(openAttachStream, "openAttachStream");
+function setRawMode(stdin, enabled) {
+  const maybeTty = stdin;
+  if (!enabled || !maybeTty.isTTY || typeof maybeTty.setRawMode !== "function") {
+    return () => {
+    };
+  }
+  maybeTty.setRawMode(true);
+  return () => maybeTty.setRawMode?.(false);
+}
+__name(setRawMode, "setRawMode");
+function createResizeSource(stdout) {
+  const maybeTty = stdout;
+  if (typeof maybeTty.on !== "function" || typeof maybeTty.off !== "function") {
+    return void 0;
+  }
+  return (callback) => {
+    const emitSize = /* @__PURE__ */ __name(() => {
+      const columns = maybeTty.columns;
+      const rows = maybeTty.rows;
+      if (Number.isInteger(columns) && Number.isInteger(rows)) {
+        callback({ columns, rows });
+      }
+    }, "emitSize");
+    maybeTty.on?.("resize", emitSize);
+    emitSize();
+    return {
+      dispose: /* @__PURE__ */ __name(() => {
+        maybeTty.off?.("resize", emitSize);
+      }, "dispose")
+    };
+  };
+}
+__name(createResizeSource, "createResizeSource");
+function writeToWritable(stdout, data) {
+  return new Promise((resolve, reject) => {
+    stdout.write(data, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+__name(writeToWritable, "writeToWritable");
+function parseSupervisorResponse(line) {
+  const parsed = JSON.parse(line);
+  if (!isRecord(parsed) || typeof parsed["id"] !== "string") {
+    throw new AgentViewSupervisorClientError(
+      "Invalid Agent View supervisor response.",
+      "invalid_response"
+    );
+  }
+  if (parsed["ok"] === true) {
+    return {
+      id: parsed["id"],
+      ok: true,
+      result: parsed["result"]
+    };
+  }
+  if (parsed["ok"] === false && isRecord(parsed["error"]) && typeof parsed["error"]["code"] === "string" && typeof parsed["error"]["message"] === "string") {
+    return {
+      id: parsed["id"],
+      ok: false,
+      error: {
+        code: parsed["error"]["code"],
+        message: parsed["error"]["message"]
+      }
+    };
+  }
+  throw new AgentViewSupervisorClientError(
+    "Invalid Agent View supervisor response.",
+    "invalid_response"
+  );
+}
+__name(parseSupervisorResponse, "parseSupervisorResponse");
+function parseSupervisorEvent(line) {
+  const parsed = JSON.parse(line);
+  if (!isRecord(parsed) || parsed["type"] !== "changed") return void 0;
+  const at = typeof parsed["at"] === "string" ? parsed["at"] : void 0;
+  if (!at) return void 0;
+  return { type: "changed", at };
+}
+__name(parseSupervisorEvent, "parseSupervisorEvent");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+
+// packages/cli/src/agent-view/worker-sideband.ts
+init_esbuild_shims();
+import { randomUUID } from "node:crypto";
+var O1CODE_AGENT_VIEW_WORKER = "O1CODE_AGENT_VIEW_WORKER";
+var O1CODE_AGENT_VIEW_SESSION_ID = "O1CODE_AGENT_VIEW_SESSION_ID";
+var O1CODE_AGENT_VIEW_SIDEBAND = "O1CODE_AGENT_VIEW_SIDEBAND";
+var O1CODE_AGENT_VIEW_TOKEN = "O1CODE_AGENT_VIEW_TOKEN";
+var O1CODE_AGENT_VIEW_ACTIVE_CWD = "O1CODE_AGENT_VIEW_ACTIVE_CWD";
+var AGENT_VIEW_WORKER_ENV_KEYS = [
+  O1CODE_AGENT_VIEW_WORKER,
+  O1CODE_AGENT_VIEW_SESSION_ID,
+  O1CODE_AGENT_VIEW_SIDEBAND,
+  O1CODE_AGENT_VIEW_TOKEN,
+  O1CODE_AGENT_VIEW_ACTIVE_CWD
+];
+async function requestAgentSessionDashboard(env = process.env) {
+  if (!readAgentViewWorkerSidebandEnv(env)) return false;
+  await sendAgentViewWorkerEvent(
+    { type: "dashboard", requestId: randomUUID() },
+    env
+  );
+  return true;
+}
+__name(requestAgentSessionDashboard, "requestAgentSessionDashboard");
+var lastStateReportKeys = /* @__PURE__ */ new Map();
+var stateReportChains = /* @__PURE__ */ new Map();
+var pendingStateReports = /* @__PURE__ */ new Map();
+var activePrompts = /* @__PURE__ */ new Map();
+function createAgentViewWorkerSidebandEnv(config) {
+  return {
+    [O1CODE_AGENT_VIEW_WORKER]: "1",
+    [O1CODE_AGENT_VIEW_SESSION_ID]: config.sessionId,
+    [O1CODE_AGENT_VIEW_SIDEBAND]: config.sidebandEndpoint,
+    [O1CODE_AGENT_VIEW_TOKEN]: config.token,
+    [O1CODE_AGENT_VIEW_ACTIVE_CWD]: config.activeCwd
+  };
+}
+__name(createAgentViewWorkerSidebandEnv, "createAgentViewWorkerSidebandEnv");
+function isAgentViewWorkerEnv(env = process.env) {
+  return env[O1CODE_AGENT_VIEW_WORKER] === "1";
+}
+__name(isAgentViewWorkerEnv, "isAgentViewWorkerEnv");
+function readAgentViewWorkerSidebandEnv(env = process.env) {
+  if (!isAgentViewWorkerEnv(env)) {
+    return void 0;
+  }
+  const sessionId = env[O1CODE_AGENT_VIEW_SESSION_ID];
+  const sidebandEndpoint = env[O1CODE_AGENT_VIEW_SIDEBAND];
+  const token = env[O1CODE_AGENT_VIEW_TOKEN];
+  const activeCwd = env[O1CODE_AGENT_VIEW_ACTIVE_CWD];
+  if (!sessionId || !sidebandEndpoint || !token || !activeCwd) {
+    return void 0;
+  }
+  return {
+    sessionId,
+    sidebandEndpoint,
+    token,
+    activeCwd
+  };
+}
+__name(readAgentViewWorkerSidebandEnv, "readAgentViewWorkerSidebandEnv");
+async function sendAgentViewWorkerEvent(event, env = process.env) {
+  const sideband = readAgentViewWorkerSidebandEnv(env);
+  if (!sideband) return void 0;
+  return callAgentViewSupervisor(sideband.sidebandEndpoint, "workerEvent", {
+    ...event,
+    // Stamp at emit time so the dequeue ordering guard (event.at vs
+    // lastQueuedPromptAt) protects in production — worker events are
+    // otherwise built without an `at` field.
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: sideband.sessionId,
+    token: sideband.token
+  });
+}
+__name(sendAgentViewWorkerEvent, "sendAgentViewWorkerEvent");
+async function readAgentViewWorkerRedrawEvents(env = process.env) {
+  const sideband = readAgentViewWorkerSidebandEnv(env);
+  if (!sideband) return [];
+  const result = await callAgentViewSupervisor(
+    sideband.sidebandEndpoint,
+    "workerControl",
+    {
+      sessionId: sideband.sessionId,
+      token: sideband.token,
+      redrawOnly: true
+    },
+    { timeoutMs: 1e3 }
+  );
+  if (!isRecord2(result) || !Array.isArray(result["events"])) return [];
+  return result["events"].filter(isAgentViewWorkerControlEvent).filter(
+    (event) => event.type === "redraw"
+  );
+}
+__name(readAgentViewWorkerRedrawEvents, "readAgentViewWorkerRedrawEvents");
+async function reportAgentViewWorkerState(report, env = process.env) {
+  const sideband = readAgentViewWorkerSidebandEnv(env);
+  if (!sideband) return;
+  const activePrompt = activePrompts.get(sideband.sessionId);
+  if (activePrompt && activePrompt.phase === "received" && report.sessionState === "idle") {
+    activePrompt.phase = "ready";
+  }
+  const promptId = activePrompt && (activePrompt.phase === "accepted" || activePrompt.phase === "ready" && report.sessionState === "working") ? activePrompt.promptId : void 0;
+  if (promptId && activePrompt?.phase === "ready") {
+    activePrompt.phase = "accepted";
+  }
+  if (promptId) {
+    pendingStateReports.set(sideband.sessionId, report);
+  }
+  const event = {
+    type: "state",
+    ...report,
+    ...promptId ? { promptId } : {},
+    // activeCwd is guaranteed by readAgentViewWorkerSidebandEnv and survives
+    // a deleted cwd, unlike process.cwd(), which throws ENOENT.
+    cwd: report.cwd ?? sideband.activeCwd
+  };
+  const key = JSON.stringify(event);
+  const sendAndRecord = /* @__PURE__ */ __name(async () => {
+    if (key === lastStateReportKeys.get(sideband.sessionId)) {
+      if (pendingStateReports.get(sideband.sessionId) === report) {
+        pendingStateReports.delete(sideband.sessionId);
+      }
+      return;
+    }
+    try {
+      await sendAgentViewWorkerEvent(event, env);
+      lastStateReportKeys.set(sideband.sessionId, key);
+      if (pendingStateReports.get(sideband.sessionId) === report) {
+        pendingStateReports.delete(sideband.sessionId);
+      }
+      const currentPrompt = activePrompts.get(sideband.sessionId);
+      if (event.promptId && currentPrompt?.phase === "accepted" && (event.sessionState === "idle" || event.sessionState === "completed" || event.sessionState === "stopped" || event.sessionState === "failed")) {
+        activePrompts.delete(sideband.sessionId);
+      }
+    } catch {
+      lastStateReportKeys.delete(sideband.sessionId);
+    }
+  }, "sendAndRecord");
+  const previous = stateReportChains.get(sideband.sessionId);
+  const run = previous ? previous.catch(() => {
+  }).then(sendAndRecord) : sendAndRecord();
+  stateReportChains.set(sideband.sessionId, run);
+  try {
+    await run;
+  } finally {
+    if (stateReportChains.get(sideband.sessionId) === run) {
+      stateReportChains.delete(sideband.sessionId);
+    }
+  }
+}
+__name(reportAgentViewWorkerState, "reportAgentViewWorkerState");
+function startAgentViewWorkerHeartbeat(env = process.env, intervalMs = 15e3) {
+  if (!readAgentViewWorkerSidebandEnv(env)) return void 0;
+  const interval = setInterval(() => {
+    void sendAgentViewWorkerEvent({ type: "heartbeat" }, env).catch(() => {
+    });
+  }, intervalMs);
+  interval.unref?.();
+  return {
+    dispose() {
+      clearInterval(interval);
+    }
+  };
+}
+__name(startAgentViewWorkerHeartbeat, "startAgentViewWorkerHeartbeat");
+function isAgentViewWorkerControlEvent(value) {
+  if (!isRecord2(value) || !Number.isInteger(value["sequence"]) || typeof value["at"] !== "string") {
+    return false;
+  }
+  if (value["type"] === "redraw") {
+    return true;
+  }
+  if (value["type"] === "stop") {
+    return true;
+  }
+  if (value["type"] === "prompt") {
+    return typeof value["promptId"] === "string" && typeof value["text"] === "string";
+  }
+  return value["type"] === "answer" && (value["text"] === void 0 || typeof value["text"] === "string") && (value["callId"] === void 0 || typeof value["callId"] === "string") && (value["outcome"] === void 0 || isAgentViewWorkerAnswerOutcome(value["outcome"])) && (value["payload"] === void 0 || isRecord2(value["payload"]));
+}
+__name(isAgentViewWorkerControlEvent, "isAgentViewWorkerControlEvent");
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord2, "isRecord");
+function isAgentViewWorkerAnswerOutcome(value) {
+  return value === "proceed_once" || value === "proceed_always" || value === "proceed_always_project" || value === "proceed_always_user" || value === "modify_with_editor" || value === "restore_previous" || value === "cancel";
+}
+__name(isAgentViewWorkerAnswerOutcome, "isAgentViewWorkerAnswerOutcome");
+
+export {
+  AGENT_VIEW_PROTOCOL_VERSION,
+  bridgeAgentViewTerminal,
+  requestAgentViewSupervisor,
+  callAgentViewSupervisor,
+  watchAgentViewOwner,
+  attachAgentViewSupervisorTerminal,
+  subscribeAgentViewSupervisor,
+  O1CODE_AGENT_VIEW_TOKEN,
+  AGENT_VIEW_WORKER_ENV_KEYS,
+  requestAgentSessionDashboard,
+  createAgentViewWorkerSidebandEnv,
+  isAgentViewWorkerEnv,
+  readAgentViewWorkerSidebandEnv,
+  sendAgentViewWorkerEvent,
+  readAgentViewWorkerRedrawEvents,
+  reportAgentViewWorkerState,
+  startAgentViewWorkerHeartbeat
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */