@organizaone/o1-code 0.20.3 → 0.21.0

package/chunks/chunk-VDSY3ODQ.js

@@ -0,0 +1,2405 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  AGENT_VIEW_WORKER_ENV_KEYS,
+  bridgeAgentViewTerminal
+} from "./chunk-LRHUT6ZW.js";
+import {
+  atomicWriteFile
+} from "./chunk-EPJAMNLS.js";
+import {
+  Storage
+} from "./chunk-S3HSUBBN.js";
+import {
+  init_esbuild_shims
+} from "./chunk-S2467S6L.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/agent-view/pty-host-process.ts
+init_esbuild_shims();
+import { spawn } from "node:child_process";
+import {
+  accessSync,
+  closeSync,
+  constants as fsConstants,
+  lstatSync,
+  openSync,
+  statSync
+} from "node:fs";
+import * as fs3 from "node:fs/promises";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path3 from "node:path";
+import { createHash as createHash2, randomUUID, timingSafeEqual } from "node:crypto";
+
+// packages/cli/src/agent-view/pty-host-env.ts
+init_esbuild_shims();
+var PTY_HOST_AUTH_TOKEN_ENV = "O1CODE_AGENT_VIEW_PTY_HOST_TOKEN";
+var PTY_HOST_ID_ENV = "O1CODE_AGENT_VIEW_PTY_HOST_ID";
+
+// packages/cli/src/agent-view/pty-host.ts
+init_esbuild_shims();
+import { StringDecoder } from "node:string_decoder";
+var DEFAULT_AGENT_VIEW_PTY_OUTPUT_BYTES = 1024 * 1024;
+var INTERNAL_ONLY_WORKER_ENV_KEYS = /* @__PURE__ */ new Set([
+  PTY_HOST_AUTH_TOKEN_ENV,
+  PTY_HOST_ID_ENV,
+  "TMUX",
+  "TMUX_PANE",
+  "STY",
+  "WINDOW",
+  "WINDOWID",
+  "TERMCAP",
+  "COLUMNS",
+  "LINES",
+  "NO_COLOR",
+  "FORCE_COLOR",
+  "CI"
+]);
+var AgentViewPtyUnavailableError = class extends Error {
+  static {
+    __name(this, "AgentViewPtyUnavailableError");
+  }
+  constructor() {
+    super("Agent View PTY is unavailable in this runtime.");
+    this.name = "AgentViewPtyUnavailableError";
+  }
+};
+var AgentViewLaunchConfigError = class extends Error {
+  constructor(errors) {
+    super(`Invalid Agent View launch config: ${errors.join("; ")}`);
+    this.errors = errors;
+    this.name = "AgentViewLaunchConfigError";
+  }
+  static {
+    __name(this, "AgentViewLaunchConfigError");
+  }
+};
+var BoundedOutputRing = class _BoundedOutputRing {
+  constructor(maxBytes = DEFAULT_AGENT_VIEW_PTY_OUTPUT_BYTES) {
+    this.maxBytes = maxBytes;
+    if (!Number.isInteger(maxBytes) || maxBytes < 1) {
+      throw new RangeError("maxBytes must be a positive integer");
+    }
+  }
+  static {
+    __name(this, "BoundedOutputRing");
+  }
+  static MAX_CHUNK_BYTES = 8192;
+  chunks = [];
+  retainedBytesValue = 0;
+  totalBytesValue = 0;
+  get retainedBytes() {
+    return this.retainedBytesValue;
+  }
+  get totalBytes() {
+    return this.totalBytesValue;
+  }
+  get droppedBytes() {
+    return this.totalBytesValue - this.retainedBytesValue;
+  }
+  append(data) {
+    const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8");
+    this.totalBytesValue += chunk.byteLength;
+    if (chunk.byteLength >= this.maxBytes) {
+      const retained = trimUtf8Start(
+        Buffer.from(chunk.subarray(chunk.byteLength - this.maxBytes))
+      );
+      this.chunks = [retained];
+      this.retainedBytesValue = retained.byteLength;
+      return;
+    }
+    this.appendChunk(chunk);
+    this.retainedBytesValue += chunk.byteLength;
+    this.trim();
+  }
+  toBuffer() {
+    return Buffer.concat(this.chunks, this.retainedBytesValue);
+  }
+  toString(encoding = "utf8") {
+    return this.toBuffer().toString(encoding);
+  }
+  trim() {
+    let trimmed = false;
+    while (this.retainedBytesValue > this.maxBytes) {
+      trimmed = true;
+      const excess = this.retainedBytesValue - this.maxBytes;
+      const first = this.chunks[0];
+      if (!first) {
+        this.retainedBytesValue = 0;
+        return;
+      }
+      if (first.byteLength <= excess) {
+        this.chunks.shift();
+        this.retainedBytesValue -= first.byteLength;
+      } else {
+        const retained = trimUtf8Start(first.subarray(excess));
+        if (retained.byteLength === 0) {
+          this.chunks.shift();
+        } else {
+          this.chunks[0] = retained;
+        }
+        this.retainedBytesValue -= first.byteLength - retained.byteLength;
+      }
+    }
+    if (trimmed) this.trimLeadingUtf8ContinuationBytes();
+  }
+  appendChunk(chunk) {
+    const previous = this.chunks[this.chunks.length - 1];
+    if (previous && previous.byteLength + chunk.byteLength <= _BoundedOutputRing.MAX_CHUNK_BYTES) {
+      this.chunks[this.chunks.length - 1] = Buffer.concat([previous, chunk]);
+      return;
+    }
+    this.chunks.push(chunk);
+  }
+  trimLeadingUtf8ContinuationBytes() {
+    while (this.chunks.length > 0) {
+      const first = this.chunks[0];
+      const retained = trimUtf8Start(first);
+      if (retained.byteLength === first.byteLength) {
+        return;
+      }
+      if (retained.byteLength === 0) {
+        this.chunks.shift();
+      } else {
+        this.chunks[0] = retained;
+      }
+      this.retainedBytesValue -= first.byteLength - retained.byteLength;
+      if (retained.byteLength > 0) return;
+    }
+  }
+};
+function trimUtf8Start(buffer) {
+  let offset = 0;
+  while (offset < buffer.byteLength && isUtf8ContinuationByte(buffer[offset])) {
+    offset++;
+  }
+  return offset === 0 ? buffer : buffer.subarray(offset);
+}
+__name(trimUtf8Start, "trimUtf8Start");
+function isUtf8ContinuationByte(value) {
+  return value >= 128 && value <= 191;
+}
+__name(isUtf8ContinuationByte, "isUtf8ContinuationByte");
+async function loadAgentViewPty() {
+  if ("bun" in process.versions) {
+    return null;
+  }
+  const lydell = await importPty("@lydell/node-pty", "lydell-node-pty");
+  if (lydell) {
+    return lydell;
+  }
+  return importPty("node-pty", "node-pty");
+}
+__name(loadAgentViewPty, "loadAgentViewPty");
+function validateAgentViewLaunchConfig(value) {
+  const errors = [];
+  if (!isRecord(value)) {
+    return { ok: false, errors: ["launch config must be an object"] };
+  }
+  requireLiteral(value, "schemaVersion", 1, errors);
+  requireNonEmptyString(value, "sessionId", errors);
+  requireStringArray(value, "argv", errors, { nonEmpty: true });
+  requireStringRecord(value, "env", errors);
+  requireNonEmptyString(value, "entrypoint", errors);
+  requireNonEmptyString(value, "projectCwd", errors);
+  requireNonEmptyString(value, "activeCwd", errors);
+  requireStringArray(value, "includeDirectories", errors);
+  validateOptionalString(value, "model", errors);
+  validateOptionalString(value, "approvalMode", errors);
+  validateOptionalString(value, "sandbox", errors);
+  validateOptionalString(value, "initialPrompt", errors);
+  validateOptionalString(value, "settingsDigest", errors);
+  validateOptionalString(value, "mcpDigest", errors);
+  validateTerminal(value["terminal"], errors);
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return { ok: true, launch: value };
+}
+__name(validateAgentViewLaunchConfig, "validateAgentViewLaunchConfig");
+async function launchAgentViewPtyHost(rawLaunch, options = {}) {
+  const validation = validateAgentViewLaunchConfig(rawLaunch);
+  if (!validation.ok) {
+    throw new AgentViewLaunchConfigError(validation.errors);
+  }
+  const pty = options.pty === void 0 ? await (options.loadPty ?? loadAgentViewPty)() : options.pty;
+  if (!pty) {
+    throw new AgentViewPtyUnavailableError();
+  }
+  const launch = validation.launch;
+  const command = options.fakeCommand ?? launch.argv;
+  validateCommand(command);
+  const output = new BoundedOutputRing(
+    options.maxOutputBytes ?? DEFAULT_AGENT_VIEW_PTY_OUTPUT_BYTES
+  );
+  const inheritedEnv = stringProcessEnv(process.env);
+  for (const key of AGENT_VIEW_WORKER_ENV_KEYS) {
+    delete inheritedEnv[key];
+  }
+  const term = launch.env["TERM"] || "xterm-256color";
+  const workerEnv = {
+    ...inheritedEnv,
+    ...launch.env,
+    TERM: term
+  };
+  for (const key of INTERNAL_ONLY_WORKER_ENV_KEYS) {
+    delete workerEnv[key];
+  }
+  const ptyProcess = pty.module.spawn(command[0], command.slice(1), {
+    cwd: launch.activeCwd,
+    name: term,
+    cols: launch.terminal.columns,
+    rows: launch.terminal.rows,
+    env: workerEnv,
+    handleFlowControl: false,
+    // Windows: the inbox ConPTY backend orphans a `conhost.exe --headless`
+    // per natural worker exit (microsoft/node-pty#965); the bundled backend
+    // releases its host reference right after spawn.
+    useConptyDll: process.platform === "win32"
+  });
+  let inputDecoder = new StringDecoder("utf8");
+  const disposables = [];
+  let settled = false;
+  let resolveExit = /* @__PURE__ */ __name(() => {
+  }, "resolveExit");
+  const resolveExitOnce = /* @__PURE__ */ __name((exit) => {
+    if (settled) return;
+    settled = true;
+    resolveExit(exit);
+  }, "resolveExitOnce");
+  const dataDisposable = ptyProcess.onData((data) => {
+    output.append(data);
+  });
+  if (dataDisposable) {
+    disposables.push(dataDisposable);
+  }
+  const exited = new Promise((resolve3) => {
+    resolveExit = resolve3;
+    const exitDisposable = ptyProcess.onExit((event) => {
+      resolveExitOnce({ kind: "exited", ...event });
+    });
+    if (exitDisposable) {
+      disposables.push(exitDisposable);
+    }
+  });
+  if (process.platform === "win32" || options.isWorkerProcessAlive) {
+    const isAlive = options.isWorkerProcessAlive ?? isProcessAlive;
+    const exitPoll = setInterval(() => {
+      if (!settled && !isAlive(ptyProcess.pid)) {
+        resolveExitOnce({ kind: "exited", exitCode: 1 });
+      }
+    }, options.exitPollMs ?? 1e3);
+    exitPoll.unref?.();
+    void exited.then(() => clearInterval(exitPoll));
+  }
+  return {
+    pid: process.pid,
+    workerPid: ptyProcess.pid,
+    command: [...command],
+    output,
+    exited,
+    write(data) {
+      ptyProcess.write(inputDecoder.write(data));
+    },
+    onData(callback) {
+      return ptyProcess.onData(callback);
+    },
+    resize(size) {
+      ptyProcess.resize(size.columns, size.rows);
+    },
+    kill(signal) {
+      ptyProcess.kill(process.platform === "win32" ? void 0 : signal);
+    },
+    pause() {
+      ptyProcess.pause?.();
+    },
+    resume() {
+      ptyProcess.resume?.();
+    },
+    shutdown() {
+      ptyProcess.kill(process.platform === "win32" ? void 0 : "SIGTERM");
+    },
+    resetInput() {
+      inputDecoder = new StringDecoder("utf8");
+    },
+    dispose() {
+      ptyProcess.kill(process.platform === "win32" ? void 0 : "SIGTERM");
+      resolveExitOnce({ kind: "unreachable" });
+      for (const disposable of disposables.splice(0)) {
+        disposable.dispose();
+      }
+    }
+  };
+}
+__name(launchAgentViewPtyHost, "launchAgentViewPtyHost");
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+__name(isProcessAlive, "isProcessAlive");
+async function importPty(specifier, name) {
+  try {
+    const module = await import(specifier);
+    const ptyModule = asPtyModule(module);
+    return ptyModule ? { module: ptyModule, name } : null;
+  } catch {
+    return null;
+  }
+}
+__name(importPty, "importPty");
+function asPtyModule(module) {
+  if (!isRecord(module) || typeof module["spawn"] !== "function") {
+    return void 0;
+  }
+  return module;
+}
+__name(asPtyModule, "asPtyModule");
+function validateCommand(command) {
+  if (command.length === 0 || command.some((part) => part.length === 0)) {
+    throw new AgentViewLaunchConfigError([
+      "command must contain at least one non-empty string"
+    ]);
+  }
+}
+__name(validateCommand, "validateCommand");
+function stringProcessEnv(env) {
+  return Object.fromEntries(
+    Object.entries(env).filter(
+      (entry) => typeof entry[1] === "string"
+    )
+  );
+}
+__name(stringProcessEnv, "stringProcessEnv");
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function requireLiteral(record, key, expected, errors) {
+  if (record[key] !== expected) {
+    errors.push(`${key} must be ${String(expected)}`);
+  }
+}
+__name(requireLiteral, "requireLiteral");
+function requireNonEmptyString(record, key, errors) {
+  if (typeof record[key] !== "string" || record[key].length === 0) {
+    errors.push(`${key} must be a non-empty string`);
+  }
+}
+__name(requireNonEmptyString, "requireNonEmptyString");
+function validateOptionalString(record, key, errors) {
+  if (record[key] !== void 0 && typeof record[key] !== "string") {
+    errors.push(`${key} must be a string when present`);
+  }
+}
+__name(validateOptionalString, "validateOptionalString");
+function requireStringArray(record, key, errors, options = {}) {
+  const value = record[key];
+  if (!Array.isArray(value)) {
+    errors.push(`${key} must be an array of strings`);
+    return;
+  }
+  if (options.nonEmpty && value.length === 0) {
+    errors.push(`${key} must not be empty`);
+  }
+  if (value.some((item) => typeof item !== "string")) {
+    errors.push(`${key} must contain only strings`);
+  }
+}
+__name(requireStringArray, "requireStringArray");
+function requireStringRecord(record, key, errors) {
+  const value = record[key];
+  if (!isRecord(value)) {
+    errors.push(`${key} must be an object with string values`);
+    return;
+  }
+  if (Object.values(value).some((item) => typeof item !== "string")) {
+    errors.push(`${key} must contain only string values`);
+  }
+}
+__name(requireStringRecord, "requireStringRecord");
+function validateTerminal(value, errors) {
+  if (!isRecord(value)) {
+    errors.push("terminal must be an object");
+    return;
+  }
+  if (!isPositiveInteger(value["columns"])) {
+    errors.push("terminal.columns must be a positive integer");
+  }
+  if (!isPositiveInteger(value["rows"])) {
+    errors.push("terminal.rows must be a positive integer");
+  }
+}
+__name(validateTerminal, "validateTerminal");
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && Number(value) > 0;
+}
+__name(isPositiveInteger, "isPositiveInteger");
+
+// packages/cli/src/agent-view/supervisor-store.ts
+init_esbuild_shims();
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { createHash } from "node:crypto";
+var rosterMutationQueues = /* @__PURE__ */ new Map();
+var stateMutationQueues = /* @__PURE__ */ new Map();
+var activityMutationQueues = /* @__PURE__ */ new Map();
+var workerMutationQueues = /* @__PURE__ */ new Map();
+function getAgentViewStorePaths(options = {}) {
+  const globalDir = options.globalDir ?? Storage.getGlobalO1CodeDir();
+  const daemonDir = path.join(globalDir, "daemon");
+  return {
+    globalDir,
+    daemonDir,
+    rosterPath: path.join(daemonDir, "roster.json"),
+    supervisorPath: path.join(daemonDir, "supervisor.json"),
+    daemonLogPath: path.join(daemonDir, "daemon.log"),
+    jobsDir: path.join(globalDir, "jobs")
+  };
+}
+__name(getAgentViewStorePaths, "getAgentViewStorePaths");
+function getAgentViewSessionPaths(sessionId, options = {}) {
+  const safeId = sanitizeSessionId(sessionId);
+  const sessionDir = path.join(getAgentViewStorePaths(options).jobsDir, safeId);
+  return {
+    sessionDir,
+    statePath: path.join(sessionDir, "state.json"),
+    launchPath: path.join(sessionDir, "launch.json"),
+    activityPath: path.join(sessionDir, "activity.json"),
+    workerPath: path.join(sessionDir, "worker.json"),
+    tmpDir: path.join(sessionDir, "tmp")
+  };
+}
+__name(getAgentViewSessionPaths, "getAgentViewSessionPaths");
+async function readAgentViewRoster(options = {}) {
+  const raw = await readJsonRecord(getAgentViewStorePaths(options).rosterPath);
+  return normalizeRoster(raw);
+}
+__name(readAgentViewRoster, "readAgentViewRoster");
+async function readAgentViewRosterForWrite(options = {}) {
+  return readAgentViewRosterStrict(options);
+}
+__name(readAgentViewRosterForWrite, "readAgentViewRosterForWrite");
+async function readAgentViewRosterStrict(options = {}) {
+  const rosterPath = getAgentViewStorePaths(options).rosterPath;
+  let text;
+  try {
+    text = await fs.readFile(rosterPath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return normalizeRoster(void 0);
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Agent View roster at ${rosterPath} is corrupt.`, {
+      cause: error
+    });
+  }
+  if (!isRecord2(parsed)) {
+    throw new Error(`Agent View roster at ${rosterPath} is not a JSON object.`);
+  }
+  if (!Array.isArray(parsed["sessions"])) {
+    throw new Error(
+      `Agent View roster at ${rosterPath} has no sessions array.`
+    );
+  }
+  for (const entry of parsed["sessions"]) {
+    if (isRecord2(entry) && "pinned" in entry && typeof entry["pinned"] !== "boolean") {
+      throw new Error(
+        `Agent View roster at ${rosterPath} has a non-boolean pinned field.`
+      );
+    }
+  }
+  const roster = normalizeRoster(parsed);
+  if (roster.sessions.length !== parsed["sessions"].length) {
+    throw new Error(
+      `Agent View roster at ${rosterPath} has incomplete session entries.`
+    );
+  }
+  return roster;
+}
+__name(readAgentViewRosterStrict, "readAgentViewRosterStrict");
+async function writeAgentViewRoster(roster, options = {}) {
+  await writeJsonFile(getAgentViewStorePaths(options).rosterPath, roster);
+}
+__name(writeAgentViewRoster, "writeAgentViewRoster");
+async function upsertAgentViewRosterEntry(entry, options = {}) {
+  return mutateAgentViewRoster(options, async () => {
+    const roster = await readAgentViewRosterForWrite(options);
+    const entryKey = sanitizeSessionId(entry.sessionId);
+    const sessions = roster.sessions.filter(
+      (item) => sanitizeSessionId(item.sessionId) !== entryKey
+    );
+    const existing = roster.sessions.find(
+      (item) => sanitizeSessionId(item.sessionId) === entryKey
+    );
+    const updated = {
+      ...existing,
+      ...entry
+    };
+    const next = {
+      ...roster,
+      schemaVersion: 1,
+      updatedAt: entry.updatedAt,
+      sessions: [...sessions, updated].sort(compareRosterEntries)
+    };
+    await writeAgentViewRoster(next, options);
+    return next;
+  });
+}
+__name(upsertAgentViewRosterEntry, "upsertAgentViewRosterEntry");
+async function removeAgentViewRosterEntry(sessionId, options = {}) {
+  return mutateAgentViewRoster(options, async () => {
+    const roster = await readAgentViewRosterForWrite(options);
+    const sessionKey = sanitizeSessionId(sessionId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const next = {
+      ...roster,
+      schemaVersion: 1,
+      updatedAt: now,
+      sessions: roster.sessions.filter(
+        (item) => sanitizeSessionId(item.sessionId) !== sessionKey
+      )
+    };
+    await writeAgentViewRoster(next, options);
+    return next;
+  });
+}
+__name(removeAgentViewRosterEntry, "removeAgentViewRosterEntry");
+async function updateAgentViewRosterEntry(sessionId, update, options = {}) {
+  return mutateAgentViewRoster(options, async () => {
+    const roster = await readAgentViewRosterForWrite(options);
+    const sessionKey = sanitizeSessionId(sessionId);
+    const existing = roster.sessions.find(
+      (entry) => sanitizeSessionId(entry.sessionId) === sessionKey
+    );
+    if (!existing) return void 0;
+    const updated = update(existing);
+    const sessions = roster.sessions.filter(
+      (entry) => sanitizeSessionId(entry.sessionId) !== sessionKey
+    );
+    const next = {
+      ...roster,
+      schemaVersion: 1,
+      updatedAt: updated.updatedAt,
+      sessions: [...sessions, updated].sort(compareRosterEntries)
+    };
+    await writeAgentViewRoster(next, options);
+    return updated;
+  });
+}
+__name(updateAgentViewRosterEntry, "updateAgentViewRosterEntry");
+async function readAgentViewSessionState(sessionId, options = {}) {
+  const paths = getAgentViewSessionPaths(sessionId, options);
+  const raw = await readJsonRecord(paths.statePath);
+  return normalizeSessionState(raw, path.basename(paths.sessionDir));
+}
+__name(readAgentViewSessionState, "readAgentViewSessionState");
+async function writeAgentViewSessionState(state, options = {}) {
+  return mutateAgentViewState(state.sessionId, options, async () => {
+    const paths = getAgentViewSessionPaths(state.sessionId, options);
+    const existing = await readJsonRecordForWrite(paths.statePath);
+    await writeJsonFile(paths.statePath, {
+      ...existing,
+      ...state,
+      schemaVersion: 1
+    });
+    await fs.mkdir(paths.tmpDir, { recursive: true });
+  });
+}
+__name(writeAgentViewSessionState, "writeAgentViewSessionState");
+async function patchAgentViewSessionState(sessionId, patch, options = {}) {
+  return mutateAgentViewState(sessionId, options, async () => {
+    const paths = getAgentViewSessionPaths(sessionId, options);
+    const existing = await readJsonRecordForWrite(paths.statePath);
+    if (existing === void 0) {
+      return;
+    }
+    await writeJsonFile(paths.statePath, {
+      ...existing,
+      ...patch,
+      schemaVersion: 1
+    });
+    await fs.mkdir(paths.tmpDir, { recursive: true });
+  });
+}
+__name(patchAgentViewSessionState, "patchAgentViewSessionState");
+async function patchAgentViewSessionStateIf(sessionId, decidePatch, options = {}) {
+  let applied = false;
+  await mutateAgentViewState(sessionId, options, async () => {
+    const paths = getAgentViewSessionPaths(sessionId, options);
+    const existing = await readJsonRecordForConditionalWrite(paths.statePath);
+    if (existing === void 0) {
+      return;
+    }
+    const normalized = normalizeSessionState(existing, sessionId);
+    if (normalized === void 0) {
+      throw new Error(
+        `Agent View session state at ${paths.statePath} is incomplete.`
+      );
+    }
+    const patch = decidePatch(normalized);
+    if (patch === void 0) {
+      return;
+    }
+    applied = true;
+    await writeJsonFile(paths.statePath, {
+      ...existing,
+      ...patch,
+      schemaVersion: 1
+    });
+    await fs.mkdir(paths.tmpDir, { recursive: true });
+  });
+  return applied;
+}
+__name(patchAgentViewSessionStateIf, "patchAgentViewSessionStateIf");
+async function listAgentViewSessionStates(options = {}) {
+  const { jobsDir } = getAgentViewStorePaths(options);
+  let entries;
+  try {
+    entries = await fs.readdir(jobsDir);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const states = await Promise.all(
+    entries.map((sessionId) => readAgentViewSessionState(sessionId, options))
+  );
+  return states.filter((state) => Boolean(state)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+__name(listAgentViewSessionStates, "listAgentViewSessionStates");
+async function listAgentViewSessionSnapshots(options = {}) {
+  const states = await listAgentViewSessionStates(options);
+  const roster = await readAgentViewRoster(options);
+  const rosterEntries = new Map(
+    roster.sessions.map((entry) => [sanitizeSessionId(entry.sessionId), entry])
+  );
+  const snapshots = await Promise.all(
+    states.map(async (state) => {
+      const snapshot = {
+        sessionId: state.sessionId,
+        state,
+        rosterEntry: rosterEntries.get(sanitizeSessionId(state.sessionId))
+      };
+      if (state.ownership === "unmanaged") {
+        return snapshot;
+      }
+      return {
+        ...snapshot,
+        launch: redactAgentViewLaunch(
+          await readAgentViewLaunch(state.sessionId, options)
+        ),
+        activity: redactAgentViewActivity(
+          await readAgentViewActivity(state.sessionId, options)
+        ),
+        worker: redactAgentViewWorker(
+          await readAgentViewWorker(state.sessionId, options)
+        )
+      };
+    })
+  );
+  return snapshots.sort(
+    (left, right) => right.state.updatedAt.localeCompare(left.state.updatedAt)
+  );
+}
+__name(listAgentViewSessionSnapshots, "listAgentViewSessionSnapshots");
+async function readAgentViewLaunch(sessionId, options = {}) {
+  const paths = getAgentViewSessionPaths(sessionId, options);
+  const raw = await readJsonRecord(paths.launchPath);
+  return normalizeLaunch(raw, path.basename(paths.sessionDir));
+}
+__name(readAgentViewLaunch, "readAgentViewLaunch");
+async function writeAgentViewLaunch(launch, options = {}) {
+  const paths = getAgentViewSessionPaths(launch.sessionId, options);
+  const existing = await readJsonRecordForWrite(paths.launchPath);
+  await writeJsonFile(paths.launchPath, {
+    ...existing,
+    ...launch,
+    schemaVersion: 1
+  });
+}
+__name(writeAgentViewLaunch, "writeAgentViewLaunch");
+async function readAgentViewActivity(sessionId, options = {}) {
+  const raw = await readJsonRecord(
+    getAgentViewSessionPaths(sessionId, options).activityPath
+  );
+  return normalizeActivity(raw);
+}
+__name(readAgentViewActivity, "readAgentViewActivity");
+async function writeAgentViewActivity(sessionId, activity, options = {}) {
+  return mutateAgentViewActivity(sessionId, options, async () => {
+    const paths = getAgentViewSessionPaths(sessionId, options);
+    const existing = await readJsonRecordForWrite(paths.activityPath);
+    await writeJsonFile(paths.activityPath, {
+      ...existing,
+      ...activity,
+      schemaVersion: 1
+    });
+  });
+}
+__name(writeAgentViewActivity, "writeAgentViewActivity");
+async function patchAgentViewActivityIf(sessionId, decidePatch, options = {}) {
+  let applied = false;
+  await mutateAgentViewActivity(sessionId, options, async () => {
+    const paths = getAgentViewSessionPaths(sessionId, options);
+    const existing = await readJsonRecordForWrite(paths.activityPath);
+    const normalized = normalizeActivity(existing);
+    if (normalized === void 0) {
+      return;
+    }
+    const patch = decidePatch(normalized);
+    if (patch === void 0) {
+      return;
+    }
+    applied = true;
+    await writeJsonFile(paths.activityPath, {
+      ...existing,
+      ...patch,
+      schemaVersion: 1
+    });
+  });
+  return applied;
+}
+__name(patchAgentViewActivityIf, "patchAgentViewActivityIf");
+async function clearAgentViewWorkerPids(sessionId, options = {}) {
+  const paths = getAgentViewSessionPaths(sessionId, options);
+  await withMutationQueue(workerMutationQueues, paths.workerPath, async () => {
+    const existing = await readJsonRecordForWrite(paths.workerPath);
+    if (existing === void 0) {
+      return;
+    }
+    const next = { ...existing };
+    delete next["hostPid"];
+    delete next["workerPid"];
+    await writeJsonFile(paths.workerPath, { ...next, schemaVersion: 1 });
+  });
+}
+__name(clearAgentViewWorkerPids, "clearAgentViewWorkerPids");
+function digestAgentViewWorkerToken(token) {
+  return createHash("sha256").update(token).digest("hex");
+}
+__name(digestAgentViewWorkerToken, "digestAgentViewWorkerToken");
+async function readAgentViewWorker(sessionId, options = {}) {
+  const raw = await readJsonRecord(
+    getAgentViewSessionPaths(sessionId, options).workerPath
+  );
+  return normalizeWorker(raw);
+}
+__name(readAgentViewWorker, "readAgentViewWorker");
+async function writeAgentViewWorker(sessionId, worker, options = {}) {
+  const paths = getAgentViewSessionPaths(sessionId, options);
+  await withMutationQueue(workerMutationQueues, paths.workerPath, async () => {
+    const existing = await readJsonRecordForWrite(paths.workerPath);
+    await writeJsonFile(paths.workerPath, {
+      ...existing,
+      ...worker,
+      schemaVersion: 1
+    });
+  });
+}
+__name(writeAgentViewWorker, "writeAgentViewWorker");
+async function readAgentViewSupervisor(options = {}) {
+  const raw = await readJsonRecord(
+    getAgentViewStorePaths(options).supervisorPath
+  );
+  return normalizeSupervisor(raw);
+}
+__name(readAgentViewSupervisor, "readAgentViewSupervisor");
+async function writeAgentViewSupervisor(supervisor, options = {}) {
+  const paths = getAgentViewStorePaths(options);
+  const existing = await readJsonRecordForWrite(paths.supervisorPath);
+  await writeJsonFile(paths.supervisorPath, {
+    ...existing,
+    ...supervisor,
+    schemaVersion: 1
+  });
+}
+__name(writeAgentViewSupervisor, "writeAgentViewSupervisor");
+function sanitizeSessionId(sessionId) {
+  const safe = path.basename(sessionId.replace(/\\/g, "/")).toLowerCase().replace(/^\.+/g, "_").replace(/[<>:"|?*\x00-\x1F]/g, "_");
+  return safe || "_";
+}
+__name(sanitizeSessionId, "sanitizeSessionId");
+function compareRosterEntries(left, right) {
+  if (Boolean(left.pinned) !== Boolean(right.pinned)) {
+    return left.pinned ? -1 : 1;
+  }
+  return right.updatedAt.localeCompare(left.updatedAt);
+}
+__name(compareRosterEntries, "compareRosterEntries");
+async function readJsonRecord(filePath) {
+  try {
+    const text = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse(text);
+    return isRecord2(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(readJsonRecord, "readJsonRecord");
+async function readJsonRecordForWrite(filePath) {
+  let text;
+  try {
+    text = await fs.readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    return isRecord2(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(readJsonRecordForWrite, "readJsonRecordForWrite");
+async function readJsonRecordForConditionalWrite(filePath) {
+  let text;
+  try {
+    text = await fs.readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Agent View record at ${filePath} is corrupt.`, {
+      cause: error
+    });
+  }
+  if (!isRecord2(parsed)) {
+    throw new Error(`Agent View record at ${filePath} is not a JSON object.`);
+  }
+  return parsed;
+}
+__name(readJsonRecordForConditionalWrite, "readJsonRecordForConditionalWrite");
+async function withMutationQueue(queues, key, action) {
+  const previous = queues.get(key) ?? Promise.resolve();
+  let release;
+  const gate = new Promise((resolve3) => {
+    release = resolve3;
+  });
+  const current = previous.catch(() => {
+  }).then(() => gate);
+  queues.set(key, current);
+  await previous.catch(() => {
+  });
+  try {
+    return await action();
+  } finally {
+    release();
+    if (queues.get(key) === current) {
+      queues.delete(key);
+    }
+  }
+}
+__name(withMutationQueue, "withMutationQueue");
+async function mutateAgentViewRoster(options, action) {
+  return withMutationQueue(
+    rosterMutationQueues,
+    getAgentViewStorePaths(options).rosterPath,
+    action
+  );
+}
+__name(mutateAgentViewRoster, "mutateAgentViewRoster");
+async function mutateAgentViewActivity(sessionId, options, action) {
+  return withMutationQueue(
+    activityMutationQueues,
+    getAgentViewSessionPaths(sessionId, options).activityPath,
+    action
+  );
+}
+__name(mutateAgentViewActivity, "mutateAgentViewActivity");
+async function mutateAgentViewState(sessionId, options, action) {
+  return withMutationQueue(
+    stateMutationQueues,
+    getAgentViewSessionPaths(sessionId, options).statePath,
+    action
+  );
+}
+__name(mutateAgentViewState, "mutateAgentViewState");
+async function writeJsonFile(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await atomicWriteFile(filePath, `${JSON.stringify(value, null, 2)}
+`, {
+    mode: 384,
+    forceMode: true,
+    noFollow: true
+  });
+}
+__name(writeJsonFile, "writeJsonFile");
+function normalizeRoster(raw) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const sessions = Array.isArray(raw?.["sessions"]) ? raw["sessions"].map(normalizeRosterEntry).filter((entry) => Boolean(entry)) : [];
+  return {
+    ...raw,
+    schemaVersion: 1,
+    updatedAt: stringValue(raw?.["updatedAt"]) ?? now,
+    sessions: sessions.sort(compareRosterEntries)
+  };
+}
+__name(normalizeRoster, "normalizeRoster");
+function normalizeRosterEntry(value) {
+  if (!isRecord2(value)) return void 0;
+  const sessionId = stringValue(value["sessionId"]);
+  const projectCwd = stringValue(value["projectCwd"]);
+  const activeCwd = stringValue(value["activeCwd"]);
+  const createdAt = stringValue(value["createdAt"]);
+  const updatedAt = stringValue(value["updatedAt"]);
+  if (!sessionId || !projectCwd || !activeCwd || !createdAt || !updatedAt) {
+    return void 0;
+  }
+  return {
+    ...value,
+    sessionId,
+    projectCwd: path.resolve(projectCwd),
+    activeCwd: path.resolve(activeCwd),
+    displayName: stringValue(value["displayName"]),
+    pinned: typeof value["pinned"] === "boolean" ? value["pinned"] : void 0,
+    createdAt,
+    updatedAt
+  };
+}
+__name(normalizeRosterEntry, "normalizeRosterEntry");
+function normalizeSessionState(raw, expectedSessionId) {
+  if (!raw) return void 0;
+  const sessionId = expectedSessionId || stringValue(raw["sessionId"]);
+  const projectCwd = stringValue(raw["projectCwd"]);
+  const originalCwd = stringValue(raw["originalCwd"]);
+  const activeCwd = stringValue(raw["activeCwd"]);
+  const createdAt = stringValue(raw["createdAt"]);
+  const updatedAt = stringValue(raw["updatedAt"]);
+  if (!sessionId || !projectCwd || !originalCwd || !activeCwd || !createdAt || !updatedAt) {
+    return void 0;
+  }
+  return {
+    ...raw,
+    schemaVersion: 1,
+    sessionId,
+    ownership: ownershipValue(raw["ownership"]),
+    sessionState: sessionStateValue(raw["sessionState"]),
+    processState: processStateValue(raw["processState"]),
+    attachState: attachStateValue(raw["attachState"]),
+    projectCwd: path.resolve(projectCwd),
+    originalCwd: path.resolve(originalCwd),
+    activeCwd: path.resolve(activeCwd),
+    foregroundOwnerId: stringValue(raw["foregroundOwnerId"]),
+    createdAt,
+    updatedAt,
+    worktree: isRecord2(raw["worktree"]) ? {
+      ...raw["worktree"],
+      mode: worktreeModeValue(raw["worktree"]["mode"])
+    } : { mode: "none" }
+  };
+}
+__name(normalizeSessionState, "normalizeSessionState");
+function normalizeLaunch(raw, expectedSessionId) {
+  if (!raw) return void 0;
+  const sessionId = expectedSessionId || stringValue(raw["sessionId"]);
+  const entrypoint = stringValue(raw["entrypoint"]);
+  const projectCwd = stringValue(raw["projectCwd"]);
+  const activeCwd = stringValue(raw["activeCwd"]);
+  if (!sessionId || !entrypoint || !projectCwd || !activeCwd) return void 0;
+  return stripUndefined({
+    ...raw,
+    schemaVersion: 1,
+    sessionId,
+    argv: stringArrayValue(raw["argv"]),
+    env: stringMapValue(raw["env"]),
+    entrypoint,
+    initialPrompt: stringValue(raw["initialPrompt"]),
+    projectCwd: path.resolve(projectCwd),
+    activeCwd: path.resolve(activeCwd),
+    includeDirectories: stringArrayValue(raw["includeDirectories"]),
+    terminal: terminalValue(raw["terminal"])
+  });
+}
+__name(normalizeLaunch, "normalizeLaunch");
+function redactAgentViewLaunch(launch) {
+  if (!launch) return void 0;
+  return {
+    ...launch,
+    env: {}
+  };
+}
+__name(redactAgentViewLaunch, "redactAgentViewLaunch");
+function normalizeActivity(raw) {
+  if (!raw) return void 0;
+  const lastActivityAt = stringValue(raw["lastActivityAt"]);
+  if (!lastActivityAt) return void 0;
+  return stripUndefined({
+    ...raw,
+    schemaVersion: 1,
+    summary: stringValue(raw["summary"]),
+    model: stringValue(raw["model"]),
+    theme: raw["theme"] === "light" ? "light" : raw["theme"] === "dark" ? "dark" : void 0,
+    language: stringValue(raw["language"]),
+    dashboardRequestId: stringValue(raw["dashboardRequestId"]),
+    waitingFor: stringValue(raw["waitingFor"]),
+    inputKind: inputKindValue(raw["inputKind"]),
+    lastResult: stringValue(raw["lastResult"]),
+    queuedPromptCount: numberValue(raw["queuedPromptCount"]),
+    queuedPromptPreview: stringValue(raw["queuedPromptPreview"]),
+    queuedPromptId: stringValue(raw["queuedPromptId"]),
+    queuedPromptText: stringValue(raw["queuedPromptText"]),
+    queuedPromptDeliveredAt: stringValue(raw["queuedPromptDeliveredAt"]),
+    lastQueuedPromptAt: stringValue(raw["lastQueuedPromptAt"]),
+    lastActivityAt,
+    capabilities: stringArrayValue(raw["capabilities"])
+  });
+}
+__name(normalizeActivity, "normalizeActivity");
+function redactAgentViewActivity(activity) {
+  if (!activity) return void 0;
+  return stripUndefined({
+    ...activity,
+    queuedPromptId: void 0,
+    queuedPromptText: void 0,
+    queuedPromptDeliveredAt: void 0
+  });
+}
+__name(redactAgentViewActivity, "redactAgentViewActivity");
+function redactAgentViewWorker(worker) {
+  if (!worker) return void 0;
+  return stripUndefined({
+    ...worker,
+    hostAuthToken: void 0
+  });
+}
+__name(redactAgentViewWorker, "redactAgentViewWorker");
+function stripUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter((entry) => entry[1] !== void 0)
+  );
+}
+__name(stripUndefined, "stripUndefined");
+function normalizeWorker(raw) {
+  if (!raw) return void 0;
+  return {
+    ...raw,
+    schemaVersion: 1,
+    hostPid: numberValue(raw["hostPid"]),
+    workerPid: numberValue(raw["workerPid"]),
+    endpoint: stringValue(raw["endpoint"]),
+    hostEndpoint: stringValue(raw["hostEndpoint"]),
+    hostAuthToken: stringValue(raw["hostAuthToken"]),
+    hostId: stringValue(raw["hostId"]),
+    tokenDigest: stringValue(raw["tokenDigest"]),
+    lastHeartbeatAt: stringValue(raw["lastHeartbeatAt"]),
+    protocolVersion: numberValue(raw["protocolVersion"]) ?? 1,
+    platform: platformValue(raw["platform"]),
+    recentOutputBytes: numberValue(raw["recentOutputBytes"]) ?? 0
+  };
+}
+__name(normalizeWorker, "normalizeWorker");
+function normalizeSupervisor(raw) {
+  if (!raw) return void 0;
+  const pid = numberValue(raw["pid"]);
+  const socketPath = stringValue(raw["socketPath"]);
+  const authToken = stringValue(raw["authToken"]);
+  const startedAt = stringValue(raw["startedAt"]);
+  const updatedAt = stringValue(raw["updatedAt"]);
+  if (!pid || !socketPath || !startedAt || !updatedAt) return void 0;
+  return {
+    ...raw,
+    schemaVersion: 1,
+    pid,
+    socketPath,
+    authToken,
+    startedAt,
+    updatedAt,
+    protocolVersion: numberValue(raw["protocolVersion"]) ?? 1
+  };
+}
+__name(normalizeSupervisor, "normalizeSupervisor");
+function ownershipValue(value) {
+  return value === "unmanaged" || value === "adopting" || value === "managed" || value === "removing" ? value : "managed";
+}
+__name(ownershipValue, "ownershipValue");
+function isAgentViewSessionState(value) {
+  return value === "starting" || value === "working" || value === "needs_input" || value === "idle" || value === "completed" || value === "stopped" || value === "failed";
+}
+__name(isAgentViewSessionState, "isAgentViewSessionState");
+function sessionStateValue(value) {
+  return isAgentViewSessionState(value) ? value : "failed";
+}
+__name(sessionStateValue, "sessionStateValue");
+function processStateValue(value) {
+  return value === "starting" || value === "alive" || value === "hibernating" || value === "hibernated" || value === "restarting" || value === "exited" ? value : "exited";
+}
+__name(processStateValue, "processStateValue");
+function attachStateValue(value) {
+  return value === "attaching" || value === "attached" ? value : "detached";
+}
+__name(attachStateValue, "attachStateValue");
+function worktreeModeValue(value) {
+  return value === "worktree" || value === "shared-unisolated" ? value : "none";
+}
+__name(worktreeModeValue, "worktreeModeValue");
+function inputKindValue(value) {
+  return value === "blocking" || value === "soft" ? value : void 0;
+}
+__name(inputKindValue, "inputKindValue");
+function terminalValue(value) {
+  if (!isRecord2(value)) return { columns: 80, rows: 24 };
+  return {
+    columns: numberValue(value["columns"]) ?? 80,
+    rows: numberValue(value["rows"]) ?? 24
+  };
+}
+__name(terminalValue, "terminalValue");
+var KNOWN_PLATFORMS = /* @__PURE__ */ new Set([
+  "aix",
+  "darwin",
+  "freebsd",
+  "linux",
+  "openbsd",
+  "sunos",
+  "win32"
+]);
+function platformValue(value) {
+  return typeof value === "string" && KNOWN_PLATFORMS.has(value) ? value : process.platform;
+}
+__name(platformValue, "platformValue");
+function stringMapValue(value) {
+  if (!isRecord2(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).filter(
+      (entry) => typeof entry[1] === "string"
+    )
+  );
+}
+__name(stringMapValue, "stringMapValue");
+function stringArrayValue(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+__name(stringArrayValue, "stringArrayValue");
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+__name(stringValue, "stringValue");
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+__name(numberValue, "numberValue");
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord2, "isRecord");
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+__name(isNodeError, "isNodeError");
+
+// packages/cli/src/agent-view/current-cli-argv.ts
+init_esbuild_shims();
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+function getCurrentO1CodeCliEntrypoint() {
+  const entry = process.argv[1];
+  if (!entry) return "o1-code";
+  return path2.isAbsolute(entry) ? entry : path2.resolve(entry);
+}
+__name(getCurrentO1CodeCliEntrypoint, "getCurrentO1CodeCliEntrypoint");
+function buildCurrentO1CodeCliArgv(args) {
+  const entrypoint = getCurrentO1CodeCliEntrypoint();
+  if (entrypoint === "o1-code") {
+    return ["o1-code", ...args];
+  }
+  if (process.env["DEV"] === "true" && entrypoint.endsWith(".ts")) {
+    const tsxCli = findLocalTsxCli(entrypoint);
+    if (tsxCli) {
+      return [process.execPath, tsxCli, entrypoint, ...args];
+    }
+    throw new Error(
+      `Cannot spawn supervisor: DEV=true with TypeScript entrypoint ${entrypoint} but tsx was not found. Run npm install.`
+    );
+  }
+  return [process.execPath, entrypoint, ...args];
+}
+__name(buildCurrentO1CodeCliArgv, "buildCurrentO1CodeCliArgv");
+function findLocalTsxCli(entrypoint) {
+  const root = path2.resolve(path2.dirname(entrypoint), "..", "..");
+  const tsxCli = path2.join(root, "node_modules", "tsx", "dist", "cli.mjs");
+  if (fs2.existsSync(tsxCli)) {
+    return tsxCli;
+  }
+  return void 0;
+}
+__name(findLocalTsxCli, "findLocalTsxCli");
+
+// packages/cli/src/agent-view/pty-host-process.ts
+var INTERNAL_AGENT_VIEW_PTY_HOST_ARG = "--internal-agent-view-pty-host";
+var HOST_READY_RETRIES = 50;
+var CONNECT_HOST_READY_RETRIES = 10;
+var HOST_READY_DELAY_MS = 50;
+var HOST_READY_REQUEST_TIMEOUT_MS = 250;
+var REMOTE_HOST_EXIT_POLL_MS = 5e3;
+var SHUTDOWN_GRACE_MS = 2e3;
+var UNIX_SOCKET_PATH_LIMIT = 100;
+var MAX_PTY_HOST_REQUEST_LINE_BYTES = 1024 * 1024;
+var MAX_PTY_HOST_RESPONSE_LINE_BYTES = 8 * 1024 * 1024;
+var ALLOWED_KILL_SIGNALS = /* @__PURE__ */ new Set([
+  "SIGINT",
+  "SIGKILL",
+  "SIGTERM"
+]);
+var HOST_OPERATIONS = [
+  "status",
+  "logs",
+  "resize",
+  "kill",
+  "shutdown",
+  "attachStream"
+];
+function createAgentViewPtyHostIdentity(sessionId, options = {}) {
+  return {
+    hostId: randomUUID(),
+    endpoint: getAgentViewPtyHostSocketPath(sessionId, options),
+    authToken: randomUUID()
+  };
+}
+__name(createAgentViewPtyHostIdentity, "createAgentViewPtyHostIdentity");
+async function launchAgentViewPtyHostProcess(launch, options = {}) {
+  const identity = options.identity ?? createAgentViewPtyHostIdentity(launch.sessionId, options);
+  const socketPath = identity.endpoint;
+  const authToken = identity.authToken;
+  const launchPath = getAgentViewSessionPaths(launch.sessionId, {
+    ...options.globalDir ? { globalDir: options.globalDir } : {}
+  }).launchPath;
+  const stderrLogPath = `${launchPath}.host-stderr.log`;
+  const child = (options.spawnProcess ?? defaultSpawnPtyHost)(
+    [INTERNAL_AGENT_VIEW_PTY_HOST_ARG, launchPath, socketPath],
+    {
+      [PTY_HOST_AUTH_TOKEN_ENV]: authToken,
+      [PTY_HOST_ID_ENV]: identity.hostId
+    },
+    stderrLogPath
+  );
+  child.unref?.();
+  let status;
+  try {
+    status = await waitForSpawnedPtyHost(
+      socketPath,
+      child,
+      authToken,
+      identity.hostId
+    );
+  } catch (error) {
+    child.kill?.("SIGKILL");
+    throw await withHostStderrTail(error, stderrLogPath);
+  }
+  return createRemotePtyHostHandle({
+    hostId: identity.hostId,
+    socketPath,
+    launch,
+    authToken,
+    pid: child.pid ?? status.pid,
+    workerPid: status.workerPid,
+    child
+  });
+}
+__name(launchAgentViewPtyHostProcess, "launchAgentViewPtyHostProcess");
+async function connectAgentViewPtyHostProcess(launch, socketPath, authToken, options = {}) {
+  const status = await waitForPtyHost(
+    socketPath,
+    options.readyRetries ?? CONNECT_HOST_READY_RETRIES,
+    authToken,
+    {
+      requestTimeoutMs: options.requestTimeoutMs ?? HOST_READY_REQUEST_TIMEOUT_MS,
+      expectedHostId: options.expectedHostId
+    }
+  );
+  return createRemotePtyHostHandle({
+    hostId: status.hostId,
+    socketPath,
+    launch,
+    authToken,
+    ...options.requestTimeoutMs !== void 0 ? { requestTimeoutMs: options.requestTimeoutMs } : {},
+    pid: status.pid,
+    workerPid: status.workerPid
+  });
+}
+__name(connectAgentViewPtyHostProcess, "connectAgentViewPtyHostProcess");
+function createRemotePtyHostHandle({
+  hostId,
+  socketPath,
+  launch,
+  authToken,
+  requestTimeoutMs,
+  pid,
+  workerPid,
+  child
+}) {
+  const output = new BoundedOutputRing();
+  let attachSocket;
+  const exitTracker = child ? createChildExitTracker(child) : createRemoteExitTracker(socketPath, authToken);
+  return {
+    ...hostId ? { hostId } : {},
+    pid,
+    workerPid,
+    command: launch.argv,
+    endpoint: socketPath,
+    ...authToken ? { authToken } : {},
+    output,
+    exited: exitTracker.exited,
+    async getOutput() {
+      const result = await callAgentViewPtyHost(
+        socketPath,
+        authToken,
+        "logs",
+        void 0,
+        requestTimeoutMs
+      );
+      if (isRecord3(result) && typeof result["output"] === "string") {
+        return result["output"];
+      }
+      return "";
+    },
+    write(data) {
+      if (!attachSocket) {
+        throw new Error(
+          "Agent View PTY host input requires an active attach stream."
+        );
+      }
+      attachSocket.write(data);
+    },
+    onData(callback) {
+      attachSocket?.destroy();
+      const socket = net.createConnection(socketPath);
+      attachSocket = socket;
+      socket.setEncoding("utf8");
+      socket.write(
+        `${JSON.stringify({
+          id: createRequestId(),
+          op: "attachStream",
+          ...authToken ? { authToken } : {}
+        })}
+`
+      );
+      let attached = false;
+      let buffer = "";
+      const onData = /* @__PURE__ */ __name((textChunk) => {
+        if (attached) {
+          output.append(textChunk);
+          callback(textChunk);
+          return;
+        }
+        buffer += textChunk;
+        if (Buffer.byteLength(buffer, "utf8") > MAX_PTY_HOST_RESPONSE_LINE_BYTES) {
+          socket.destroy(
+            new AgentViewPtyHostProtocolError(
+              "Agent View PTY host response line is too large."
+            )
+          );
+          return;
+        }
+        const newline = buffer.indexOf("\n");
+        if (newline === -1) return;
+        let response;
+        try {
+          response = parseHostResponse(buffer.slice(0, newline));
+        } catch (error) {
+          socket.destroy(
+            error instanceof Error ? error : new Error(String(error))
+          );
+          return;
+        }
+        if (!response.ok) {
+          socket.destroy(new Error(response.error.message));
+          return;
+        }
+        attached = true;
+        const leftover = buffer.slice(newline + 1);
+        buffer = "";
+        if (leftover) {
+          output.append(leftover);
+          callback(leftover);
+        }
+      }, "onData");
+      socket.on("data", onData);
+      socket.once("error", () => {
+        if (attachSocket === socket) {
+          attachSocket = void 0;
+        }
+      });
+      socket.once("close", () => {
+        if (attachSocket === socket) {
+          attachSocket = void 0;
+        }
+      });
+      return {
+        dispose() {
+          socket.off("data", onData);
+          socket.destroy();
+        }
+      };
+    },
+    resize(size) {
+      void callAgentViewPtyHost(socketPath, authToken, "resize", {
+        columns: size.columns,
+        rows: size.rows
+      }).catch(() => {
+      });
+    },
+    kill(signal) {
+      const allowedSignal = killSignalValue(signal);
+      void callAgentViewPtyHost(socketPath, authToken, "kill", {
+        signal: allowedSignal
+      }).then(
+        () => {
+          if (!child && allowedSignal === "SIGKILL") {
+            exitTracker.markKillConfirmed?.();
+          }
+        },
+        () => {
+          child?.kill(allowedSignal);
+        }
+      );
+    },
+    shutdown() {
+      void callAgentViewPtyHost(socketPath, authToken, "shutdown").then(
+        () => {
+          if (!child) {
+            exitTracker.markShutdownConfirmed?.();
+          }
+        },
+        () => {
+          child?.kill("SIGTERM");
+        }
+      );
+      attachSocket?.destroy();
+    },
+    dispose() {
+      void callAgentViewPtyHost(socketPath, authToken, "shutdown").catch(() => {
+        child?.kill("SIGTERM");
+      });
+      attachSocket?.destroy();
+      exitTracker.resolve({ kind: "unreachable" });
+    }
+  };
+}
+__name(createRemotePtyHostHandle, "createRemotePtyHostHandle");
+function createChildExitTracker(child) {
+  let resolveExit = /* @__PURE__ */ __name(() => {
+  }, "resolveExit");
+  const exited = new Promise((resolve3) => {
+    resolveExit = resolve3;
+    child.once("exit", (code, signal) => {
+      const signalNumber = signal ? os.constants.signals[signal] : void 0;
+      resolve3({
+        kind: "exited",
+        exitCode: typeof code === "number" ? code : 1,
+        ...signalNumber ? { signal: signalNumber } : {}
+      });
+    });
+  });
+  return { exited, resolve: resolveExit };
+}
+__name(createChildExitTracker, "createChildExitTracker");
+function createRemoteExitTracker(socketPath, authToken) {
+  let settled = false;
+  let pollInFlight = false;
+  let resolveExit = /* @__PURE__ */ __name(() => {
+  }, "resolveExit");
+  const exited = new Promise((resolve3) => {
+    resolveExit = resolve3;
+  });
+  let consecutiveFailures = 0;
+  let confirmedTermination;
+  let confirmedTerminationPoll;
+  const scheduleConfirmedPoll = /* @__PURE__ */ __name(() => {
+    if (settled || !confirmedTermination) return;
+    clearTimeout(confirmedTerminationPoll);
+    confirmedTerminationPoll = setTimeout(poll, 50);
+    confirmedTerminationPoll.unref?.();
+  }, "scheduleConfirmedPoll");
+  const poll = /* @__PURE__ */ __name(() => {
+    if (settled || pollInFlight) return;
+    pollInFlight = true;
+    void callAgentViewPtyHost(socketPath, authToken, "status").then(() => {
+      if (settled) return;
+      consecutiveFailures = 0;
+    }).catch(() => {
+      if (settled) return;
+      if (++consecutiveFailures >= 2) {
+        resolveExitOnce(
+          confirmedTermination === "kill" ? { kind: "confirmed-kill" } : confirmedTermination === "shutdown" ? { kind: "confirmed-shutdown" } : { kind: "unreachable" }
+        );
+      }
+    }).finally(() => {
+      pollInFlight = false;
+      scheduleConfirmedPoll();
+    });
+  }, "poll");
+  const interval = setInterval(poll, REMOTE_HOST_EXIT_POLL_MS);
+  interval.unref?.();
+  const resolveExitOnce = /* @__PURE__ */ __name((exit) => {
+    if (settled) return;
+    settled = true;
+    clearInterval(interval);
+    clearTimeout(confirmedTerminationPoll);
+    resolveExit(exit);
+  }, "resolveExitOnce");
+  return {
+    exited,
+    resolve: resolveExitOnce,
+    markKillConfirmed: /* @__PURE__ */ __name(() => {
+      if (confirmedTermination) return;
+      confirmedTermination = "kill";
+      poll();
+    }, "markKillConfirmed"),
+    markShutdownConfirmed: /* @__PURE__ */ __name(() => {
+      if (confirmedTermination) return;
+      confirmedTermination = "shutdown";
+      poll();
+    }, "markShutdownConfirmed")
+  };
+}
+__name(createRemoteExitTracker, "createRemoteExitTracker");
+async function runAgentViewPtyHostProcess({
+  launchPath,
+  socketPath,
+  authToken,
+  hostId,
+  loadPty
+}) {
+  const launch = JSON.parse(await fs3.readFile(launchPath, "utf8"));
+  const host = await launchAgentViewPtyHost(launch, {
+    ...loadPty ? { loadPty } : {}
+  });
+  const server = createAgentViewPtyHostServer(host, socketPath, {
+    authToken: authToken ?? process.env[PTY_HOST_AUTH_TOKEN_ENV],
+    hostId: hostId ?? process.env[PTY_HOST_ID_ENV]
+  });
+  try {
+    await server.listen();
+  } catch (error) {
+    host.dispose();
+    throw error;
+  }
+  await host.exited.finally(async () => {
+    host.dispose();
+    await server.close();
+  });
+}
+__name(runAgentViewPtyHostProcess, "runAgentViewPtyHostProcess");
+function getAgentViewPtyHostSocketPath(sessionId, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const digest = shortHash(`${options.globalDir ?? ""}:${sessionId}:pty-host`);
+  if (platform === "win32") {
+    return `\\\\.\\pipe\\o1-code-agent-pty-${digest}`;
+  }
+  const tmpDir = getAgentViewSessionPaths(sessionId, {
+    ...options.globalDir ? { globalDir: options.globalDir } : {}
+  }).tmpDir;
+  const candidate = path3.join(tmpDir, "pty-host.sock");
+  if (Buffer.byteLength(candidate) < UNIX_SOCKET_PATH_LIMIT) {
+    return candidate;
+  }
+  const uid = typeof process.getuid === "function" ? process.getuid() : "user";
+  const fallbackCandidates = [
+    path3.join(os.tmpdir(), `o1-code-avp-${uid}`, `${digest}.sock`),
+    path3.join("/tmp", `o1-code-avp-${uid}`, `${digest}.sock`)
+  ];
+  const fallback = fallbackCandidates.find(
+    (item) => Buffer.byteLength(item) < UNIX_SOCKET_PATH_LIMIT && canPrepareSocketDirectory(path3.dirname(item))
+  );
+  const lengthFallback = fallbackCandidates.find(
+    (item) => Buffer.byteLength(item) < UNIX_SOCKET_PATH_LIMIT
+  );
+  if (fallback) {
+    return fallback;
+  }
+  if (lengthFallback) {
+    throw new Error(
+      "Agent View PTY host socket fallback directories are not writable."
+    );
+  }
+  throw new Error("Agent View PTY host socket path is too long.");
+}
+__name(getAgentViewPtyHostSocketPath, "getAgentViewPtyHostSocketPath");
+async function callAgentViewPtyHost(socketPath, authToken, op, params, timeoutMs) {
+  const response = await requestAgentViewPtyHost(
+    socketPath,
+    {
+      id: createRequestId(),
+      op,
+      ...authToken ? { authToken } : {},
+      ...params ? { params } : {}
+    },
+    timeoutMs ? { timeoutMs } : {}
+  );
+  if (response.ok) return response.result;
+  throw new AgentViewPtyHostRequestError(
+    response.error.code,
+    response.error.message
+  );
+}
+__name(callAgentViewPtyHost, "callAgentViewPtyHost");
+var AgentViewPtyHostRequestError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AgentViewPtyHostRequestError";
+  }
+  static {
+    __name(this, "AgentViewPtyHostRequestError");
+  }
+};
+var AgentViewPtyHostProtocolError = class extends Error {
+  static {
+    __name(this, "AgentViewPtyHostProtocolError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "AgentViewPtyHostProtocolError";
+  }
+};
+async function requestAgentViewPtyHost(socketPath, request, options = {}) {
+  return new Promise((resolve3, reject) => {
+    const socket = net.createConnection(socketPath);
+    let buffer = "";
+    let settled = false;
+    const timeout = setTimeout(() => {
+      finish(
+        void 0,
+        new Error("Timed out waiting for Agent View PTY host.")
+      );
+      socket.destroy();
+    }, options.timeoutMs ?? 5e3);
+    const finish = /* @__PURE__ */ __name((response, error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      socket.removeAllListeners();
+      if (error) {
+        reject(error);
+      } else {
+        resolve3(response);
+      }
+    }, "finish");
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify(request)}
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      if (Buffer.byteLength(buffer, "utf8") > MAX_PTY_HOST_RESPONSE_LINE_BYTES) {
+        finish(
+          void 0,
+          new AgentViewPtyHostProtocolError(
+            "Agent View PTY host response line is too large."
+          )
+        );
+        socket.destroy();
+        return;
+      }
+      const newline = buffer.indexOf("\n");
+      if (newline === -1) return;
+      try {
+        finish(parseHostResponse(buffer.slice(0, newline)));
+      } catch (error) {
+        finish(void 0, error);
+      } finally {
+        socket.end();
+      }
+    });
+    socket.on("error", (error) => finish(void 0, error));
+    socket.on("close", () => {
+      finish(void 0, new Error("Agent View PTY host connection closed."));
+    });
+  });
+}
+__name(requestAgentViewPtyHost, "requestAgentViewPtyHost");
+function createAgentViewPtyHostServer(host, socketPath, options = {}) {
+  const attachState = {
+    activeAttachSocket: void 0
+  };
+  const openSockets = /* @__PURE__ */ new Set();
+  const server = net.createServer((socket) => {
+    openSockets.add(socket);
+    socket.once("close", () => {
+      openSockets.delete(socket);
+    });
+    socket.on("error", () => {
+    });
+    socket.setTimeout(5e3, () => {
+      socket.destroy();
+    });
+    let buffer = Buffer.alloc(0);
+    socket.on("data", (chunk) => {
+      buffer = buffer.length === 0 ? chunk : Buffer.concat([buffer, chunk]);
+      if (buffer.length > MAX_PTY_HOST_REQUEST_LINE_BYTES) {
+        socket.destroy();
+        return;
+      }
+      const newline = buffer.indexOf(10);
+      if (newline === -1) return;
+      const line = buffer.toString("utf8", 0, newline);
+      const leftover = Buffer.from(buffer.subarray(newline + 1));
+      buffer = Buffer.alloc(0);
+      socket.pause();
+      void respondToHostLine(
+        host,
+        line,
+        socket,
+        attachState,
+        leftover,
+        options.authToken,
+        options.hostId,
+        options.shutdownGraceMs
+      ).catch(() => {
+        socket.destroy();
+      });
+    });
+  });
+  let releaseLock;
+  return {
+    async listen() {
+      if (!isWindowsPipePath(socketPath)) {
+        releaseLock = await acquireSocketPathLock(socketPath);
+      }
+      try {
+        await prepareSocketPath(socketPath);
+        await new Promise((resolve3, reject) => {
+          server.once("error", reject);
+          server.listen(socketPath, () => {
+            server.off("error", reject);
+            server.on("error", () => {
+            });
+            if (isWindowsPipePath(socketPath)) {
+              resolve3();
+              return;
+            }
+            fs3.chmod(socketPath, 384).then(resolve3, (error) => {
+              server.close(() => reject(error));
+            });
+          });
+        });
+        if (!isWindowsPipePath(socketPath)) {
+          const lockContent = await fs3.readFile(`${socketPath}.lock`, "utf8").catch(() => "");
+          if (lockContent !== String(process.pid)) {
+            releaseLock = void 0;
+            for (const socket of openSockets) {
+              socket.destroy();
+            }
+            await new Promise((resolve3) => server.close(() => resolve3()));
+            const displaced = new Error(
+              `Agent View PTY host socket is already in use: ${socketPath}`
+            );
+            displaced.code = "EADDRINUSE";
+            throw displaced;
+          }
+        }
+      } catch (error) {
+        await releaseLock?.();
+        releaseLock = void 0;
+        throw error;
+      }
+    },
+    async close() {
+      attachState.activeAttachSocket?.destroy();
+      for (const socket of openSockets) {
+        socket.destroy();
+      }
+      await new Promise((resolve3, reject) => {
+        if (!server.listening) {
+          resolve3();
+          return;
+        }
+        server.close((error) => error ? reject(error) : resolve3());
+      });
+      await removeOwnedSocketPath(socketPath);
+      await releaseLock?.();
+      releaseLock = void 0;
+    }
+  };
+}
+__name(createAgentViewPtyHostServer, "createAgentViewPtyHostServer");
+async function respondToHostLine(host, line, socket, attachState, leftover = Buffer.alloc(0), authToken, hostId, shutdownGraceMs) {
+  const request = parseHostRequest(line);
+  if (!request) {
+    socket.end(
+      `${JSON.stringify(errorResponse("", "invalid_json", "Invalid JSON."))}
+`
+    );
+    return;
+  }
+  if (authToken && !isValidAuthToken(request.authToken, authToken)) {
+    socket.end(
+      `${JSON.stringify(
+        errorResponse(
+          request.id,
+          "unauthorized",
+          "Unauthorized PTY host request."
+        )
+      )}
+`
+    );
+    return;
+  }
+  if (request.op === "attachStream") {
+    if (attachState.activeAttachSocket?.destroyed === false) {
+      socket.end(
+        `${JSON.stringify(
+          errorResponse(
+            request.id,
+            "already_attached",
+            "Agent View PTY host already has an attached stream."
+          )
+        )}
+`
+      );
+      return;
+    }
+    attachState.activeAttachSocket = socket;
+    host.resetInput?.();
+    const clearActiveAttach = /* @__PURE__ */ __name(() => {
+      if (attachState.activeAttachSocket === socket) {
+        attachState.activeAttachSocket = void 0;
+      }
+    }, "clearActiveAttach");
+    socket.once("close", clearActiveAttach);
+    socket.removeAllListeners("data");
+    socket.setTimeout(0);
+    socket.resume();
+    try {
+      socket.write(
+        `${JSON.stringify({
+          id: request.id,
+          ok: true,
+          result: { attached: true }
+        })}
+`
+      );
+      if (leftover.length > 0) {
+        host.write(leftover);
+      }
+      await bridgeAgentViewTerminal({
+        stdin: socket,
+        stdout: socket,
+        pty: host
+      });
+    } finally {
+      socket.off("close", clearActiveAttach);
+      clearActiveAttach();
+      socket.end();
+    }
+    return;
+  }
+  try {
+    const result = await handleHostRequest(
+      host,
+      request,
+      hostId,
+      shutdownGraceMs
+    );
+    socket.end(`${JSON.stringify({ id: request.id, ok: true, result })}
+`);
+  } catch (error) {
+    socket.end(
+      `${JSON.stringify(
+        errorResponse(
+          request.id,
+          "internal_error",
+          error instanceof Error ? error.message : "PTY host request failed."
+        )
+      )}
+`
+    );
+  }
+}
+__name(respondToHostLine, "respondToHostLine");
+async function handleHostRequest(host, request, hostId, shutdownGraceMs) {
+  switch (request.op) {
+    case "status":
+      return {
+        ...hostId ? { hostId } : {},
+        pid: process.pid,
+        workerPid: host.workerPid
+      };
+    case "logs":
+      return { output: host.output.toString() };
+    case "resize":
+      host.resize({
+        columns: positiveIntegerParam(request.params, "columns"),
+        rows: positiveIntegerParam(request.params, "rows")
+      });
+      return { resized: true };
+    case "kill":
+      host.kill(signalParam(request.params) ?? "SIGTERM");
+      return { killed: true };
+    case "shutdown":
+      await shutdownHost(host, shutdownGraceMs);
+      return { shuttingDown: true };
+    case "attachStream":
+      throw new Error("attachStream must use the streaming path.");
+    default: {
+      const unknownOperation = request.op;
+      throw new Error(`Unsupported PTY host operation: ${unknownOperation}`);
+    }
+  }
+}
+__name(handleHostRequest, "handleHostRequest");
+async function shutdownHost(host, graceMs = SHUTDOWN_GRACE_MS) {
+  if (host.shutdown) {
+    await host.shutdown();
+  } else {
+    host.kill("SIGTERM");
+  }
+  const timer = setTimeout(() => {
+    try {
+      host.kill("SIGKILL");
+    } catch {
+    }
+  }, graceMs);
+  timer.unref?.();
+  const cancel = /* @__PURE__ */ __name(() => clearTimeout(timer), "cancel");
+  void host.exited.then(cancel, cancel);
+}
+__name(shutdownHost, "shutdownHost");
+async function waitForSpawnedPtyHost(socketPath, child, authToken, hostId) {
+  return new Promise((resolve3, reject) => {
+    let settled = false;
+    const abortController = new AbortController();
+    const cleanup = /* @__PURE__ */ __name(() => {
+      abortController.abort();
+      child.off("exit", onExit);
+      child.off("error", onError);
+    }, "cleanup");
+    const finishResolve = /* @__PURE__ */ __name((value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve3(value);
+    }, "finishResolve");
+    const finishReject = /* @__PURE__ */ __name((error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    }, "finishReject");
+    const onExit = /* @__PURE__ */ __name((code, signal) => {
+      const suffix = signal ? `signal ${signal}` : `code ${code ?? "unknown"}`;
+      finishReject(
+        new Error(`Agent View PTY host exited before ready (${suffix}).`)
+      );
+    }, "onExit");
+    const onError = /* @__PURE__ */ __name((error) => {
+      finishReject(error);
+    }, "onError");
+    child.once("exit", onExit);
+    child.once("error", onError);
+    void waitForPtyHost(socketPath, HOST_READY_RETRIES, authToken, {
+      requestTimeoutMs: HOST_READY_REQUEST_TIMEOUT_MS,
+      expectedHostId: hostId,
+      signal: abortController.signal
+    }).then(
+      (status) => finishResolve(status),
+      (error) => {
+        if (abortController.signal.aborted && settled) return;
+        finishReject(error instanceof Error ? error : new Error(String(error)));
+      }
+    );
+  });
+}
+__name(waitForSpawnedPtyHost, "waitForSpawnedPtyHost");
+async function waitForPtyHost(socketPath, retries = HOST_READY_RETRIES, authToken, options = {}) {
+  const requestTimeoutMs = options.requestTimeoutMs ?? 5e3;
+  const deadlineMs = Date.now() + retries * (HOST_READY_DELAY_MS + requestTimeoutMs);
+  for (let attempt = 0; attempt < retries; attempt++) {
+    if (options.signal?.aborted || Date.now() >= deadlineMs) break;
+    try {
+      const result = await callAgentViewPtyHost(
+        socketPath,
+        authToken,
+        "status",
+        void 0,
+        requestTimeoutMs
+      );
+      if (isRecord3(result) && Number.isInteger(result["workerPid"])) {
+        const hostId = typeof result["hostId"] === "string" ? result["hostId"] : void 0;
+        if (options.expectedHostId && hostId !== options.expectedHostId) {
+          throw new AgentViewPtyHostProtocolError(
+            "Agent View PTY host identity does not match."
+          );
+        }
+        return {
+          ...hostId ? { hostId } : {},
+          pid: Number.isInteger(result["pid"]) ? Number(result["pid"]) : process.pid,
+          workerPid: Number(result["workerPid"])
+        };
+      }
+    } catch (error) {
+      if (error instanceof AgentViewPtyHostProtocolError || error instanceof AgentViewPtyHostRequestError && error.code === "unauthorized") {
+        throw error;
+      }
+    }
+    await delay(HOST_READY_DELAY_MS, options.signal);
+  }
+  throw new Error("Agent View PTY host did not become ready.");
+}
+__name(waitForPtyHost, "waitForPtyHost");
+function defaultSpawnPtyHost(args, env, stderrLogPath) {
+  const argv = buildCurrentO1CodeCliArgv(args);
+  let stderrFd;
+  if (stderrLogPath) {
+    try {
+      stderrFd = openSync(stderrLogPath, "w", 384);
+    } catch {
+    }
+  }
+  try {
+    return spawn(argv[0], argv.slice(1), {
+      detached: true,
+      windowsHide: true,
+      stdio: ["ignore", "ignore", stderrFd ?? "ignore"],
+      env: {
+        ...process.env,
+        ...env,
+        O1CODE_NO_RELAUNCH: "1"
+      }
+    });
+  } finally {
+    if (stderrFd !== void 0) closeSync(stderrFd);
+  }
+}
+__name(defaultSpawnPtyHost, "defaultSpawnPtyHost");
+async function withHostStderrTail(error, stderrLogPath) {
+  const base = error instanceof Error ? error : new Error(String(error));
+  const tail = await fs3.readFile(stderrLogPath, "utf8").then((text) => text.trim().slice(-2048)).catch(() => "");
+  if (!tail) return base;
+  return new Error(`${base.message} Host stderr: ${tail}`, { cause: base });
+}
+__name(withHostStderrTail, "withHostStderrTail");
+function parseHostRequest(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (!isRecord3(parsed) || typeof parsed["id"] !== "string" || !isHostOperation(parsed["op"])) {
+      return void 0;
+    }
+    return {
+      id: parsed["id"],
+      op: parsed["op"],
+      ...typeof parsed["authToken"] === "string" ? { authToken: parsed["authToken"] } : {},
+      ...isRecord3(parsed["params"]) ? { params: parsed["params"] } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+__name(parseHostRequest, "parseHostRequest");
+function parseHostResponse(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (error) {
+    throw new AgentViewPtyHostProtocolError(
+      error instanceof Error ? error.message : "Invalid PTY host response."
+    );
+  }
+  if (!isRecord3(parsed) || typeof parsed["id"] !== "string") {
+    throw new AgentViewPtyHostProtocolError(
+      "Invalid Agent View PTY host response."
+    );
+  }
+  if (parsed["ok"] === true) {
+    return { id: parsed["id"], ok: true, result: parsed["result"] };
+  }
+  if (parsed["ok"] === false && isRecord3(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 AgentViewPtyHostProtocolError(
+    "Invalid Agent View PTY host response."
+  );
+}
+__name(parseHostResponse, "parseHostResponse");
+function isHostOperation(value) {
+  return HOST_OPERATIONS.includes(value);
+}
+__name(isHostOperation, "isHostOperation");
+function errorResponse(id, code, message) {
+  return { id, ok: false, error: { code, message } };
+}
+__name(errorResponse, "errorResponse");
+async function acquireSocketPathLock(socketPath) {
+  const lockPath = `${socketPath}.lock`;
+  await fs3.mkdir(path3.dirname(socketPath), { recursive: true, mode: 448 });
+  while (true) {
+    try {
+      await fs3.writeFile(lockPath, String(process.pid), { flag: "wx" });
+      return async () => {
+        const current = await fs3.readFile(lockPath, "utf8").catch(() => "");
+        if (current === String(process.pid)) {
+          await fs3.rm(lockPath, { force: true });
+        }
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const raw = await fs3.readFile(lockPath, "utf8").catch(() => "");
+      const holderPid = Number.parseInt(raw, 10);
+      if (!Number.isInteger(holderPid) || !isProcessAlive2(holderPid)) {
+        const current = await fs3.readFile(lockPath, "utf8").catch(() => "");
+        if (current === raw) {
+          await fs3.rm(lockPath, { force: true });
+        }
+        continue;
+      }
+      break;
+    }
+  }
+  const busy = new Error(
+    `Agent View PTY host socket is already in use: ${socketPath}`
+  );
+  busy.code = "EADDRINUSE";
+  throw busy;
+}
+__name(acquireSocketPathLock, "acquireSocketPathLock");
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+__name(isProcessAlive2, "isProcessAlive");
+async function prepareSocketPath(socketPath) {
+  if (isWindowsPipePath(socketPath)) return;
+  const socketDir = path3.dirname(socketPath);
+  await fs3.mkdir(socketDir, { recursive: true, mode: 448 });
+  await ensurePrivateSocketDirectory(socketDir);
+  if (!await socketPathExists(socketPath)) return;
+  if (await canConnect(socketPath)) {
+    const error = new Error(
+      `Agent View PTY host socket is already in use: ${socketPath}`
+    );
+    error.code = "EADDRINUSE";
+    throw error;
+  }
+  await removeSocketPath(socketPath);
+}
+__name(prepareSocketPath, "prepareSocketPath");
+async function ensurePrivateSocketDirectory(socketDir) {
+  const stat = await fs3.lstat(socketDir);
+  if (stat.isSymbolicLink()) {
+    throw new Error("Agent View PTY host socket parent must not be a symlink.");
+  }
+  if (!stat.isDirectory()) {
+    throw new Error("Agent View PTY host socket parent is not a directory.");
+  }
+  if (typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+    throw new Error("Agent View PTY host socket parent is not owned by you.");
+  }
+  if ((stat.mode & 63) !== 0) {
+    await fs3.chmod(socketDir, 448);
+  }
+}
+__name(ensurePrivateSocketDirectory, "ensurePrivateSocketDirectory");
+function canPrepareSocketDirectory(socketDir) {
+  try {
+    const stat = lstatSync(socketDir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) return false;
+    if (typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+      return false;
+    }
+    accessSync(socketDir, fsConstants.W_OK | fsConstants.X_OK);
+    return true;
+  } catch (error) {
+    if (!isNodeError2(error) || error.code !== "ENOENT") return false;
+  }
+  const parentDir = path3.dirname(socketDir);
+  try {
+    const parentStat = statSync(parentDir);
+    if (!parentStat.isDirectory()) return false;
+    accessSync(parentDir, fsConstants.W_OK | fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(canPrepareSocketDirectory, "canPrepareSocketDirectory");
+async function removeSocketPath(socketPath) {
+  if (isWindowsPipePath(socketPath)) return;
+  try {
+    await fs3.unlink(socketPath);
+  } catch (error) {
+    if (!isNodeError2(error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+__name(removeSocketPath, "removeSocketPath");
+async function removeOwnedSocketPath(socketPath) {
+  if (isWindowsPipePath(socketPath)) return;
+  if (!await socketPathExists(socketPath)) return;
+  if (await canConnect(socketPath)) return;
+  await removeSocketPath(socketPath);
+}
+__name(removeOwnedSocketPath, "removeOwnedSocketPath");
+async function socketPathExists(socketPath) {
+  try {
+    await fs3.lstat(socketPath);
+    return true;
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+__name(socketPathExists, "socketPathExists");
+async function canConnect(socketPath) {
+  return new Promise((resolve3) => {
+    const socket = net.createConnection(socketPath);
+    let settled = false;
+    function finish(result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve3(result);
+    }
+    __name(finish, "finish");
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    const timeout = setTimeout(() => finish(false), 250);
+  });
+}
+__name(canConnect, "canConnect");
+function positiveIntegerParam(params, key) {
+  const value = params?.[key];
+  if (!Number.isInteger(value) || Number(value) <= 0) {
+    throw new Error(`Agent View PTY host ${key} must be a positive integer.`);
+  }
+  return Number(value);
+}
+__name(positiveIntegerParam, "positiveIntegerParam");
+function signalParam(params) {
+  return killSignalValue(params?.["signal"]);
+}
+__name(signalParam, "signalParam");
+function killSignalValue(value) {
+  if (value === void 0 || value === "") return void 0;
+  if (typeof value === "string" && ALLOWED_KILL_SIGNALS.has(value)) {
+    return value;
+  }
+  throw new Error("Agent View PTY host signal is not allowed.");
+}
+__name(killSignalValue, "killSignalValue");
+function isValidAuthToken(provided, expected) {
+  if (!provided) return false;
+  const providedBuffer = Buffer.from(provided);
+  const expectedBuffer = Buffer.from(expected);
+  return providedBuffer.length === expectedBuffer.length && timingSafeEqual(providedBuffer, expectedBuffer);
+}
+__name(isValidAuthToken, "isValidAuthToken");
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord3, "isRecord");
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+__name(isNodeError2, "isNodeError");
+function isWindowsPipePath(socketPath) {
+  return socketPath.startsWith("\\\\.\\pipe\\");
+}
+__name(isWindowsPipePath, "isWindowsPipePath");
+function shortHash(value) {
+  return createHash2("sha256").update(value).digest("hex").slice(0, 12);
+}
+__name(shortHash, "shortHash");
+function createRequestId() {
+  return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+__name(createRequestId, "createRequestId");
+async function delay(ms, signal) {
+  await new Promise((resolve3) => {
+    if (signal?.aborted) {
+      resolve3();
+      return;
+    }
+    const onAbort = /* @__PURE__ */ __name(() => {
+      clearTimeout(timeout);
+      resolve3();
+    }, "onAbort");
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve3();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+__name(delay, "delay");
+
+export {
+  getAgentViewStorePaths,
+  getAgentViewSessionPaths,
+  readAgentViewRosterStrict,
+  upsertAgentViewRosterEntry,
+  removeAgentViewRosterEntry,
+  updateAgentViewRosterEntry,
+  readAgentViewSessionState,
+  writeAgentViewSessionState,
+  patchAgentViewSessionState,
+  patchAgentViewSessionStateIf,
+  listAgentViewSessionStates,
+  listAgentViewSessionSnapshots,
+  readAgentViewLaunch,
+  writeAgentViewLaunch,
+  readAgentViewActivity,
+  writeAgentViewActivity,
+  patchAgentViewActivityIf,
+  clearAgentViewWorkerPids,
+  digestAgentViewWorkerToken,
+  readAgentViewWorker,
+  writeAgentViewWorker,
+  readAgentViewSupervisor,
+  writeAgentViewSupervisor,
+  sanitizeSessionId,
+  redactAgentViewActivity,
+  redactAgentViewWorker,
+  isAgentViewSessionState,
+  inputKindValue,
+  getCurrentO1CodeCliEntrypoint,
+  buildCurrentO1CodeCliArgv,
+  INTERNAL_AGENT_VIEW_PTY_HOST_ARG,
+  createAgentViewPtyHostIdentity,
+  launchAgentViewPtyHostProcess,
+  connectAgentViewPtyHostProcess,
+  runAgentViewPtyHostProcess,
+  getAgentViewPtyHostSocketPath,
+  createAgentViewPtyHostServer
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */