@sma1lboy/kobe 0.8.99 → 0.8.102

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

@@ -58,7 +58,7 @@ async function nodePtyDriver(spawn) {
 import { mkdir, unlink, writeFile } from "node:fs/promises";
 import { createServer } from "node:net";
 import { dirname as dirname2 } from "node:path";
-import { StringDecoder as StringDecoder2 } from "node:string_decoder";
+import { StringDecoder as StringDecoder3 } from "node:string_decoder";
 
 // ../kobe-daemon/src/daemon/client-writer.ts
 var DEFAULT_WRITE_HIGH_WATER_MARK = 8 * 1024 * 1024;
@@ -249,6 +249,9 @@ function defaultPtyHostPidPath(homeDir = readRoveEnv("HOME_DIR") ?? homedir()) {
 function defaultPtyExitsPath(homeDir = readRoveEnv("HOME_DIR") ?? homedir()) {
   return join(homeDir, COMPAT_STATE_DIR_BASENAME, "pty-exits.json");
 }
+function defaultPtyFreezeDir(homeDir = readRoveEnv("HOME_DIR") ?? homedir()) {
+  return join(homeDir, COMPAT_STATE_DIR_BASENAME, "pty-sessions");
+}
 // ../kobe-plugin-sdk/dist/contract.js
 var DAEMON_CHANNELS = [
   "task.snapshot",
@@ -327,8 +330,128 @@ function recordPtyExit(info, path = defaultPtyExitsPath()) {
   writeFileSync(path, JSON.stringify(Object.fromEntries(newest.map((r) => [r.key, r])), null, 2), "utf8");
 }
 
-// ../kobe-daemon/src/daemon/pty-host.ts
+// ../kobe-daemon/src/daemon/pty-freeze-store.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, renameSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
 import { StringDecoder } from "node:string_decoder";
+var FREEZE_VERSION = 1;
+function freezeSession(session, now = new Date) {
+  return {
+    v: FREEZE_VERSION,
+    key: session.key,
+    cwd: session.cwd,
+    command: [...session.command],
+    cols: session.cols,
+    rows: session.rows,
+    title: session.title,
+    totalBytes: session.totalBytes,
+    exit: session.exit,
+    ringB64: Buffer.concat(session.chunks).toString("base64"),
+    updatedAt: now.toISOString()
+  };
+}
+function thawRing(record, cap) {
+  let ring;
+  try {
+    ring = Buffer.from(record.ringB64, "base64");
+  } catch {
+    return null;
+  }
+  const trimmed = ring.byteLength > cap ? ring.subarray(ring.byteLength - cap) : ring;
+  return { chunks: trimmed.byteLength > 0 ? [trimmed] : [], bytes: trimmed.byteLength };
+}
+function thawSession(record, cap) {
+  const ring = thawRing(record, cap);
+  if (!ring)
+    return null;
+  return {
+    key: record.key,
+    cwd: record.cwd,
+    proc: null,
+    alive: false,
+    chunks: [...ring.chunks],
+    bytes: ring.bytes,
+    totalBytes: Math.max(record.totalBytes, ring.bytes),
+    cols: record.cols,
+    rows: record.rows,
+    command: record.command,
+    title: record.title,
+    titleCarry: "",
+    titleDecoder: new StringDecoder("utf8"),
+    sinks: new Map,
+    parked: false,
+    parkedScreenBytes: 0,
+    exit: record.exit,
+    restored: true,
+    lastFreezeAtMs: 0
+  };
+}
+function recordFile(dir, key) {
+  return join2(dir, `${encodeURIComponent(key)}.json`);
+}
+function parseRecord(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.v !== FREEZE_VERSION)
+      return null;
+    if (typeof parsed.key !== "string" || parsed.key.length === 0)
+      return null;
+    if (parsed.key.startsWith("::"))
+      return null;
+    if (typeof parsed.cwd !== "string" || !Array.isArray(parsed.command))
+      return null;
+    if (typeof parsed.ringB64 !== "string" || typeof parsed.totalBytes !== "number")
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function loadFrozenSessions(dir = defaultPtyFreezeDir()) {
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (!name.endsWith(".json"))
+      continue;
+    try {
+      const record = parseRecord(readFileSync2(join2(dir, name), "utf8"));
+      if (record)
+        out.push(record);
+    } catch {}
+  }
+  return out;
+}
+function fileFreezeSink(dir = defaultPtyFreezeDir()) {
+  return {
+    save(record) {
+      try {
+        mkdirSync2(dir, { recursive: true });
+        const target = recordFile(dir, record.key);
+        const staging = `${target}.${process.pid}.tmp`;
+        writeFileSync2(staging, JSON.stringify(record), "utf8");
+        renameSync(staging, target);
+      } catch {}
+    },
+    drop(key) {
+      try {
+        rmSync(recordFile(dir, key), { force: true });
+      } catch {}
+    }
+  };
+}
+function clearFrozenSessions(dir = defaultPtyFreezeDir()) {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {}
+}
+
+// ../kobe-daemon/src/daemon/pty-host.ts
+import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 
 // ../kobe-daemon/src/daemon/platform-shell.js
 import { existsSync } from "node:fs";
@@ -402,6 +525,20 @@ function embeddedTerminalEnv(base, overrides = {}) {
 }
 
 // ../kobe-daemon/src/daemon/pty-observability.ts
+function sessionInfo(s) {
+  return {
+    key: s.key,
+    alive: s.alive,
+    pid: s.proc?.pid ?? null,
+    command: s.command,
+    title: s.title,
+    totalBytes: s.totalBytes,
+    parked: s.parked,
+    parkedScreenBytes: s.parkedScreenBytes,
+    exit: s.exit,
+    restored: s.restored || undefined
+  };
+}
 function describeExit(exit) {
   if (exit?.signal)
     return ` (signal ${exit.signal})`;
@@ -420,6 +557,28 @@ function ringTail(chunks, bytes, maxBytes) {
   }
   return Buffer.concat(parts).toString("utf8");
 }
+function hostStats(sessions, perSessionCap, parkRestoreDeltas, parkRestoreFallbacks) {
+  let ringBytes = 0;
+  let count = 0;
+  let parkedSessions = 0;
+  let parkedScreenBytes = 0;
+  for (const session of sessions) {
+    count++;
+    ringBytes += session.bytes;
+    if (session.parked) {
+      parkedSessions++;
+      parkedScreenBytes += session.parkedScreenBytes;
+    }
+  }
+  return {
+    ringBytes,
+    ringCapacityBytes: count * perSessionCap,
+    parkedSessions,
+    parkedScreenBytes,
+    parkRestoreDeltas,
+    parkRestoreFallbacks
+  };
+}
 var OSC_TITLE_RE = /\x1b\][02];([^\x07\x1b]*)(?:\x07|\x1b\\)/g;
 var TITLE_CARRY_CAP = 1024;
 function titleCarryFrom(rest) {
@@ -491,28 +650,99 @@ function signalProcessGroup(pid, signal, fallback, platform = process.platform)
     fallback();
   } catch {}
 }
