@juspay/shooter 1.21.0 → 1.23.0

package/build/server/chunks/{pty-manager-ZqXqa-6A.js → pty-manager-DDjG7DlH.js}

@@ -10,6 +10,8 @@ import { b as broadcastEvent } from './guest-registry-Dxvd7p-g.js';
 import './super-session-handler-DPyxFgmz.js';
 import * as net from 'net';
 import Database from 'better-sqlite3';
+import { createRequire } from 'node:module';
+import { s as shooterDataDir } from './shooter-home-4f_HkdGI.js';
 
 function readOnlySourceForCommand(command) {
   switch (command) {
@@ -69,6 +71,21 @@ function discoverReadOnlyProviderSessionFile(source, cwd, launchTimeMs, nowMs) {
   }
   return resolveReadOnlyProviderFile(source, match.id);
 }
+const CLAUDE_COMMANDS = /* @__PURE__ */ new Set(["claude"]);
+function withAgentPermissionMode(command, args, mode) {
+  const trimmed = (mode ?? "").trim();
+  if (trimmed.length === 0) {
+    return args;
+  }
+  const base = command.split("/").pop() ?? command;
+  if (!CLAUDE_COMMANDS.has(base)) {
+    return args;
+  }
+  if (args.includes("--permission-mode")) {
+    return args;
+  }
+  return [...args, "--permission-mode", trimmed];
+}
 class HolderClient {
   connected = false;
   pid = 0;
@@ -705,7 +722,63 @@ function toMillis(timestamp) {
 const OW_GLOBAL_KEY = "__shooter_opencode_watcher";
 const openCodeWatcher = globalThis[OW_GLOBAL_KEY] || new OpenCodeWatcher();
 globalThis[OW_GLOBAL_KEY] = openCodeWatcher;
-const DB_DIR = path.join(process.env.HOME || "", ".shooter");
+const require$1 = createRequire(import.meta.url);
+const { Terminal } = require$1("@xterm/headless");
+const { SerializeAddon } = require$1("@xterm/addon-serialize");
+const SNAPSHOT_SCROLLBACK_LINES = 1e3;
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+class TerminalEmulator {
+  cursorHidden = false;
+  serializer;
+  term;
+  constructor(cols, rows) {
+    this.term = new Terminal({
+      allowProposedApi: true,
+      cols: cols > 0 ? cols : 80,
+      rows: rows > 0 ? rows : 24,
+      scrollback: SNAPSHOT_SCROLLBACK_LINES
+    });
+    this.serializer = new SerializeAddon();
+    this.term.loadAddon(this.serializer);
+  }
+  dispose() {
+    try {
+      this.serializer.dispose();
+      this.term.dispose();
+    } catch {
+    }
+  }
+  resize(cols, rows) {
+    if (cols > 0 && rows > 0) {
+      this.term.resize(cols, rows);
+    }
+  }
+  /**
+   * Capture the current screen as a VT-escape string. Serialization runs inside
+   * a write() callback so all previously-written bytes are parsed first.
+   */
+  snapshot() {
+    return new Promise((resolve) => {
+      this.term.write("", () => {
+        let data = this.serializer.serialize({ scrollback: SNAPSHOT_SCROLLBACK_LINES });
+        if (this.cursorHidden) {
+          data += HIDE_CURSOR;
+        }
+        resolve({ cols: this.term.cols, data, rows: this.term.rows });
+      });
+    });
+  }
+  write(data) {
+    const hideIdx = data.lastIndexOf(HIDE_CURSOR);
+    const showIdx = data.lastIndexOf(SHOW_CURSOR);
+    if (hideIdx !== -1 || showIdx !== -1) {
+      this.cursorHidden = hideIdx > showIdx;
+    }
+    this.term.write(data);
+  }
+}
+const DB_DIR = shooterDataDir();
 const DB_PATH = path.join(DB_DIR, "shooter.db");
 const COLUMNS = [
   "id",
@@ -849,6 +922,11 @@ globalThis[TS_GLOBAL_KEY] = terminalStore;
 const MAX_SCROLLBACK_BYTES = 512 * 1024;
 const MAX_OUTPUT_BUFFER_BYTES = 1024 * 1024;
 const SCROLLBACK_CHUNK_SIZE = 50 * 1024;
+const SEQ_RING_MAX_ENTRIES = 2e3;
+const SNAPSHOT_ENABLED = process.env.SHOOTER_SNAPSHOT_FALLBACK !== "raw";
+const RESNAPSHOT_LOW_WATER_BYTES = MAX_OUTPUT_BUFFER_BYTES / 4;
+const RESNAPSHOT_POLL_MS = 100;
+const RESNAPSHOT_MAX_WAIT_MS = 1e4;
 const CLEANUP_INTERVAL_MS = 5 * 60 * 1e3;
 const EXITED_TTL_MS = 60 * 60 * 1e3;
 const MAX_EXITED_TERMINALS = 10;
@@ -859,6 +937,10 @@ const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path__default.dirname(__filename$1);
 class PtyManager {
   cleanupTimer = null;
+  // Clients currently converging via a resnapshot (Phase 2). While pending, a
+  // client receives no normal output frames — the forthcoming snapshot brings
+  // it to the current screen. WeakSet so disconnected sockets drop out on GC.
+  resnapshotPending = /* @__PURE__ */ new WeakSet();
   terminals = /* @__PURE__ */ new Map();
   constructor() {
     this.cleanupTimer = setInterval(() => {
@@ -869,19 +951,42 @@ class PtyManager {
   // create — now async: forks a holder process, connects via HolderClient,
   //          persists to SQLite
   // -----------------------------------------------------------------------
-  attach(id, ws) {
+  attach(id, ws, opts) {
     const terminal = this.terminals.get(id);
     if (!terminal) {
       return false;
     }
-    terminal.clients.add(ws);
     terminal.outputBuffers.set(ws, { data: [], size: 0 });
+    const wantsSnapshot = opts?.snapshot === true;
+    const lastSeq = opts?.lastSeq ?? 0;
+    if (wantsSnapshot && lastSeq > 0) {
+      const gap = this.getSeqRingFrom(id, lastSeq);
+      if (gap !== null) {
+        for (const entry of gap) {
+          this.safeSend(ws, JSON.stringify({ data: entry.data, seq: entry.seq, type: "output" }));
+        }
+        terminal.clients.add(ws);
+        return true;
+      }
+    }
+    if (wantsSnapshot && terminal.emulator) {
+      void this.snapshotAndSend(terminal, ws).then((ok) => {
+        if (ws.readyState !== 1) {
+          return;
+        }
+        if (!ok) {
+          terminal.clients.add(ws);
+          void this.sendScrollback(terminal, ws);
+          return;
+        }
+        terminal.clients.add(ws);
+      });
+      return true;
+    }
+    terminal.clients.add(ws);
     void this.sendScrollback(terminal, ws);
     return true;
   }
-  // -----------------------------------------------------------------------
-  // reconnectAll — recover persisted terminals on server startup
-  // -----------------------------------------------------------------------
   cleanup() {
     const now = Date.now();
     const exited = [];
@@ -912,13 +1017,18 @@ class PtyManager {
     }
   }
   // -----------------------------------------------------------------------
-  // disconnectAll — graceful shutdown: disconnect clients, keep holders alive
+  // reconnectAll — recover persisted terminals on server startup
   // -----------------------------------------------------------------------
   async create(command, args, cwd, cols, rows) {
     const id = randomBytes(4).toString("hex");
     const socketPath = `/tmp/shooter-term-${id}.sock`;
     const holderScript = resolveHolderPath();
-    const holderArgs = [id, socketPath, cwd, String(cols), String(rows), command, ...args];
+    const launchArgs = withAgentPermissionMode(
+      command,
+      args,
+      process.env.SHOOTER_AGENT_PERMISSION_MODE
+    );
+    const holderArgs = [id, socketPath, cwd, String(cols), String(rows), command, ...launchArgs];
     const holder = fork(holderScript, holderArgs, {
       detached: true,
       stdio: ["ignore", "ignore", "ignore", "ipc"]
@@ -953,13 +1063,14 @@ class PtyManager {
     const connectResult = await client.connect(socketPath);
     const now = /* @__PURE__ */ new Date();
     const terminal = {
-      args,
+      args: launchArgs,
       clients: /* @__PURE__ */ new Set(),
       cols,
       command,
       createdAt: now,
       currentCwd: null,
       cwd,
+      emulator: SNAPSHOT_ENABLED ? new TerminalEmulator(cols, rows) : null,
       exitCode: connectResult.exitCode,
       exitedAt: null,
       holderPid,
@@ -973,6 +1084,8 @@ class PtyManager {
       pty: client,
       rows,
       scrollback: connectResult.scrollback,
+      seqCounter: 0,
+      seqRing: [],
       sessionFile: null,
       socketPath,
       status: connectResult.exited ? "exited" : "running",
@@ -980,7 +1093,7 @@ class PtyManager {
     };
     this.wireHolderCallbacks(client, terminal);
     terminalStore.insert({
-      args: JSON.stringify(args),
+      args: JSON.stringify(launchArgs),
       cols,
       command,
       createdAt: now.toISOString(),
@@ -1006,7 +1119,7 @@ class PtyManager {
     return terminal;
   }
   // -----------------------------------------------------------------------
-  // get
+  // disconnectAll — graceful shutdown: disconnect clients, keep holders alive
   // -----------------------------------------------------------------------
   destroy() {
     if (this.cleanupTimer) {
@@ -1041,8 +1154,7 @@ class PtyManager {
     }
   }
   // -----------------------------------------------------------------------
-  // list — running first, then recently exited, each group sorted by
-  //        createdAt descending
+  // get
   // -----------------------------------------------------------------------
   detach(id, ws) {
     const terminal = this.terminals.get(id);
@@ -1054,7 +1166,8 @@ class PtyManager {
     return true;
   }
   // -----------------------------------------------------------------------
-  // kill — route through holder: SIGTERM, then SIGKILL after 5 s
+  // list — running first, then recently exited, each group sorted by
+  //        createdAt descending
   // -----------------------------------------------------------------------
   disconnectAll() {
     if (this.cleanupTimer) {
@@ -1079,13 +1192,13 @@ class PtyManager {
     this.terminals.clear();
   }
   // -----------------------------------------------------------------------
-  // remove — remove an exited terminal from the map
+  // kill — route through holder: SIGTERM, then SIGKILL after 5 s
   // -----------------------------------------------------------------------
   get(id) {
     return this.terminals.get(id) ?? null;
   }
   // -----------------------------------------------------------------------
-  // resize
+  // remove — remove an exited terminal from the map
   // -----------------------------------------------------------------------
   getScrollback(id) {
     const terminal = this.terminals.get(id);
@@ -1095,8 +1208,40 @@ class PtyManager {
     return terminal.scrollback;
   }
   // -----------------------------------------------------------------------
-  // attach — register a WebSocket client and replay scrollback
+  // resize
   // -----------------------------------------------------------------------
+  /** Current highest assigned seq for a terminal, or null if unknown. */
+  getSeqCounter(id) {
+    return this.terminals.get(id)?.seqCounter ?? null;
+  }
+  /**
+   * Return the ring entries with seq > afterSeq, in order. Returns an empty
+   * array when the caller is already current, or null when the gap is
+   * unresolvable from the ring (caller must take a full snapshot). Unresolvable
+   * means any of:
+   *   - afterSeq > seqCounter: the caller claims a seq we never produced — this
+   *     happens when the seq counter reset across a server restart (the client
+   *     is from a previous terminal lifetime), so its content is unrelated.
+   *   - ring empty but afterSeq > 0: nothing buffered to bridge the gap.
+   *   - afterSeq predates the oldest retained entry: the gap aged out.
+   */
+  getSeqRingFrom(id, afterSeq) {
+    const terminal = this.terminals.get(id);
+    if (!terminal) {
+      return null;
+    }
+    if (afterSeq > terminal.seqCounter) {
+      return null;
+    }
+    const ring = terminal.seqRing;
+    if (ring.length === 0) {
+      return afterSeq <= 0 ? [] : null;
+    }
+    if (afterSeq < ring[0].seq - 1) {
+      return null;
+    }
+    return ring.filter((e) => e.seq > afterSeq);
+  }
   kill(id) {
     const terminal = this.terminals.get(id);
     if (!terminal) {
@@ -1129,7 +1274,7 @@ class PtyManager {
     return true;
   }
   // -----------------------------------------------------------------------
-  // detach — remove a WebSocket client
+  // attach — register a WebSocket client and replay scrollback
   // -----------------------------------------------------------------------
   list() {
     const all = Array.from(this.terminals.values());
@@ -1142,7 +1287,7 @@ class PtyManager {
     return [...running, ...exited];
   }
   // -----------------------------------------------------------------------
-  // getScrollback — return raw scrollback data for replay
+  // detach — remove a WebSocket client
   // -----------------------------------------------------------------------
   async reconnectAll() {
     const running = terminalStore.listRunning();
@@ -1162,8 +1307,7 @@ class PtyManager {
     }
   }
   // -----------------------------------------------------------------------
-  // cleanup — evict exited terminals older than 1 hour, cap at 10 exited;
-  //           also clean up old SQLite records
+  // getScrollback — return raw scrollback data for replay
   // -----------------------------------------------------------------------
   remove(id) {
     const terminal = this.terminals.get(id);
@@ -1177,7 +1321,8 @@ class PtyManager {
     return true;
   }
   // -----------------------------------------------------------------------
-  // destroy — emergency forced kill (kills holder processes too)
+  // cleanup — evict exited terminals older than 1 hour, cap at 10 exited;
+  //           also clean up old SQLite records
   // -----------------------------------------------------------------------
   resize(id, cols, rows) {
     const terminal = this.terminals.get(id);
@@ -1188,6 +1333,7 @@ class PtyManager {
       terminal.pty.resize(cols, rows);
       terminal.cols = cols;
       terminal.rows = rows;
+      terminal.emulator?.resize(cols, rows);
       const msg = JSON.stringify({ cols, rows, type: "resize" });
       for (const ws of terminal.clients) {
         this.safeSend(ws, msg);
@@ -1198,6 +1344,39 @@ class PtyManager {
     }
   }
   // -----------------------------------------------------------------------
+  // destroy — emergency forced kill (kills holder processes too)
+  // -----------------------------------------------------------------------
+  /**
+   * Compute the current-screen snapshot from the emulator and send it as a
+   * single {type:'snapshot'} frame stamped with the current seq. Returns false
+   * if there is no emulator, the socket closed, or serialization failed.
+   * Reused by Phase 2 to resnapshot a client after a backpressure gap.
+   */
+  async snapshotAndSend(terminal, ws) {
+    if (!terminal.emulator) {
+      return false;
+    }
+    try {
+      const snap = await terminal.emulator.snapshot();
+      if (ws.readyState !== 1) {
+        return false;
+      }
+      this.safeSend(
+        ws,
+        JSON.stringify({
+          cols: snap.cols,
+          data: snap.data,
+          rows: snap.rows,
+          seq: terminal.seqCounter,
+          type: "snapshot"
+        })
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // -----------------------------------------------------------------------
   // Private: reconnectOne — reconnect to a single persisted terminal
   // -----------------------------------------------------------------------
   appendScrollback(terminal, data) {
@@ -1212,21 +1391,103 @@ class PtyManager {
       }
     }
   }
+  /**
+   * Assign the next sequence number to an output chunk and append it to the
+   * bounded replay ring. Returns the new seq. Phase 2 uses the ring to replay
+   * the gap to a reconnecting client without a full snapshot.
+   */
+  appendSeqRing(terminal, data) {
+    const seq = terminal.seqCounter + 1;
+    terminal.seqRing.push({ data, seq });
+    if (terminal.seqRing.length > SEQ_RING_MAX_ENTRIES) {
+      terminal.seqRing.shift();
+    }
+    terminal.seqCounter = seq;
+    return seq;
+  }
+  /**
+   * Mark a client for convergence (Phase 2). Its queued output is discarded and
+   * further live frames are withheld until its socket drains below the low-water
+   * mark (or a hard timeout elapses), at which point a fresh snapshot resets it
+   * to the current screen. This replaces silent byte-dropping so a slow or
+   * throttled client can never diverge permanently (G1).
+   */
+  beginResnapshot(terminal, ws) {
+    if (this.resnapshotPending.has(ws)) {
+      return;
+    }
+    this.resnapshotPending.add(ws);
+    const buffer = terminal.outputBuffers.get(ws);
+    if (buffer) {
+      buffer.data.length = 0;
+      buffer.size = 0;
+    }
+    this.safeSend(ws, JSON.stringify({ bytes: 0, type: "output-dropped" }));
+    const startedAt = Date.now();
+    const poll = () => {
+      if (!this.resnapshotPending.has(ws)) {
+        return;
+      }
+      if (ws.readyState !== 1 || !terminal.emulator || !terminal.clients.has(ws)) {
+        this.resnapshotPending.delete(ws);
+        return;
+      }
+      const drained = ws.bufferedAmount <= RESNAPSHOT_LOW_WATER_BYTES;
+      const timedOut = Date.now() - startedAt > RESNAPSHOT_MAX_WAIT_MS;
+      if (drained || timedOut) {
+        void this.snapshotAndSend(terminal, ws).finally(() => {
+          this.resnapshotPending.delete(ws);
+        });
+        return;
+      }
+      setTimeout(poll, RESNAPSHOT_POLL_MS);
+    };
+    setTimeout(poll, RESNAPSHOT_POLL_MS);
+  }
   // -----------------------------------------------------------------------
   // Private: handleReconnectFailure — handle failed reconnection
   // -----------------------------------------------------------------------
   broadcastOutput(terminal, data) {
-    const msg = JSON.stringify({ data, type: "output" });
+    const seq = this.appendSeqRing(terminal, data);
+    const msg = JSON.stringify({ data, seq, type: "output" });
+    if (!terminal.emulator) {
+      this.broadcastOutputLegacy(terminal, msg);
+      return;
+    }
+    const msgSize = Buffer.byteLength(msg, "utf8");
+    for (const ws of terminal.clients) {
+      if (this.resnapshotPending.has(ws)) {
+        continue;
+      }
+      const buffer = terminal.outputBuffers.get(ws);
+      if (!buffer) {
+        continue;
+      }
+      if (ws.bufferedAmount > MAX_OUTPUT_BUFFER_BYTES || buffer.size + msgSize > MAX_OUTPUT_BUFFER_BYTES) {
+        this.beginResnapshot(terminal, ws);
+        continue;
+      }
+      buffer.data.push(msg);
+      buffer.size += msgSize;
+      this.flushOutputBuffer(ws, buffer);
+    }
+  }
+  /**
+   * Legacy broadcast path used only when the emulator is disabled
+   * (SHOOTER_SNAPSHOT_FALLBACK=raw). Drops the oldest buffered output to make
+   * room and notifies the client; there is no snapshot to converge it to.
+   */
+  broadcastOutputLegacy(terminal, msg) {
+    const msgSize = Buffer.byteLength(msg, "utf8");
     for (const ws of terminal.clients) {
       if (ws.bufferedAmount > MAX_OUTPUT_BUFFER_BYTES) {
-        this.safeSend(ws, JSON.stringify({ bytes: data.length, type: "output-dropped" }));
+        this.safeSend(ws, JSON.stringify({ bytes: msgSize, type: "output-dropped" }));
         continue;
       }
       const buffer = terminal.outputBuffers.get(ws);
       if (!buffer) {
         continue;
       }
-      const msgSize = Buffer.byteLength(msg, "utf8");
       if (buffer.size + msgSize > MAX_OUTPUT_BUFFER_BYTES) {
         let droppedBytes = 0;
         while (buffer.size + msgSize > MAX_OUTPUT_BUFFER_BYTES && buffer.data.length > 0) {
@@ -1238,11 +1499,7 @@ class PtyManager {
           }
         }
         if (droppedBytes > 0) {
-          const dropMsg = JSON.stringify({
-            bytes: droppedBytes,
-            type: "output-dropped"
-          });
-          this.safeSend(ws, dropMsg);
+          this.safeSend(ws, JSON.stringify({ bytes: droppedBytes, type: "output-dropped" }));
         }
       }
       buffer.data.push(msg);
@@ -1275,6 +1532,8 @@ class PtyManager {
       openCodeWatcher.stop(terminal.openCodeSessionId, terminal.openCodeNoopCb);
       terminal.openCodeNoopCb = null;
     }
+    terminal.emulator?.dispose();
+    terminal.emulator = null;
     terminal.pty.disconnect();
     for (const ws of terminal.clients) {
       try {
@@ -1366,6 +1625,7 @@ class PtyManager {
       createdAt: new Date(record.createdAt),
       currentCwd: null,
       cwd: record.cwd,
+      emulator: SNAPSHOT_ENABLED ? new TerminalEmulator(record.cols, record.rows) : null,
       exitCode: connectResult.exitCode,
       exitedAt: record.exitedAt ? new Date(record.exitedAt) : null,
       holderPid: record.holderPid ?? 0,
@@ -1379,11 +1639,16 @@ class PtyManager {
       pty: client,
       rows: record.rows,
       scrollback: connectResult.scrollback,
+      seqCounter: 0,
+      seqRing: [],
       sessionFile: record.sessionFile ?? null,
       socketPath: record.socketPath,
       status: connectResult.exited ? "exited" : "running",
       watcherOffset: 0
     };
+    if (terminal.emulator && connectResult.scrollback.length > 0) {
+      terminal.emulator.write(connectResult.scrollback);
+    }
     if (connectResult.exited) {
       terminal.exitedAt = terminal.exitedAt ?? /* @__PURE__ */ new Date();
       terminalStore.markExited(record.id, connectResult.exitCode);
@@ -1646,6 +1911,7 @@ class PtyManager {
       }
     });
     client.onOutput((data) => {
+      terminal.emulator?.write(data);
       this.appendScrollback(terminal, data);
       this.broadcastOutput(terminal, data);
     });
@@ -1690,4 +1956,4 @@ const ptyManager = globalThis[PTY_GLOBAL_KEY] || new PtyManager();
 globalThis[PTY_GLOBAL_KEY] = ptyManager;
 
 export { ptyManager as p };
-//# sourceMappingURL=pty-manager-ZqXqa-6A.js.map
+//# sourceMappingURL=pty-manager-DDjG7DlH.js.map