sootsim 0.0.1 → 0.0.2

package/dist-lib/agent-sessions.cjs

@@ -0,0 +1,692 @@
+/*! sootsim v0.0.2 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent-sessions.ts
+var agent_sessions_exports = {};
+__export(agent_sessions_exports, {
+  AgentSessionError: () => AgentSessionError,
+  endSession: () => endSession,
+  eventsFifoPath: () => eventsFifoPath,
+  mkfifoSync: () => mkfifoSync,
+  pidIsAlive: () => pidIsAlive,
+  promptFifoPath: () => promptFifoPath,
+  resolveSootsimInvocation: () => resolveSootsimInvocation,
+  sendPrompt: () => sendPrompt,
+  sessionDir: () => sessionDir,
+  startSession: () => startSession,
+  subscribeEvents: () => subscribeEvents,
+  transcriptPath: () => transcriptPath
+});
+module.exports = __toCommonJS(agent_sessions_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_readline = __toESM(require("node:readline"), 1);
+
+// src/agent-events.ts
+function isAgentEvent(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.type === "string" && typeof v.ts === "number";
+}
+function parseAgentEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return isAgentEvent(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/agent-prompt.ts
+var ENVELOPE_MARKER = "sootsim-agent-prompt-v1";
+function cleanPromptText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function encodeAgentPromptEnvelope(input) {
+  const text = cleanPromptText(input.text);
+  if (!text) return "";
+  const displayText = cleanPromptText(input.displayText);
+  const inspectSummary = cleanPromptText(input.inspectSummary);
+  const inspectTrace = cleanPromptText(input.inspectTrace);
+  const needsEnvelope = !!inspectSummary || !!inspectTrace || /[\r\n]/.test(text) || !!displayText && displayText !== text;
+  if (!needsEnvelope) return text;
+  return JSON.stringify({
+    __sootsimAgentPrompt: ENVELOPE_MARKER,
+    text,
+    displayText,
+    inspectSummary,
+    inspectTrace
+  });
+}
+
+// src/attached-projects.ts
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var overrideDir = null;
+function userDataDir() {
+  if (overrideDir) return overrideDir;
+  const fromEnv = process.env.SOOTSIM_USER_DATA_DIR;
+  if (fromEnv) return fromEnv;
+  try {
+    const electron = require("electron");
+    if (electron.app?.getPath) return electron.app.getPath("userData");
+  } catch {
+  }
+  return platformDefaultUserDataDir();
+}
+function platformDefaultUserDataDir() {
+  const home = import_node_os.default.homedir();
+  if (process.platform === "darwin") {
+    return import_node_path.default.join(home, "Library", "Application Support", "sootsim");
+  }
+  if (process.platform === "win32") {
+    return import_node_path.default.join(process.env.APPDATA || home, "sootsim");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME || import_node_path.default.join(home, ".config");
+  return import_node_path.default.join(xdg, "sootsim");
+}
+function getUserDataDir() {
+  return userDataDir();
+}
+function storeFile() {
+  return import_node_path.default.join(userDataDir(), "attached-projects.json");
+}
+function cloneEmpty() {
+  return {
+    version: 1,
+    attachedProjects: [],
+    previewAttachments: [],
+    agentSessions: []
+  };
+}
+function loadStore() {
+  const file = storeFile();
+  let raw;
+  try {
+    raw = import_node_fs.default.readFileSync(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return cloneEmpty();
+    throw err;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") throw new Error("not an object");
+    return {
+      version: 1,
+      attachedProjects: Array.isArray(parsed.attachedProjects) ? parsed.attachedProjects : [],
+      previewAttachments: Array.isArray(parsed.previewAttachments) ? parsed.previewAttachments : [],
+      agentSessions: Array.isArray(parsed.agentSessions) ? parsed.agentSessions : []
+    };
+  } catch (err) {
+    const quarantine = `${file}.corrupt-${Date.now()}`;
+    try {
+      import_node_fs.default.renameSync(file, quarantine);
+      console.warn(
+        `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
+      );
+    } catch {
+    }
+    return cloneEmpty();
+  }
+}
+function writeStore(store) {
+  const file = storeFile();
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  const fd = import_node_fs.default.openSync(tmp, "w", 384);
+  try {
+    import_node_fs.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs.default.fsyncSync(fd);
+  } finally {
+    import_node_fs.default.closeSync(fd);
+  }
+  import_node_fs.default.renameSync(tmp, file);
+}
+function mutateStore(fn) {
+  const store = loadStore();
+  fn(store);
+  writeStore(store);
+  return store;
+}
+function newSessionId() {
+  return `s_${(0, import_node_crypto.randomBytes)(10).toString("hex")}`;
+}
+function findProjectById(id) {
+  return loadStore().attachedProjects.find((p) => p.id === id) ?? null;
+}
+var COST_HISTORY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+function upsertSession(input) {
+  let result;
+  mutateStore((store) => {
+    if (input.id) {
+      const existing = store.agentSessions.find((s) => s.id === input.id);
+      if (existing) {
+        const merged = {
+          ...existing,
+          ...input,
+          lastSeenAt: Date.now()
+        };
+        const idx = store.agentSessions.indexOf(existing);
+        store.agentSessions[idx] = merged;
+        result = merged;
+        return;
+      }
+    }
+    const project = store.attachedProjects.find((p) => p.id === input.projectId);
+    if (!project) {
+      throw new Error(`upsertSession: no AttachedProject with id=${input.projectId}`);
+    }
+    const now = Date.now();
+    const created = {
+      id: input.id ?? newSessionId(),
+      projectId: input.projectId,
+      provider: input.provider,
+      transport: input.transport ?? project.preferredTransport,
+      cwd: input.cwd ?? project.cwd,
+      claudeSessionUuid: input.claudeSessionUuid,
+      tmuxSessionName: input.tmuxSessionName,
+      wrapperPid: input.wrapperPid,
+      status: input.status ?? "idle",
+      needsAttention: input.needsAttention ?? false,
+      lastPrompt: input.lastPrompt,
+      lastSummary: input.lastSummary,
+      lastTurnFiles: input.lastTurnFiles,
+      currentlyEditing: input.currentlyEditing,
+      lastSeenAt: now,
+      createdAt: now
+    };
+    store.agentSessions.push(created);
+    result = created;
+  });
+  return result;
+}
+function findSessionById(id) {
+  return loadStore().agentSessions.find((s) => s.id === id) ?? null;
+}
+function listSessions(projectId) {
+  const all = loadStore().agentSessions;
+  return projectId ? all.filter((s) => s.projectId === projectId) : all;
+}
+function updateSessionStatus(id, patch) {
+  mutateStore((store) => {
+    const existing = store.agentSessions.find((s) => s.id === id);
+    if (!existing) return;
+    const idx = store.agentSessions.indexOf(existing);
+    store.agentSessions[idx] = {
+      ...existing,
+      ...patch,
+      id: existing.id,
+      projectId: existing.projectId,
+      createdAt: existing.createdAt,
+      lastSeenAt: Date.now()
+    };
+  });
+}
+
+// src/agent-sessions.ts
+function sessionDir(sessionId) {
+  return import_node_path2.default.join(getUserDataDir(), "sessions", sessionId);
+}
+function promptFifoPath(sessionId) {
+  return import_node_path2.default.join(sessionDir(sessionId), "prompt.in");
+}
+function eventsFifoPath(sessionId) {
+  return import_node_path2.default.join(sessionDir(sessionId), "events.out");
+}
+function transcriptPath(sessionId) {
+  return import_node_path2.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+}
+function pidIsAlive(pid, sessionId) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  if (sessionId) {
+    if (!import_node_fs2.default.existsSync(sessionDir(sessionId))) return false;
+  }
+  return true;
+}
+function resolveSootsimInvocation() {
+  if (process.env.SOOTSIM_BIN) {
+    return { cmd: process.env.SOOTSIM_BIN, prefixArgs: [] };
+  }
+  if (process.versions.electron) {
+    const resourcesPath = process.resourcesPath;
+    if (resourcesPath) {
+      const candidates = [
+        import_node_path2.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path2.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+      ];
+      for (const c of candidates) {
+        if (import_node_fs2.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
+      }
+    }
+  }
+  const workspace = tryWorkspaceSootsim();
+  if (workspace) return workspace;
+  const argv0 = process.argv[0];
+  const argv1 = process.argv[1];
+  if (argv1 && /\.(ts|tsx|mjs|cjs|js)$/.test(argv1)) {
+    return { cmd: argv0, prefixArgs: [argv1] };
+  }
+  if (!argv1 || argv1.includes("/.bin/")) {
+    throw new Error(
+      "sootsim CLI not found. set SOOTSIM_BIN to the path of the sootsim binary, or build the workspace CLI via `bun run --cwd packages/sootsim build:cli`."
+    );
+  }
+  return { cmd: argv0, prefixArgs: [] };
+}
+function tryWorkspaceSootsim() {
+  try {
+    const sootsimDir = resolveSootsimPackageDir();
+    if (!sootsimDir) return null;
+    const binaryName = `sootsim-${process.platform}-${process.arch}`;
+    const distBinary = import_node_path2.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs2.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
+    const distBin = import_node_path2.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs2.default.existsSync(distBin)) {
+      try {
+        const src = import_node_path2.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        if (import_node_fs2.default.existsSync(src)) {
+          const srcMtime = import_node_fs2.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs2.default.statSync(distBin).mtimeMs;
+          if (buildMtime < srcMtime) {
+            console.warn(
+              `[sootsim] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/sootsim build:cli\` (watch:cli:binary builds dist-bin/ instead).`
+            );
+          }
+        }
+      } catch {
+      }
+      return { cmd: process.execPath, prefixArgs: [distBin] };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function resolveSootsimPackageDir() {
+  try {
+    const resolved = require.resolve("sootsim/package.json");
+    return import_node_path2.default.dirname(resolved);
+  } catch {
+  }
+  const here = fileFromImportMeta();
+  if (!here) return null;
+  let cur = import_node_path2.default.dirname(here);
+  for (let i = 0; i < 8; i++) {
+    const pkg = import_node_path2.default.join(cur, "package.json");
+    try {
+      if (import_node_fs2.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs2.default.readFileSync(pkg, "utf8"));
+        if (parsed.name === "sootsim") return cur;
+      }
+    } catch {
+    }
+    const parent = import_node_path2.default.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+function fileFromImportMeta() {
+  try {
+    const url = __sootsim_import_meta_url;
+    if (!url || !url.startsWith("file://")) return null;
+    return decodeURIComponent(url.slice("file://".length));
+  } catch {
+    return null;
+  }
+}
+async function withStartLock(projectId, provider, fn) {
+  const lockDir = import_node_path2.default.join(getUserDataDir(), "locks");
+  import_node_fs2.default.mkdirSync(lockDir, { recursive: true });
+  try {
+    import_node_fs2.default.chmodSync(lockDir, 448);
+  } catch {
+  }
+  const lockPath = import_node_path2.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const deadline = Date.now() + 4e3;
+  let fd = null;
+  while (fd === null) {
+    try {
+      fd = import_node_fs2.default.openSync(
+        lockPath,
+        import_node_fs2.constants.O_WRONLY | import_node_fs2.constants.O_CREAT | import_node_fs2.constants.O_EXCL,
+        384
+      );
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      try {
+        const stale = Number(import_node_fs2.default.readFileSync(lockPath, "utf8").trim());
+        if (stale && !isProcessAlive(stale)) {
+          import_node_fs2.default.unlinkSync(lockPath);
+          continue;
+        }
+      } catch {
+      }
+      if (Date.now() > deadline) {
+        throw new Error(
+          `another start is in progress for project=${projectId} provider=${provider} (lock: ${lockPath})`
+        );
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  try {
+    import_node_fs2.default.writeFileSync(fd, String(process.pid));
+    return await fn();
+  } finally {
+    try {
+      import_node_fs2.default.closeSync(fd);
+    } catch {
+    }
+    try {
+      import_node_fs2.default.unlinkSync(lockPath);
+    } catch {
+    }
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mkfifoSync(p) {
+  const parent = import_node_path2.default.dirname(p);
+  import_node_fs2.default.mkdirSync(parent, { recursive: true });
+  try {
+    import_node_fs2.default.chmodSync(parent, 448);
+  } catch {
+  }
+  if (import_node_fs2.default.existsSync(p)) {
+    try {
+      const stat = import_node_fs2.default.statSync(p);
+      if (stat.isFIFO()) {
+        try {
+          import_node_fs2.default.chmodSync(p, 384);
+        } catch {
+        }
+        return;
+      }
+      import_node_fs2.default.unlinkSync(p);
+    } catch {
+      import_node_fs2.default.unlinkSync(p);
+    }
+  }
+  const result = (0, import_node_child_process.spawnSync)("mkfifo", ["-m", "600", p]);
+  if (result.status !== 0) {
+    throw new Error(
+      `mkfifo(${p}) failed: ${result.stderr?.toString().trim() || "unknown error"}`
+    );
+  }
+}
+var AgentSessionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+async function startSession(opts) {
+  const project = findProjectById(opts.projectId);
+  if (!project) {
+    throw new AgentSessionError("NO_PROJECT", `no project with id=${opts.projectId}`);
+  }
+  const provider = opts.provider || project.preferredProvider || "codex";
+  return withStartLock(project.id, provider, async () => {
+    const existingLive = listSessions(project.id).find(
+      (s) => s.provider === provider && s.status !== "ended" && pidIsAlive(s.wrapperPid, s.id)
+    );
+    if (existingLive) {
+      throw new AgentSessionError(
+        "ALREADY_RUNNING",
+        `session already running for project=${project.id} provider=${provider} (session ${existingLive.id}, pid ${existingLive.wrapperPid}). end it first with \`sootsim agent end <sessionId>\`.`
+      );
+    }
+    const claudeSessionUuid = provider === "claude" ? (0, import_node_crypto2.randomUUID)() : void 0;
+    const session = upsertSession({
+      projectId: project.id,
+      provider,
+      transport: "pty",
+      cwd: project.cwd,
+      status: "idle",
+      claudeSessionUuid
+    });
+    const promptIn = promptFifoPath(session.id);
+    const eventsOut = eventsFifoPath(session.id);
+    const transcript = transcriptPath(session.id);
+    mkfifoSync(promptIn);
+    mkfifoSync(eventsOut);
+    const transcriptDir = import_node_path2.default.dirname(transcript);
+    import_node_fs2.default.mkdirSync(transcriptDir, { recursive: true });
+    try {
+      import_node_fs2.default.chmodSync(transcriptDir, 448);
+    } catch {
+    }
+    const { cmd, prefixArgs } = resolveSootsimInvocation();
+    const wrapperArgs = [
+      ...prefixArgs,
+      "agent-wrapper",
+      "--session-id",
+      session.id,
+      "--project-id",
+      project.id,
+      "--provider",
+      provider,
+      "--cwd",
+      project.cwd,
+      "--prompt-in",
+      promptIn,
+      "--events-out",
+      eventsOut,
+      "--transcript",
+      transcript
+    ];
+    if (opts.codexBin) wrapperArgs.push("--codex-bin", opts.codexBin);
+    if (opts.claudeBin) wrapperArgs.push("--claude-bin", opts.claudeBin);
+    if (claudeSessionUuid) {
+      wrapperArgs.push("--claude-session-uuid", claudeSessionUuid);
+    }
+    const child = (0, import_node_child_process.spawn)(cmd, wrapperArgs, {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        SOOTSIM_USER_DATA_DIR: getUserDataDir()
+      }
+    });
+    child.unref();
+    const readyTimeout = opts.readyTimeoutMs ?? 6e3;
+    const boot = await waitForFirstEvent(
+      eventsOut,
+      (e) => e.type === "ready" || e.type === "error",
+      readyTimeout
+    );
+    if (!boot || boot.type === "error") {
+      if (child.pid) {
+        try {
+          process.kill(child.pid, "SIGTERM");
+        } catch {
+        }
+      }
+      try {
+        import_node_fs2.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+      } catch {
+      }
+      updateSessionStatus(session.id, { status: "ended" });
+      const reason = boot && boot.type === "error" ? boot.message : `no ready event within ${readyTimeout}ms`;
+      throw new AgentSessionError("WRAPPER_FAILED", reason);
+    }
+    updateSessionStatus(session.id, {
+      wrapperPid: child.pid,
+      status: "idle"
+    });
+    const updated = findSessionById(session.id);
+    return { session: updated, wrapperPid: child.pid };
+  });
+}
+async function sendPrompt(sessionId, prompt) {
+  const session = findSessionById(sessionId);
+  if (!session) {
+    throw new AgentSessionError("NO_SESSION", `no session with id=${sessionId}`);
+  }
+  if (!pidIsAlive(session.wrapperPid, sessionId)) {
+    updateSessionStatus(sessionId, { status: "ended" });
+    throw new AgentSessionError(
+      "NOT_ALIVE",
+      `session wrapper is not alive (pid=${session.wrapperPid}). start a new session.`
+    );
+  }
+  const fifo = promptFifoPath(sessionId);
+  if (!import_node_fs2.default.existsSync(fifo)) {
+    throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
+  }
+  const fd = import_node_fs2.default.openSync(fifo, import_node_fs2.constants.O_WRONLY);
+  try {
+    const wireText = encodeAgentPromptEnvelope(prompt);
+    if (!wireText) {
+      throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
+    }
+    import_node_fs2.default.writeSync(fd, wireText + "\n");
+  } finally {
+    import_node_fs2.default.closeSync(fd);
+  }
+  updateSessionStatus(sessionId, {
+    lastPrompt: prompt.displayText ?? prompt.text,
+    status: "working"
+  });
+}
+async function endSession(sessionId) {
+  const session = findSessionById(sessionId);
+  if (!session) {
+    throw new AgentSessionError("NO_SESSION", `no session with id=${sessionId}`);
+  }
+  if (pidIsAlive(session.wrapperPid, sessionId)) {
+    try {
+      process.kill(session.wrapperPid, "SIGTERM");
+    } catch {
+    }
+  }
+  const dir = sessionDir(sessionId);
+  const base = getUserDataDir();
+  if (dir.startsWith(base)) {
+    try {
+      import_node_fs2.default.rmSync(dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  updateSessionStatus(sessionId, { status: "ended", wrapperPid: void 0 });
+}
+function subscribeEvents(sessionId, onEvent) {
+  const fifo = eventsFifoPath(sessionId);
+  if (!import_node_fs2.default.existsSync(fifo)) {
+    throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
+  }
+  const fd = import_node_fs2.default.openSync(fifo, import_node_fs2.constants.O_RDWR);
+  const stream = import_node_fs2.default.createReadStream("", { fd, autoClose: true });
+  const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
+  rl.on("line", (line) => {
+    const event = parseAgentEventLine(line);
+    if (event) onEvent(event);
+  });
+  let closed = false;
+  return () => {
+    if (closed) return;
+    closed = true;
+    try {
+      rl.close();
+    } catch {
+    }
+    try {
+      stream.destroy();
+    } catch {
+    }
+  };
+}
+async function waitForFirstEvent(fifo, predicate, timeoutMs) {
+  const fd = import_node_fs2.default.openSync(fifo, import_node_fs2.constants.O_RDWR | import_node_fs2.constants.O_NONBLOCK);
+  const buf = Buffer.alloc(8192);
+  let leftover = "";
+  const deadline = Date.now() + timeoutMs;
+  try {
+    while (Date.now() < deadline) {
+      let n = 0;
+      try {
+        n = import_node_fs2.default.readSync(fd, buf, 0, buf.length, null);
+      } catch (err) {
+        if (err.code !== "EAGAIN") throw err;
+        n = 0;
+      }
+      if (n > 0) {
+        leftover += buf.subarray(0, n).toString("utf8");
+        let idx;
+        while ((idx = leftover.indexOf("\n")) >= 0) {
+          const line = leftover.slice(0, idx);
+          leftover = leftover.slice(idx + 1);
+          const event = parseAgentEventLine(line);
+          if (event && predicate(event)) return event;
+        }
+      } else {
+        await new Promise((r) => setTimeout(r, 30));
+      }
+    }
+    return null;
+  } finally {
+    import_node_fs2.default.closeSync(fd);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentSessionError,
+  endSession,
+  eventsFifoPath,
+  mkfifoSync,
+  pidIsAlive,
+  promptFifoPath,
+  resolveSootsimInvocation,
+  sendPrompt,
+  sessionDir,
+  startSession,
+  subscribeEvents,
+  transcriptPath
+});