+var TERMINATION_GRACE_MS = 500;
+async function terminatePtyChild(proc, onSettled) {
+  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);
+  }
+  onSettled();
+}
+
+// ../kobe-daemon/src/daemon/pty-warm.ts
+class WarmSpare {
+  deps;
+  spare = null;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  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.deps.endChild(old);
+    const session = this.deps.spawn("::spare", { cwd, command: [argv0], cols, rows }, true);
+    this.spare = session.alive ? session : null;
+  }
+  adopt(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;
+    const cols = spec.cols ?? spare.cols;
+    const rows = spec.rows ?? spare.rows;
+    if (spare.cols !== cols || spare.rows !== rows) {
+      spare.cols = cols;
+      spare.rows = rows;
+      try {
+        spare.proc?.resize(cols, rows);
+      } catch {
+        this.deps.markExited(spare);
+        return null;
+      }
+    }
+    this.deps.log?.("pty", `adopted warm shell for ${key} (pid ${spare.proc?.pid})`);
+    this.deps.onSessionStart?.();
+    this.warm(spec.cwd, spare.command[0], cols, rows);
+    return spare;
+  }
+  async end() {
+    const spare = this.spare;
+    this.spare = null;
+    if (spare)
+      await this.deps.endChild(spare);
+  }
+}
 
 // ../kobe-daemon/src/daemon/pty-host.ts
 var DEFAULT_SCROLLBACK_CAP = 512 * 1024;
-var TERMINATION_GRACE_MS = 500;
 var EXIT_TAIL_BYTES = 16 * 1024;
