@sma1lboy/kobe 0.8.19 → 0.8.21

package/dist/cli/pty-host-node.mjs

@@ -0,0 +1,906 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../kobe-daemon/src/daemon/pty-driver.ts
+var TERMINAL_NAME = "xterm-256color";
+function bunTerminalDriver(spawn) {
+  const spawnTerminal = spawn ?? ((argv, options) => Bun.spawn(argv, options));
+  return (request) => {
+    const proc = spawnTerminal([...request.argv], {
+      cwd: request.cwd,
+      env: request.env,
+      terminal: {
+        cols: request.cols,
+        rows: request.rows,
+        name: TERMINAL_NAME,
+        data: (_terminal, data) => request.onData(data)
+      }
+    });
+    return {
+      pid: proc.pid,
+      exited: proc.exited,
+      write: (data) => proc.terminal?.write(data),
+      resize: (cols, rows) => proc.terminal?.resize(cols, rows),
+      close: () => proc.terminal?.close(),
+      kill: (signal) => proc.kill(signal)
+    };
+  };
+}
+async function nodePtyDriver(spawn) {
+  const spawnPty = spawn ?? (await import("node-pty")).spawn;
+  return (request) => {
+    const [file, ...args] = request.argv;
+    const child = spawnPty(file ?? "", args, {
+      name: TERMINAL_NAME,
+      cols: request.cols,
+      rows: request.rows,
+      cwd: request.cwd,
+      env: Object.fromEntries(Object.entries(request.env).filter((entry) => entry[1] !== undefined))
+    });
+    let settle = () => {};
+    const exited = new Promise((resolve) => {
+      settle = resolve;
+    });
+    child.onData((data) => request.onData(data));
+    child.onExit(({ exitCode }) => settle(exitCode));
+    return {
+      pid: child.pid,
+      exited,
+      write: (data) => child.write(data),
+      resize: (cols, rows) => child.resize(cols, rows),
+      close: () => {},
+      kill: () => child.kill()
+    };
+  };
+}
+
+// ../kobe-daemon/src/daemon/pty-server.ts
+import { mkdir, unlink, writeFile } from "node:fs/promises";
+import { createServer } from "node:net";
+import { dirname } from "node:path";
+import { StringDecoder as StringDecoder2 } from "node:string_decoder";
+
+// ../kobe-daemon/src/daemon/client-writer.ts
+var DEFAULT_WRITE_HIGH_WATER_MARK = 8 * 1024 * 1024;
+
+class ClientWriter {
+  socket;
+  highWaterMark;
+  onOverflow;
+  queue = [];
+  queuedBytes = 0;
+  paused = false;
+  draining = false;
+  droppedFrames = 0;
+  overflowed = false;
+  constructor(socket, options = {}) {
+    this.socket = socket;
+    this.highWaterMark = options.highWaterMark ?? DEFAULT_WRITE_HIGH_WATER_MARK;
+    this.onOverflow = options.onOverflow;
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  get pendingBytes() {
+    return this.queuedBytes;
+  }
+  get pendingCount() {
+    return this.queue.length;
+  }
+  get dropped() {
+    return this.droppedFrames;
+  }
+  write(line, critical) {
+    if (this.overflowed)
+      return;
+    if (!this.paused) {
+      if (this.safeWrite(line))
+        return;
+      this.pause();
+      return;
+    }
+    this.enqueue({ line, bytes: Buffer.byteLength(line), critical });
+  }
+  enqueue(frame) {
+    this.queue.push(frame);
+    this.queuedBytes += frame.bytes;
+    if (this.queuedBytes <= this.highWaterMark)
+      return;
+    const survivors = [];
+    for (const queued of this.queue) {
+      if (this.queuedBytes > this.highWaterMark && !queued.critical) {
+        this.queuedBytes -= queued.bytes;
+        this.droppedFrames++;
+        continue;
+      }
+      survivors.push(queued);
+    }
+    this.queue = survivors;
+    if (this.queuedBytes <= this.highWaterMark || !this.onOverflow)
+      return;
+    this.overflowed = true;
+    this.queue = [];
+    this.queuedBytes = 0;
+    this.onOverflow();
+  }
+  pause() {
+    if (this.draining)
+      return;
+    this.paused = true;
+    this.draining = true;
+    this.socket.once("drain", () => {
+      this.draining = false;
+      this.paused = false;
+      this.flush();
+    });
+  }
+  flush() {
+    while (this.queue.length > 0) {
+      const frame = this.queue[0];
+      const ok = this.safeWrite(frame.line);
+      this.queue.shift();
+      this.queuedBytes -= frame.bytes;
+      if (!ok) {
+        this.pause();
+        return;
+      }
+    }
+  }
+  safeWrite(line) {
+    try {
+      return this.socket.write(line);
+    } catch {
+      return true;
+    }
+  }
+}
+
+// ../kobe-daemon/src/daemon/crash-log.ts
+function toError(err) {
+  if (err instanceof Error)
+    return err;
+  let text;
+  try {
+    text = typeof err === "string" ? err : JSON.stringify(err);
+  } catch {
+    text = String(err);
+  }
+  return new Error(text);
+}
+function formatDaemonError(subsystem, err, now = new Date) {
+  const e = toError(err);
+  return `[${now.toISOString()}] daemon error [${subsystem}]: ${e.stack ?? `${e.name}: ${e.message}`}
+`;
+}
+function logDaemonError(subsystem, err) {
+  process.stderr.write(formatDaemonError(subsystem, err));
+}
+
+// ../kobe-daemon/src/daemon/handler-validators.ts
+function objectPayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return {};
+  return payload;
+}
+function requireString(payload, key) {
+  const value = payload[key];
+  if (typeof value !== "string" || value.length === 0)
+    throw new Error(`${key} is required`);
+  return value;
+}
+
+// ../kobe-daemon/src/daemon/paths.ts
+import { createHash } from "node:crypto";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+var SOCKET_PATH_SAFETY_LIMIT = 100;
+function shortHomeTag(homeDir) {
+  return createHash("sha1").update(homeDir).digest("hex").slice(0, 8);
+}
+function fitSocketPath(naturalPath, homeDir, role, pidTag) {
+  if (Buffer.byteLength(naturalPath, "utf8") <= SOCKET_PATH_SAFETY_LIMIT)
+    return naturalPath;
+  const tag = shortHomeTag(homeDir);
+  const suffix = pidTag === undefined ? "" : `-${pidTag}`;
+  const fallback = join(tmpdir(), `kobe-${tag}-${role}${suffix}.sock`);
+  if (Buffer.byteLength(fallback, "utf8") <= SOCKET_PATH_SAFETY_LIMIT)
+    return fallback;
+  throw new Error(`kobe socket path exceeds ${SOCKET_PATH_SAFETY_LIMIT} bytes even after fallback: ${fallback}`);
+}
+function isWindowsPipePath(path) {
+  return path.startsWith("\\\\.\\pipe\\") || path.startsWith("//./pipe/");
+}
+function windowsPipePath(homeDir, role) {
+  return `\\\\.\\pipe\\kobe-${shortHomeTag(homeDir)}-${role}`;
+}
+function defaultPtyHostSocketPath(homeDir, platform = process.platform) {
+  const override = process.env.KOBE_PTY_SOCKET_PATH;
+  if (override && override.length > 0)
+    return override;
+  const explicit = homeDir ?? process.env.KOBE_HOME_DIR;
+  if (platform === "win32")
+    return windowsPipePath(explicit || homedir(), "pty");
+  if (explicit && explicit.length > 0) {
+    return fitSocketPath(join(explicit, ".kobe", "pty.sock"), explicit, "pty");
+  }
+  const runtimeDir = process.env.XDG_RUNTIME_DIR;
+  if (runtimeDir && runtimeDir.length > 0) {
+    return fitSocketPath(join(runtimeDir, "kobe-pty.sock"), runtimeDir, "pty");
+  }
+  const home = homedir();
+  return fitSocketPath(join(home, ".kobe", "pty.sock"), home, "pty");
+}
+function defaultPtyHostPidPath(homeDir = process.env.KOBE_HOME_DIR ?? homedir()) {
+  const override = process.env.KOBE_PTY_PID_PATH;
+  if (override && override.length > 0)
+    return override;
+  return join(homeDir, ".kobe", "pty.pid");
+}
+// ../kobe-daemon/src/daemon/channels.ts
+var CHANNEL_NAMES = [
+  "task.snapshot",
+  "issue.snapshot",
+  "active-task",
+  "update",
+  "engine-state",
+  "attention.inbox",
+  "ui-prefs",
+  "keybindings",
+  "task.jobs",
+  "worktree.changes",
+  "transcript.activity",
+  "session.deliver",
+  "notice.event",
+  "usage.snapshot"
+];
+var CHANNEL_NAME_SET = new Set(CHANNEL_NAMES);
+
+// ../kobe-daemon/src/daemon/protocol.ts
+var DAEMON_PROTOCOL_VERSION = 4;
+function frameToLine(frame) {
+  return `${JSON.stringify(frame)}
+`;
+}
+
+// ../kobe-daemon/src/daemon/pty-host.ts
+import { StringDecoder } from "node:string_decoder";
+
+// ../kobe-daemon/src/daemon/platform-shell.js
+import { existsSync } from "node:fs";
+function windowsBashCandidates(env) {
+  const roots = [env.ProgramFiles, env["ProgramFiles(x86)"], env.LOCALAPPDATA && `${env.LOCALAPPDATA}\\Programs`];
+  return roots.filter(Boolean).map((root) => `${root}\\Git\\bin\\bash.exe`);
+}
+var WINDOWS_BASH_FALLBACK = "C:\\Program Files\\Git\\bin\\bash.exe";
+function isWindowsSpawnable(shellPath) {
+  return /^[A-Za-z]:[\\/]/.test(shellPath) || shellPath.startsWith("\\\\");
+}
+var cache = new Map;
+function resolveLoginShell(options = {}) {
+  const fallback = options.fallback ?? "/bin/bash";
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const exists = options.exists ?? existsSync;
+  const cacheable = platform === process.platform && env === process.env && options.exists === undefined;
+  if (cacheable) {
+    const hit = cache.get(fallback);
+    if (hit)
+      return hit;
+  }
+  const resolved = resolveUncached(fallback, platform, env, exists);
+  if (cacheable)
+    cache.set(fallback, resolved);
+  return resolved;
+}
+function resolveUncached(fallback, platform, env, exists) {
+  const explicit = env.SHELL?.trim();
+  if (platform !== "win32")
+    return explicit || fallback;
+  if (explicit && isWindowsSpawnable(explicit) && exists(explicit))
+    return explicit;
+  for (const candidate of windowsBashCandidates(env)) {
+    if (exists(candidate))
+      return candidate;
+  }
+  return WINDOWS_BASH_FALLBACK;
+}
+
+// ../kobe-daemon/src/daemon/pty-env.js
+var IDENTITY_VARS = new Set([
+  "TERM_PROGRAM",
+  "TERM_PROGRAM_VERSION",
+  "TERM_SESSION_ID",
+  "TERM_FEATURES",
+  "LC_TERMINAL",
+  "LC_TERMINAL_VERSION",
+  "__CFBundleIdentifier",
+  "VTE_VERSION",
+  "WT_SESSION",
+  "WT_PROFILE_ID",
+  "TMUX",
+  "TMUX_PANE",
+  "ZELLIJ",
+  "STY",
+  "WINDOW"
+]);
+var IDENTITY_PREFIXES = ["ITERM_", "KITTY_", "GHOSTTY_", "WEZTERM_", "ALACRITTY_", "KONSOLE_", "ZELLIJ_"];
+function embeddedTerminalEnv(base, overrides = {}) {
+  const env = {};
+  for (const [key, value] of Object.entries(base)) {
+    if (IDENTITY_VARS.has(key))
+      continue;
+    if (IDENTITY_PREFIXES.some((prefix) => key.startsWith(prefix)))
+      continue;
+    env[key] = value;
+  }
+  return { ...env, ...overrides };
+}
+
+// ../kobe-daemon/src/daemon/pty-observability.ts
+var OSC_TITLE_RE = /\x1b\][02];([^\x07\x1b]*)(?:\x07|\x1b\\)/g;
+var TITLE_CARRY_CAP = 1024;
+function titleCarryFrom(rest) {
+  const osc = rest.lastIndexOf("\x1B]");
+  if (osc !== -1)
+    return rest.slice(osc, osc + TITLE_CARRY_CAP);
+  return rest.endsWith("\x1B") ? "\x1B" : "";
+}
+function foldOscTitle(prevCarry, chunkText) {
+  const text = prevCarry + chunkText;
+  let title = null;
+  let end = 0;
+  OSC_TITLE_RE.lastIndex = 0;
+  for (let match = OSC_TITLE_RE.exec(text);match; match = OSC_TITLE_RE.exec(text)) {
+    title = match[1] ?? "";
+    end = match.index + match[0].length;
+  }
+  return { title, carry: titleCarryFrom(text.slice(end)) };
+}
+function scanOscTitle(session, buf) {
+  const { title, carry } = foldOscTitle(session.titleCarry, session.titleDecoder.write(buf));
+  if (title !== null)
+    session.title = title;
+  session.titleCarry = carry;
+}
+function peekRing(session, sinceOffset) {
+  if (!session)
+    return { exists: false, alive: false, pid: null, offset: 0, data: "", sinceValid: false };
+  const windowStart = session.totalBytes - session.bytes;
+  let buf = Buffer.concat(session.chunks);
+  let sinceValid = false;
+  if (sinceOffset !== undefined && sinceOffset >= windowStart && sinceOffset <= session.totalBytes) {
+    buf = buf.subarray(sinceOffset - windowStart);
+    sinceValid = true;
+  }
+  return {
+    exists: true,
+    alive: session.alive,
+    pid: session.proc?.pid ?? null,
+    offset: session.totalBytes,
+    data: buf.toString("base64"),
+    sinceValid
+  };
+}
+
+// ../kobe-daemon/src/daemon/pty-termination.ts
+async function settledWithin(exited, ms) {
+  let timer;
+  const settled = await Promise.race([
+    exited.then(() => true, () => true),
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(false), ms);
+    })
+  ]);
+  if (timer)
+    clearTimeout(timer);
+  return settled;
+}
+function signalProcessGroup(pid, signal, fallback, platform = process.platform) {
+  if (platform !== "win32" && pid > 1) {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {}
+  }
+  try {
+    fallback();
+  } catch {}
+}
+
+// ../kobe-daemon/src/daemon/pty-host.ts
+var DEFAULT_SCROLLBACK_CAP = 512 * 1024;
+var TERMINATION_GRACE_MS = 500;
+
+class PtyHost {
+  sessions = new Map;
+  opts;
+  parkRestoreDeltas = 0;
+  parkRestoreFallbacks = 0;
+  spare = null;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  open(key, spec, token, sink, sinceOffset, sincePid) {
+    let session = this.sessions.get(key);
+    let created = false;
+    if (!session) {
+      created = true;
+      session = this.adoptSpare(key, spec) ?? this.spawn(key, spec);
+      this.sessions.set(key, session);
+    } else if (session.alive && (session.cols !== spec.cols || session.rows !== spec.rows)) {
+      this.resize(key, spec.cols, spec.rows);
+    }
+    session.sinks.set(token, sink);
+    session.parked = false;
+    session.parkedScreenBytes = 0;
+    const windowStart = session.totalBytes - session.bytes;
+    let replay = Buffer.concat(session.chunks);
+    let sinceValid = false;
+    if (!created && sinceOffset !== undefined && sinceOffset >= windowStart && sinceOffset <= session.totalBytes && sincePid !== undefined && sincePid === session.proc?.pid) {
+      replay = replay.subarray(sinceOffset - windowStart);
+      sinceValid = true;
+    }
+    if (sinceOffset !== undefined && sincePid !== undefined) {
+      if (sinceValid)
+        this.parkRestoreDeltas++;
+      else
+        this.parkRestoreFallbacks++;
+    }
+    return {
+      replay: replay.toString("base64"),
+      alive: session.alive,
+      pid: session.proc?.pid ?? null,
+      created,
+      offset: session.totalBytes,
+      sinceValid
+    };
+  }
+  warm(cwd, shell, cols = 80, rows = 24) {
+    const argv0 = shell ?? resolveLoginShell();
+    if (this.spare?.alive && this.spare.cwd === cwd && this.spare.command[0] === argv0)
+      return;
+    const old = this.spare;
+    this.spare = null;
+    if (old)
+      this.endChild(old);
+    const session = this.spawn("::spare", { cwd, command: [argv0], cols, rows }, true);
+    this.spare = session.alive ? session : null;
+  }
+  adoptSpare(key, spec) {
+    const spare = this.spare;
+    if (!spare?.alive || spare.cwd !== spec.cwd)
+      return null;
+    const want = spec.command && spec.command.length > 0 ? spec.command : [spec.shell ?? resolveLoginShell()];
+    if (want.length !== 1 || want[0] !== spare.command[0])
+      return null;
+    this.spare = null;
+    spare.key = key;
+    if (spare.cols !== spec.cols || spare.rows !== spec.rows) {
+      spare.cols = spec.cols;
+      spare.rows = spec.rows;
+      try {
+        spare.proc?.resize(spec.cols, spec.rows);
+      } catch {
+        this.markExited(spare);
+        return null;
+      }
+    }
+    this.opts.log?.("pty", `adopted warm shell for ${key} (pid ${spare.proc?.pid})`);
+    this.opts.onSessionStart?.();
+    this.warm(spec.cwd, spare.command[0], spec.cols, spec.rows);
+    return spare;
+  }
+  write(key, data) {
+    const session = this.sessions.get(key);
+    if (!session?.alive || data.length === 0)
+      return;
+    try {
+      session.proc?.write(data);
+    } catch {}
+  }
+  resize(key, cols, rows) {
+    const session = this.sessions.get(key);
+    if (!session?.alive)
+      return;
+    session.cols = cols;
+    session.rows = rows;
+    try {
+      session.proc?.resize(cols, rows);
+    } catch {}
+  }
+  kill(key) {
+    const session = this.sessions.get(key);
+    if (!session)
+      return Promise.resolve();
+    this.sessions.delete(key);
+    return this.endChild(session);
+  }
+  detach(key, token, parked = false, parkedScreenBytes = 0) {
+    const session = this.sessions.get(key);
+    if (!session)
+      return;
+    session.sinks.delete(token);
+    if (session.sinks.size === 0) {
+      session.parked = parked;
+      session.parkedScreenBytes = parked ? Math.max(0, parkedScreenBytes) : 0;
+    }
+  }
+  detachClient(token) {
+    for (const session of this.sessions.values()) {
+      session.sinks.delete(token);
+      if (session.sinks.size === 0) {
+        session.parked = false;
+        session.parkedScreenBytes = 0;
+      }
+    }
+  }
+  list() {
+    return Array.from(this.sessions.values(), (s) => ({
+      key: s.key,
+      alive: s.alive,
+      pid: s.proc?.pid ?? null,
+      command: s.command,
+      title: s.title,
+      parked: s.parked,
+      parkedScreenBytes: s.parkedScreenBytes
+    }));
+  }
+  peek(key, sinceOffset) {
+    return peekRing(this.sessions.get(key), sinceOffset);
+  }
+  stats() {
+    let ringBytes = 0;
+    let parkedSessions = 0;
+    let parkedScreenBytes = 0;
+    for (const session of this.sessions.values()) {
+      ringBytes += session.bytes;
+      if (session.parked) {
+        parkedSessions++;
+        parkedScreenBytes += session.parkedScreenBytes;
+      }
+    }
+    return {
+      ringBytes,
+      ringCapacityBytes: this.sessions.size * (this.opts.scrollbackCap ?? DEFAULT_SCROLLBACK_CAP),
+      parkedSessions,
+      parkedScreenBytes,
+      parkRestoreDeltas: this.parkRestoreDeltas,
+      parkRestoreFallbacks: this.parkRestoreFallbacks
+    };
+  }
+  sweepTasks(liveTaskIds) {
+    for (const key of Array.from(this.sessions.keys())) {
+      const taskId = key.split("::")[0] ?? key;
+      if (!liveTaskIds.has(taskId))
+        this.kill(key);
+    }
+  }
+  async killAll() {
+    const sessions = Array.from(this.sessions.keys(), (key) => this.kill(key));
+    const spare = this.spare;
+    this.spare = null;
+    if (spare)
+      sessions.push(this.endChild(spare));
+    await Promise.all(sessions);
+  }
+  liveCount() {
+    let n = 0;
+    for (const session of this.sessions.values())
+      if (session.alive)
+        n++;
+    return n;
+  }
+  spawn(key, spec, spare = false) {
+    const argv = spec.command && spec.command.length > 0 ? [...spec.command] : [spec.shell ?? resolveLoginShell()];
+    const session = {
+      key,
+      cwd: spec.cwd,
+      proc: null,
+      alive: true,
+      chunks: [],
+      bytes: 0,
+      totalBytes: 0,
+      cols: spec.cols,
+      rows: spec.rows,
+      command: argv,
+      title: "",
+      titleCarry: "",
+      titleDecoder: new StringDecoder("utf8"),
+      sinks: new Map,
+      parked: false,
+      parkedScreenBytes: 0
+    };
+    try {
+      session.proc = (this.opts.driver ?? bunTerminalDriver())({
+        argv,
+        cwd: spec.cwd,
+        env: embeddedTerminalEnv(process.env, {
+          TERM: "xterm-256color",
+          COLUMNS: String(spec.cols),
+          LINES: String(spec.rows),
+          BASH_SILENCE_DEPRECATION_WARNING: "1",
+          KOBE_TERMINAL_PTY: "1"
+        }),
+        cols: spec.cols,
+        rows: spec.rows,
+        onData: (data) => this.onData(session, data)
+      });
+      session.proc.exited.then(() => this.markExited(session), () => this.markExited(session));
+      this.opts.log?.("pty", `spawned ${argv[0]} for ${key} (pid ${session.proc.pid})`);
+      if (!spare)
+        this.opts.onSessionStart?.();
+    } catch (err) {
+      session.alive = false;
+      this.opts.log?.("pty", `spawn failed for ${key}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return session;
+  }
+  onData(session, data) {
+    const buf = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+    scanOscTitle(session, buf);
+    session.chunks.push(buf);
+    session.bytes += buf.byteLength;
+    session.totalBytes += buf.byteLength;
+    while (session.bytes > (this.opts.scrollbackCap ?? DEFAULT_SCROLLBACK_CAP) && session.chunks.length > 1) {
+      const dropped = session.chunks.shift();
+      if (dropped)
+        session.bytes -= dropped.byteLength;
+    }
+    if (session.sinks.size === 0)
+      return;
+    const frame = {
+      type: "event",
+      name: "pty.data",
+      payload: { key: session.key, data: buf.toString("base64") }
+    };
+    for (const sink of session.sinks.values())
+      sink(frame);
+  }
+  markExited(session) {
+    if (!session.alive)
+      return;
+    session.alive = false;
+    try {
+      session.proc?.close();
+    } catch {}
+    const frame = {
+      type: "event",
+      name: "pty.exit",
+      payload: { key: session.key, pid: session.proc?.pid ?? null }
+    };
+    for (const sink of session.sinks.values())
+      sink(frame);
+    this.opts.log?.("pty", `session ${session.key} exited`);
+    this.opts.onSessionEnd?.();
+  }
+  async endChild(session) {
+    if (!session.alive)
+      return;
+    const proc = session.proc;
+    if (!proc) {
+      this.markExited(session);
+      return;
+    }
+    signalProcessGroup(proc.pid, "SIGTERM", () => proc.kill("SIGTERM"));
+    if (!await settledWithin(proc.exited, TERMINATION_GRACE_MS)) {
+      signalProcessGroup(proc.pid, "SIGKILL", () => proc.kill("SIGKILL"));
+      await settledWithin(proc.exited, TERMINATION_GRACE_MS);
+    }
+    this.markExited(session);
+  }
+}
+
+// ../kobe-daemon/src/daemon/pty-server.ts
+var DEFAULT_IDLE_EXIT_MS = 60000;
+function resolveIdleExitMs() {
+  const raw = process.env.KOBE_PTY_IDLE_EXIT_MS;
+  if (raw === undefined)
+    return DEFAULT_IDLE_EXIT_MS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_IDLE_EXIT_MS;
+}
+async function startPtyHostServer(options = {}) {
+  const socketPath = options.socketPath ?? defaultPtyHostSocketPath();
+  const pidPath = options.pidPath ?? defaultPtyHostPidPath();
+  const idleExitMs = options.idleExitMs || resolveIdleExitMs();
+  const log = options.log ?? (() => {});
+  const clients = new Set;
+  let stopping = false;
+  let idleTimer = null;
+  const cancelIdle = () => {
+    if (idleTimer)
+      clearTimeout(idleTimer);
+    idleTimer = null;
+  };
+  const armIdle = () => {
+    if (stopping)
+      return;
+    cancelIdle();
+    idleTimer = setTimeout(() => {
+      if (stopping || ptys.liveCount() > 0)
+        return;
+      log("idle", `no live sessions for ${idleExitMs}ms — exiting`);
+      stop();
+    }, idleExitMs);
+  };
+  const ptys = new PtyHost({
+    onSessionStart: cancelIdle,
+    onSessionEnd: () => {
+      if (ptys.liveCount() === 0)
+        armIdle();
+    },
+    driver: options.driver,
+    log
+  });
+  const pipeSocket = isWindowsPipePath(socketPath);
+  if (!pipeSocket)
+    await mkdir(dirname(socketPath), { recursive: true });
+  await mkdir(dirname(pidPath), { recursive: true });
+  const server = createServer((socket) => {
+    const client = {
+      socket,
+      writer: new ClientWriter(socket, {
+        onOverflow: () => {
+          log("backpressure", "disconnecting PTY client whose critical queue exceeded 8MiB");
+          socket.destroy();
+        }
+      }),
+      buffer: ""
+    };
+    clients.add(client);
+    const decoder = new StringDecoder2("utf8");
+    socket.on("data", (chunk) => {
+      client.buffer += decoder.write(chunk);
+      drain(client);
+    });
+    socket.on("error", () => {});
+    socket.on("close", () => {
+      clients.delete(client);
+      ptys.detachClient(client);
+    });
+  });
+  const api = {
+    socketPath,
+    pidPath,
+    async close() {
+      if (stopping)
+        return;
+      stopping = true;
+      cancelIdle();
+      await ptys.killAll();
+      for (const client of Array.from(clients))
+        client.socket.destroy();
+      await new Promise((resolve) => server.close(() => resolve()));
+      if (!pipeSocket)
+        await unlink(socketPath).catch(() => {});
+      await unlink(pidPath).catch(() => {});
+    }
+  };
+  async function stop() {
+    await api.close().catch((err) => logDaemonError("pty-host-shutdown", err));
+    options.onStop?.();
+  }
+  function dispatch(req, client) {
+    switch (req.name) {
+      case "hello":
+        return { protocolVersion: DAEMON_PROTOCOL_VERSION, ptyHost: true, pid: process.pid };
+      case "pty.open": {
+        const payload = objectPayload(req.payload);
+        return ptys.open(requireString(payload, "key"), {
+          cwd: requireString(payload, "cwd"),
+          command: Array.isArray(payload.command) ? payload.command.filter((c) => typeof c === "string") : undefined,
+          shell: typeof payload.shell === "string" ? payload.shell : undefined,
+          cols: typeof payload.cols === "number" ? payload.cols : 80,
+          rows: typeof payload.rows === "number" ? payload.rows : 24
+        }, client, (frame) => writeFrame(client, frame), typeof payload.sinceOffset === "number" ? payload.sinceOffset : undefined, typeof payload.sincePid === "number" ? payload.sincePid : undefined);
+      }
+      case "pty.write": {
+        const payload = objectPayload(req.payload);
+        ptys.write(requireString(payload, "key"), typeof payload.data === "string" ? payload.data : "");
+        return {};
+      }
+      case "pty.resize": {
+        const payload = objectPayload(req.payload);
+        ptys.resize(requireString(payload, "key"), typeof payload.cols === "number" ? payload.cols : 80, typeof payload.rows === "number" ? payload.rows : 24);
+        return {};
+      }
+      case "pty.kill":
+        ptys.kill(requireString(objectPayload(req.payload), "key"));
+        return {};
+      case "pty.detach":
+        {
+          const payload = objectPayload(req.payload);
+          ptys.detach(requireString(payload, "key"), client, payload.parked === true, typeof payload.parkedScreenBytes === "number" ? payload.parkedScreenBytes : 0);
+        }
+        return {};
+      case "pty.list":
+        return { pid: process.pid, rssBytes: process.memoryUsage().rss, sessions: ptys.list(), stats: ptys.stats() };
+      case "pty.peek": {
+        const payload = objectPayload(req.payload);
+        return ptys.peek(requireString(payload, "key"), typeof payload.sinceOffset === "number" ? payload.sinceOffset : undefined);
+      }
+      case "pty.warm": {
+        const payload = objectPayload(req.payload);
+        ptys.warm(requireString(payload, "cwd"), typeof payload.shell === "string" ? payload.shell : undefined, typeof payload.cols === "number" ? payload.cols : undefined, typeof payload.rows === "number" ? payload.rows : undefined);
+        return {};
+      }
+      case "pty.sweep": {
+        const payload = objectPayload(req.payload);
+        const ids = Array.isArray(payload.liveTaskIds) ? payload.liveTaskIds.filter((id) => typeof id === "string") : [];
+        ptys.sweepTasks(new Set(ids));
+        return {};
+      }
+      case "daemon.stop":
+        setTimeout(() => void stop(), 0).unref();
+        return {};
+      default:
+        throw new Error(`unknown pty-host request: ${req.name}`);
+    }
+  }
+  function drain(client) {
+    let nl = client.buffer.indexOf(`
+`);
+    while (nl !== -1) {
+      const line = client.buffer.slice(0, nl);
+      client.buffer = client.buffer.slice(nl + 1);
+      if (line.trim().length > 0) {
+        let frame = null;
+        try {
+          frame = JSON.parse(line);
+        } catch {
+          writeFrame(client, { type: "response", id: "parse-error", error: { message: "malformed frame" } });
+        }
+        if (frame) {
+          if (frame.type !== "request") {
+            writeFrame(client, { type: "response", id: "parse-error", error: { message: "requests only" } });
+          } else {
+            try {
+              writeFrame(client, { type: "response", id: frame.id, name: frame.name, payload: dispatch(frame, client) });
+            } catch (err) {
+              writeFrame(client, {
+                type: "response",
+                id: frame.id,
+                name: frame.name,
+                error: { message: err instanceof Error ? err.message : String(err) }
+              });
+            }
+          }
+        }
+      }
+      nl = client.buffer.indexOf(`
+`);
+    }
+  }
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, () => resolve());
+  });
+  await writeFile(pidPath, `${process.pid}
+`, "utf8");
+  armIdle();
+  log("boot", `pty host listening on ${socketPath}`);
+  return api;
+}
+function writeFrame(client, frame) {
+  client.writer.write(frameToLine(frame), true);
+}
+
+// ../kobe-daemon/src/daemon/pty-host-node-entry.ts
+async function main() {
+  process.on("uncaughtException", (err) => console.error(`[pty-host crash] ${err?.stack ?? String(err)}`));
+  process.on("unhandledRejection", (err) => console.error(`[pty-host reject] ${String(err)}`));
+  const driver = await nodePtyDriver();
+  const server = await startPtyHostServer({
+    driver,
+    log: (event, message) => console.log(`[pty-host ${event}] ${message}`),
+    onStop: () => process.exit(0)
+  });
+  console.log(`kobe pty-host (node): listening on ${server.socketPath}`);
+  const shutdown = async () => {
+    await server.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", () => void shutdown());
+  process.once("SIGTERM", () => void shutdown());
+}
+await main();