+var FREEZE_INTERVAL_MS = 5000;
 
 class PtyHost {
   sessions = new Map;
   opts;
   parkRestoreDeltas = 0;
   parkRestoreFallbacks = 0;
-  spare = null;
+  warmSpare = new WarmSpare({
+    spawn: (key, spec, spare) => this.spawn(key, spec, spare),
+    endChild: (session) => this.endChild(session),
+    markExited: (session) => this.markExited(session),
+    log: (event, message) => this.opts.log?.(event, message),
+    onSessionStart: () => this.opts.onSessionStart?.()
+  });
   constructor(opts = {}) {
     this.opts = opts;
   }
   open(key, spec, token, sink, sinceOffset, sincePid) {
     let session = this.sessions.get(key);
     let created = false;
+    let respawned = false;
     if (!session) {
       created = true;
-      session = this.adoptSpare(key, spec) ?? this.spawn(key, spec);
+      session = this.warmSpare.adopt(key, spec) ?? this.spawn(key, spec);
       this.sessions.set(key, session);
+    } else if (!session.alive && session.restored) {
+      this.respawn(session, spec);
+      respawned = session.alive;
     } else if (session.alive && spec.cols !== undefined && spec.rows !== undefined && (session.cols !== spec.cols || session.rows !== spec.rows)) {
       this.resize(key, spec.cols, spec.rows);
     }
@@ -537,46 +767,13 @@ class PtyHost {
       alive: session.alive,
       pid: session.proc?.pid ?? null,
       created,
+      respawned,
       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;
-    const cols = spec.cols ?? spare.cols;
-    const rows = spec.rows ?? spare.rows;
-    if (spare.cols !== cols || spare.rows !== rows) {
-      spare.cols = cols;
-      spare.rows = rows;
-      try {
-        spare.proc?.resize(cols, 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], cols, rows);
-    return spare;
+    this.warmSpare.warm(cwd, shell, cols, rows);
   }
   write(key, data) {
     const session = this.sessions.get(key);
@@ -601,6 +798,7 @@ class PtyHost {
     if (!session)
       return Promise.resolve();
     this.sessions.delete(key);
+    this.opts.freeze?.drop(key);
     return this.endChild(session);
   }
   detach(key, token, parked = false, parkedScreenBytes = 0) {
@@ -623,40 +821,13 @@ class PtyHost {
     }
   }
   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,
-      totalBytes: s.totalBytes,
-      parked: s.parked,
-      parkedScreenBytes: s.parkedScreenBytes,
-      exit: s.exit
-    }));
+    return Array.from(this.sessions.values(), (s) => sessionInfo(s));
   }
   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
-    };
+    return hostStats(this.sessions.values(), this.opts.scrollbackCap ?? DEFAULT_SCROLLBACK_CAP, this.parkRestoreDeltas, this.parkRestoreFallbacks);
   }
   sweepTasks(liveTaskIds) {
     for (const key of Array.from(this.sessions.keys())) {
@@ -667,12 +838,57 @@ class PtyHost {
   }
   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));
+    sessions.push(this.warmSpare.end());
     await Promise.all(sessions);
   }
+  async shutdown() {
+    this.flushFrozen();
+    const endings = Array.from(this.sessions.values(), (session) => this.endChild(session));
+    endings.push(this.warmSpare.end());
+    await Promise.all(endings);
+  }
+  flushFrozen() {
+    for (const session of this.sessions.values())
+      this.maybeFreeze(session, true);
+  }
+  restoreFrozen(records) {
+    let restoredCount = 0;
+    for (const record of records) {
+      if (this.sessions.has(record.key))
+        continue;
+      const session = thawSession(record, this.opts.scrollbackCap ?? DEFAULT_SCROLLBACK_CAP);
+      if (!session)
+        continue;
+      this.sessions.set(record.key, session);
+      restoredCount++;
+    }
+    if (restoredCount > 0)
+      this.opts.log?.("pty", `restored ${restoredCount} frozen session(s) from disk`);
+    return restoredCount;
+  }
+  respawn(session, spec) {
+    session.restored = false;
+    session.exit = null;
+    if (spec.command && spec.command.length > 0)
+      session.command = [...spec.command];
+    session.cols = spec.cols ?? session.cols;
+    session.rows = spec.rows ?? session.rows;
+    this.startChild(session);
+    if (!session.alive)
+      return;
+    this.opts.log?.("pty", `respawned restored session ${session.key} (pid ${session.proc?.pid})`);
+    this.opts.onSessionStart?.();
+  }
+  maybeFreeze(session, force = false) {
+    const freeze = this.opts.freeze;
+    if (!freeze || session.key.startsWith("::"))
+      return;
+    const now = Date.now();
+    if (!force && now - session.lastFreezeAtMs < FREEZE_INTERVAL_MS)
+      return;
+    session.lastFreezeAtMs = now;
+    freeze.save(freezeSession(session));
+  }
   liveCount() {
     let n = 0;
     for (const session of this.sessions.values())
@@ -682,8 +898,6 @@ class PtyHost {
   }
   spawn(key, spec, spare = false) {
     const argv = spec.command && spec.command.length > 0 ? [...spec.command] : [spec.shell ?? resolveLoginShell()];
-    const cols = spec.cols ?? 80;
-    const rows = spec.rows ?? 24;
     const session = {
       key,
       cwd: spec.cwd,
@@ -692,41 +906,49 @@ class PtyHost {
       chunks: [],
       bytes: 0,
       totalBytes: 0,
-      cols,
-      rows,
+      cols: spec.cols ?? 80,
+      rows: spec.rows ?? 24,
       command: argv,
       title: "",
       titleCarry: "",
-      titleDecoder: new StringDecoder("utf8"),
+      titleDecoder: new StringDecoder2("utf8"),
       sinks: new Map,
       parked: false,
       parkedScreenBytes: 0,
-      exit: null
+      exit: null,
+      restored: false,
+      lastFreezeAtMs: 0
     };
+    this.startChild(session);
+    if (session.alive) {
+      this.opts.log?.("pty", `spawned ${argv[0]} for ${key} (pid ${session.proc?.pid})`);
+      if (!spare)
+        this.opts.onSessionStart?.();
+    }
+    return session;
+  }
+  startChild(session) {
     try {
       session.proc = (this.opts.driver ?? bunTerminalDriver())({
-        argv,
-        cwd: spec.cwd,
+        argv: [...session.command],
+        cwd: session.cwd,
         env: embeddedTerminalEnv(process.env, {
           TERM: "xterm-256color",
-          COLUMNS: String(cols),
-          LINES: String(rows),
+          COLUMNS: String(session.cols),
+          LINES: String(session.rows),
           BASH_SILENCE_DEPRECATION_WARNING: "1",
           KOBE_TERMINAL_PTY: "1"
         }),
-        cols,
-        rows,
+        cols: session.cols,
+        rows: session.rows,
         onData: (data) => this.onData(session, data)
       });
+      session.alive = true;
       session.proc.exited.then((exit) => this.markExited(session, exit), () => 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)}`);
+      this.opts.log?.("pty", `spawn failed for ${session.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);
@@ -739,8 +961,10 @@ class PtyHost {
       if (dropped)
         session.bytes -= dropped.byteLength;
     }
-    if (session.sinks.size === 0)
+    if (session.sinks.size === 0) {
+      this.maybeFreeze(session);
       return;
+    }
     const frame = {
       type: "event",
       name: "pty.data",
@@ -748,6 +972,7 @@ class PtyHost {
     };
     for (const sink of session.sinks.values())
       sink(frame);
+    this.maybeFreeze(session);
   }
   markExited(session, exit) {
     if (!session.alive)
@@ -765,6 +990,7 @@ class PtyHost {
     for (const sink of session.sinks.values())
       sink(frame);
     this.opts.log?.("pty", `session ${session.key} exited${describeExit(session.exit)}`);
+    this.maybeFreeze(session, true);
     try {
       this.opts.onSessionExit?.({
         key: session.key,
@@ -783,12 +1009,7 @@ class PtyHost {
       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);
+    await terminatePtyChild(proc, () => this.markExited(session));
   }
 }
 
@@ -804,10 +1025,12 @@ function resolveIdleExitMs() {
 async function startPtyHostServer(options = {}) {
   const socketPath = options.socketPath ?? defaultPtyHostSocketPath();
   const pidPath = options.pidPath ?? defaultPtyHostPidPath();
+  const freezeDir = options.freezeDir ?? defaultPtyFreezeDir();
   const idleExitMs = options.idleExitMs || resolveIdleExitMs();
   const log = options.log ?? (() => {});
   const clients = new Set;
   let stopping = false;
+  let wipeFreezeOnStop = false;
   let idleTimer = null;
   const cancelIdle = () => {
     if (idleTimer)
@@ -838,9 +1061,11 @@ async function startPtyHostServer(options = {}) {
         log("pty", `exit record write failed for ${info.key}: ${err instanceof Error ? err.message : String(err)}`);
       }
     },
+    freeze: fileFreezeSink(freezeDir),
     driver: options.driver,
     log
   });
+  ptys.restoreFrozen(loadFrozenSessions(freezeDir));
   const pipeSocket = isWindowsPipePath(socketPath);
   if (!pipeSocket)
     await mkdir(dirname2(socketPath), { recursive: true });
@@ -857,7 +1082,7 @@ async function startPtyHostServer(options = {}) {
       buffer: ""
     };
     clients.add(client);
-    const decoder = new StringDecoder2("utf8");
+    const decoder = new StringDecoder3("utf8");
     socket.on("data", (chunk) => {
       client.buffer += decoder.write(chunk);
       drain(client);
@@ -876,7 +1101,9 @@ async function startPtyHostServer(options = {}) {
         return;
       stopping = true;
       cancelIdle();
-      await ptys.killAll();
+      await ptys.shutdown();
+      if (wipeFreezeOnStop)
+        clearFrozenSessions(freezeDir);
       for (const client of Array.from(clients))
         client.socket.destroy();
       await new Promise((resolve) => server.close(() => resolve()));
@@ -940,6 +1167,7 @@ async function startPtyHostServer(options = {}) {
         return {};
       }
       case "daemon.stop":
+        wipeFreezeOnStop = true;
         setTimeout(() => void stop(), 0).unref();
         return {};
       default: