hop2 0.9.0 → 0.9.1

package/hay/apps/cli/src/index.ts

@@ -165,15 +165,26 @@ if (!config.room) {
   process.exit(1);
 }
 
+let sessionLabel = config.room;
+
 const DETACH_EXIT_CODE = 10;
 const KILL_EXIT_CODE = 11;
 const TYPING_IDLE_MS = 1200;
 const NOTICE_MS = 3500;
+const HOP_DAEMON_POLL_MS = 5000;
 const PAN_STEP = 2;
 const PAN_FAST_STEP = 10;
 let cursorVisible = true;
 const SCROLL_STEP = 3;
+const REMOTE_MOUSE_MODE_PARAMS = new Set([9, 1000, 1001, 1002, 1003, 1005, 1006, 1015, 1016]);
+const REMOTE_ALT_SCREEN_PARAMS = new Set([47, 1047, 1049]);
+const REMOTE_APPLICATION_CURSOR_MODE_PARAM = 1;
+const PRIVATE_MODE_TAIL_CHARS = 64;
 let pendingInput = "";
+let remoteMouseModes = new Set<number>();
+let remoteAlternateScreen = false;
+let remoteApplicationCursor = false;
+let pendingPrivateMode = "";
 type RgbColor = { r: number; g: number; b: number };
 let defaultFg: RgbColor | null = null;
 let defaultBg: RgbColor | null = null;
@@ -189,8 +200,10 @@ let reconnectAttempt = 0;
 let reconnectTimer: NodeJS.Timeout | null = null;
 let typingTimeout: NodeJS.Timeout | null = null;
 let noticeTimer: NodeJS.Timeout | null = null;
+let daemonPollTimer: NodeJS.Timeout | null = null;
 let exitCode = 0;
 let exitMessage: string | null = null;
+let shortcutsEnabledAt = 0;
 
 let collabMode = true;
 let controllerId: string | null = null;
@@ -201,6 +214,7 @@ let syncSize = true;
 let mouseCapture = true;
 let viewX = 0;
 let viewY = 0;
+let userPannedAway = false;
 let showHints = true;
 let scrollOff = DEFAULT_SCROLL_OFF;
 
@@ -213,6 +227,46 @@ let renderScheduled = false;
 let lastRenderCols = 0;
 let lastRenderRows = 0;
 
+const hopHomeDir = process.env.HOP_HOME || path.join(os.homedir(), ".hop2");
+const hopTunnelStateFile = path.join(hopHomeDir, ".tunnel-state");
+const explicitShareEnv = process.env.HAY_SHARE_URL || process.env.HOP_PUBLIC_URL || "";
+
+const normalizeUrlOrigin = (raw: string) => {
+  try {
+    const url = new URL(raw);
+    return url.origin;
+  } catch {
+    return raw;
+  }
+};
+
+const inferServerOrigin = () => {
+  try {
+    const wsUrl = new URL(config.server);
+    const protocol = wsUrl.protocol === "wss:" ? "https:" : "http:";
+    return normalizeUrlOrigin(`${protocol}//${wsUrl.host}`);
+  } catch {
+    return "";
+  }
+};
+
+const explicitShareUrl = explicitShareEnv ? normalizeUrlOrigin(explicitShareEnv) : "";
+const defaultShareUrl = explicitShareUrl || inferServerOrigin();
+
+const shouldTrackHopDaemon = (() => {
+  if (process.env.HAY_TRACK_HOP_DAEMON === "1") return true;
+  if (process.env.HAY_TRACK_HOP_DAEMON === "0") return false;
+  try {
+    const wsUrl = new URL(config.server);
+    return wsUrl.hostname === "127.0.0.1" || wsUrl.hostname === "localhost" || wsUrl.hostname === "::1";
+  } catch {
+    return false;
+  }
+})();
+
+let hopDaemonRunning = false;
+let hopDaemonShareUrl = "";
+
 const getLocalMetrics = () => {
   const cols = process.stdout.columns || 80;
   const rows = process.stdout.rows || 24;
@@ -250,21 +304,36 @@ terminal.onData((data) => {
 
 const filterFocusSequences = (data: string) => data.replace(/\x1b\[I/g, "").replace(/\x1b\[O/g, "");
 
+const getDirectionalKey = (direction: number) => {
+  if (remoteApplicationCursor) {
+    return direction > 0 ? "\x1bOB" : "\x1bOA";
+  }
+  return direction > 0 ? "\x1b[B" : "\x1b[A";
+};
+
 const stripMouseSequences = (data: string) => {
-  let didScroll = false;
-  const cleaned = data.replace(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/g, (_, buttonText, _x, _y, kind) => {
+  const cleaned = data.replace(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/g, (sequence, buttonText, _x, _y, kind) => {
     const button = Number(buttonText);
     const isWheel = (button & 64) === 64;
     if (isWheel && kind === "M") {
       const direction = (button & 1) === 1 ? 1 : -1;
+      const isTuiLikeMode = remoteAlternateScreen || remoteMouseModes.size > 0;
+      if (isTuiLikeMode) {
+        return getDirectionalKey(direction).repeat(SCROLL_STEP);
+      }
+      // In normal shell mode, wheel should pan local viewport scrollback.
       viewY += direction * SCROLL_STEP;
       clampView();
+      userPannedAway = viewY < getMaxViewY();
       scheduleRender();
-      didScroll = true;
+      return "";
+    }
+    if (remoteMouseModes.size > 0) {
+      return sequence;
     }
     return "";
   });
-  return { cleaned, didScroll };
+  return { cleaned };
 };
 
 const parseOscColor = (value: string): RgbColor | null => {
@@ -389,17 +458,65 @@ const setCursorVisible = (visible: boolean) => {
   scheduleRender();
 };
 
-terminal.parser.registerCsiHandler({ prefix: "?", final: "l" }, (params) => {
-  if (params.includes(25)) {
-    setCursorVisible(false);
+const applyPrivateModes = (params: readonly number[], enabled: boolean) => {
+  for (const param of params) {
+    if (param === REMOTE_APPLICATION_CURSOR_MODE_PARAM) {
+      remoteApplicationCursor = enabled;
+      continue;
+    }
+    if (param === 25) {
+      setCursorVisible(enabled);
+      continue;
+    }
+    if (REMOTE_MOUSE_MODE_PARAMS.has(param)) {
+      if (enabled) {
+        remoteMouseModes.add(param);
+      } else {
+        remoteMouseModes.delete(param);
+      }
+      continue;
+    }
+    if (REMOTE_ALT_SCREEN_PARAMS.has(param)) {
+      remoteAlternateScreen = enabled;
+    }
   }
+};
+
+const trackPrivateModes = (chunk: string) => {
+  if (!chunk) return;
+  const combined = pendingPrivateMode + chunk;
+  const modeRegex = /\x1b\[\?([0-9;]*)([hl])/g;
+  let match: RegExpExecArray | null;
+  let lastCompleteIndex = 0;
+  while ((match = modeRegex.exec(combined)) !== null) {
+    const params = match[1]
+      .split(";")
+      .filter(Boolean)
+      .map((param) => Number.parseInt(param, 10))
+      .filter((param) => Number.isFinite(param));
+    applyPrivateModes(params, match[2] === "h");
+    lastCompleteIndex = modeRegex.lastIndex;
+  }
+
+  const trailingStart = combined.lastIndexOf("\x1b[?");
+  if (trailingStart !== -1 && trailingStart >= lastCompleteIndex) {
+    const trailing = combined.slice(trailingStart);
+    if (!/[hl]/.test(trailing)) {
+      pendingPrivateMode = trailing.slice(-PRIVATE_MODE_TAIL_CHARS);
+      return;
+    }
+  }
+
+  pendingPrivateMode = combined.slice(-PRIVATE_MODE_TAIL_CHARS);
+};
+
+terminal.parser.registerCsiHandler({ prefix: "?", final: "l" }, (params) => {
+  applyPrivateModes(params, false);
   return false;
 });
 
 terminal.parser.registerCsiHandler({ prefix: "?", final: "h" }, (params) => {
-  if (params.includes(25)) {
-    setCursorVisible(true);
-  }
+  applyPrivateModes(params, true);
   return false;
 });
 
@@ -478,31 +595,78 @@ const getUrl = () => {
   )}&cols=${localMetrics.viewportCols}&rows=${localMetrics.viewportRows}`;
 };
 
-const buildShareUrl = () => {
-  const explicit = process.env.HAY_SHARE_URL || process.env.HOP_PUBLIC_URL || "";
-
-  const normalize = (raw: string) => {
-    try {
-      const url = new URL(raw);
-      return url.origin;
-    } catch {
-      return raw;
-    }
-  };
-
-  if (explicit) {
-    return normalize(explicit);
+const isPidAlive = (pid: number) => {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
   }
+};
 
+const readHopDaemonRuntime = () => {
+  if (!shouldTrackHopDaemon) {
+    return { running: false, shareUrl: "" };
+  }
+  if (!fs.existsSync(hopTunnelStateFile)) {
+    return { running: false, shareUrl: "" };
+  }
   try {
-    const wsUrl = new URL(config.server);
-    const protocol = wsUrl.protocol === "wss:" ? "https:" : "http:";
-    return normalize(`${protocol}//${wsUrl.host}`);
+    const parsed = JSON.parse(fs.readFileSync(hopTunnelStateFile, "utf8"));
+    const pid = Number(parsed?.pid);
+    if (!isPidAlive(pid)) {
+      return { running: false, shareUrl: "" };
+    }
+    const shareUrlRaw = typeof parsed?.url === "string" ? parsed.url.trim() : "";
+    return {
+      running: true,
+      shareUrl: shareUrlRaw ? normalizeUrlOrigin(shareUrlRaw) : ""
+    };
   } catch {
-    return "";
+    return { running: false, shareUrl: "" };
   }
 };
 
+const refreshHopDaemonRuntime = () => {
+  if (!shouldTrackHopDaemon) return;
+  const next = readHopDaemonRuntime();
+  if (next.running !== hopDaemonRunning || next.shareUrl !== hopDaemonShareUrl) {
+    hopDaemonRunning = next.running;
+    hopDaemonShareUrl = next.shareUrl;
+    scheduleRender();
+  }
+};
+
+const startDaemonPolling = () => {
+  if (!shouldTrackHopDaemon || daemonPollTimer) return;
+  refreshHopDaemonRuntime();
+  daemonPollTimer = setInterval(() => {
+    refreshHopDaemonRuntime();
+  }, HOP_DAEMON_POLL_MS);
+  daemonPollTimer.unref?.();
+};
+
+const stopDaemonPolling = () => {
+  if (!daemonPollTimer) return;
+  clearInterval(daemonPollTimer);
+  daemonPollTimer = null;
+};
+
+const buildShareUrl = () => {
+  if (shouldTrackHopDaemon && hopDaemonShareUrl) {
+    return hopDaemonShareUrl;
+  }
+  return defaultShareUrl;
+};
+
+const buildHopDaemonLabel = () => {
+  if (!shouldTrackHopDaemon) return "";
+  if (!hopDaemonRunning) return "hop offline";
+  if (!hopDaemonShareUrl) return "hop starting";
+  return "hop online";
+};
+
 const setStatus = (nextStatus: typeof status) => {
   status = nextStatus;
   scheduleRender();
@@ -614,6 +778,42 @@ const padOrTrim = (text: string, cols: number) => {
   return text;
 };
 
+type BarSegment = {
+  text: string;
+  secondary?: boolean;
+  dropPriority?: number;
+};
+
+const joinBarSegments = (segments: BarSegment[]) => segments.map((segment) => segment.text).join(" | ");
+
+const fitBarSegments = (left: string, segments: BarSegment[], cols: number) => {
+  const active = segments.filter((segment) => segment.text);
+  while (active.length > 0) {
+    const right = joinBarSegments(active);
+    const rightLen = visibleLength(right);
+    const availableLeft = right ? Math.max(0, cols - rightLen - 1) : cols;
+    if (rightLen < cols && visibleLength(left) <= availableLeft) {
+      break;
+    }
+
+    let optionalIndex = -1;
+    let optionalPriority = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < active.length; i += 1) {
+      const priority = active[i].dropPriority;
+      if (priority === undefined) continue;
+      if (priority < optionalPriority) {
+        optionalPriority = priority;
+        optionalIndex = i;
+      }
+    }
+    if (optionalIndex === -1) {
+      break;
+    }
+    active.splice(optionalIndex, 1);
+  }
+  return active;
+};
+
 const composeBar = (left: string, right: string, cols: number) => {
   if (!right) {
     return padOrTrim(left, cols);
@@ -874,17 +1074,34 @@ const render = () => {
   const presenceNames = presence.filter((client) => client.id !== clientId).map((client) => client.name);
   const statusLabel = status === "connected" ? "" : status;
   const shareUrl = buildShareUrl();
+  const hopDaemonLabel = buildHopDaemonLabel();
 
-  const statusOrUrl = statusLabel || shareUrl;
-  const bottomLeft = `● ${config.room}`;
+  const bottomLeft = `● ${sessionLabel}`;
   const autofitLabel = syncSize ? "autofit on" : "autofit off";
   const peerLabel = `peers ${presenceNames.length}`;
+  const rightSegments = fitBarSegments(
+    bottomLeft,
+    [
+      statusLabel ? { text: statusLabel } : null,
+      hopDaemonLabel ? { text: hopDaemonLabel, secondary: true, dropPriority: 1 } : null,
+      !statusLabel && shareUrl ? { text: shareUrl, secondary: true, dropPriority: 0 } : null,
+      { text: autofitLabel, secondary: true, dropPriority: 2 },
+      { text: peerLabel, secondary: true, dropPriority: 3 }
+    ].filter((segment): segment is BarSegment => !!segment),
+    localMetrics.cols
+  );
+  const rightPriority = rightSegments
+    .filter((segment) => segment.secondary)
+    .map((segment) => segment.text);
   const rightPrimary = decorateBottom(
-    [statusOrUrl, autofitLabel, peerLabel].filter(Boolean).join(" | "),
-    statusLabel ? [peerLabel] : [shareUrl, peerLabel]
+    joinBarSegments(rightSegments),
+    rightPriority
   );
+  const topPriority = rightSegments
+    .filter((segment) => segment.text === hopDaemonLabel || segment.text === shareUrl)
+    .map((segment) => segment.text);
   const bottomPrimary = renderBar(
-    decorateTop(composeBar(bottomLeft, rightPrimary, localMetrics.cols), statusLabel ? [] : [shareUrl], [config.room]),
+    decorateTop(composeBar(bottomLeft, rightPrimary, localMetrics.cols), topPriority, [sessionLabel]),
     "bottom"
   );
 
@@ -943,6 +1160,11 @@ const connect = () => {
 
   ws.on("open", () => {
     connected = true;
+    remoteMouseModes.clear();
+    remoteAlternateScreen = false;
+    remoteApplicationCursor = false;
+    pendingPrivateMode = "";
+    shortcutsEnabledAt = Date.now() + 400;
     reconnectAttempt = 0;
     setStatus("connected");
     initUi();
@@ -973,22 +1195,20 @@ const connect = () => {
         break;
       case "output":
         {
+          trackPrivateModes(message.data);
           trackOscColors(message.data);
           const filtered = filterFocusSequences(message.data);
           if (!filtered) return;
-          // Follow output if cursor was visible (standard terminal behavior)
-          const buffer = terminal.buffer.active;
-          const cursorRowBefore = buffer.baseY + buffer.cursorY;
-          const cursorWasVisible = cursorRowBefore >= viewY && cursorRowBefore < viewY + localMetrics.viewportRows;
           terminal.write(filtered, () => {
-            if (cursorWasVisible) {
-              // Only scroll if cursor moved outside viewport (with scrollOff margin)
-              const cursorRowAfter = buffer.baseY + buffer.cursorY;
+            if (!userPannedAway) {
+              // Follow cursor: keep it visible with scrollOff margin
+              const buffer = terminal.buffer.active;
+              const cursorRow = buffer.baseY + buffer.cursorY;
               const margin = Math.min(scrollOff, Math.floor(localMetrics.viewportRows / 2));
-              if (cursorRowAfter < viewY + margin) {
-                viewY = Math.max(0, cursorRowAfter - margin);
-              } else if (cursorRowAfter >= viewY + localMetrics.viewportRows - margin) {
-                viewY = cursorRowAfter - localMetrics.viewportRows + margin + 1;
+              if (cursorRow < viewY + margin) {
+                viewY = Math.max(0, cursorRow - margin);
+              } else if (cursorRow >= viewY + localMetrics.viewportRows - margin) {
+                viewY = cursorRow - localMetrics.viewportRows + margin + 1;
               }
               clampView();
             }
@@ -998,12 +1218,17 @@ const connect = () => {
         break;
       case "snapshot":
         {
+          trackPrivateModes(message.data);
+          if (typeof message.alternateScreen === "boolean") {
+            remoteAlternateScreen = message.alternateScreen;
+          }
           trackOscColors(message.data);
           terminal.clear();
+          userPannedAway = false;
           const filtered = filterFocusSequences(message.data);
           if (!filtered) return;
           terminal.write(filtered, () => {
-            // On snapshot, only scroll if cursor is outside viewport (with scrollOff margin)
+            // Always follow cursor on snapshot load
             const buffer = terminal.buffer.active;
             const cursorRow = buffer.baseY + buffer.cursorY;
             const margin = Math.min(scrollOff, Math.floor(localMetrics.viewportRows / 2));
@@ -1038,6 +1263,11 @@ const connect = () => {
           cleanupAndExit();
         }
         break;
+      case "session_renamed":
+        sessionLabel = message.displayName;
+        pushNotice(`Session renamed to ${message.displayName}`);
+        scheduleRender();
+        break;
       case "error":
         pushNotice(message.message);
         break;
@@ -1067,6 +1297,7 @@ const cleanupAndExit = () => {
   if (typingTimeout) {
     clearTimeout(typingTimeout);
   }
+  stopDaemonPolling();
   if (reconnectTimer) {
     clearTimeout(reconnectTimer);
   }
@@ -1095,9 +1326,10 @@ const handleLocalShortcut = (input: string) => {
 
   const shouldExitImmediately =
     !ws || ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING;
+  const ctrlShortcutsReady = Date.now() >= shortcutsEnabledAt;
 
   // Ctrl+Q to kill session
-  if (input === "\x11") {
+  if (ctrlShortcutsReady && input === "\x11") {
     shouldReconnect = false;
     exitCode = KILL_EXIT_CODE;
     if (reconnectTimer) {
@@ -1113,7 +1345,7 @@ const handleLocalShortcut = (input: string) => {
   }
 
   // Ctrl+G to detach
-  if (input === "\x07") {
+  if (ctrlShortcutsReady && input === "\x07") {
     shouldReconnect = false;
     exitCode = DETACH_EXIT_CODE;
     if (reconnectTimer) {
@@ -1128,7 +1360,7 @@ const handleLocalShortcut = (input: string) => {
   }
 
   // Ctrl+T toggles hint bar
-  if (input === "\x14") {
+  if (ctrlShortcutsReady && input === "\x14") {
     showHints = !showHints;
     saveConfig({ ...configFile, showHints });
     pushNotice(`Hints ${showHints ? "on" : "off"}`);
@@ -1157,6 +1389,7 @@ const handleLocalShortcut = (input: string) => {
     const step = altKey("K") ? PAN_FAST_STEP : PAN_STEP;
     viewY -= step;
     clampView();
+    userPannedAway = viewY < getMaxViewY();
     scheduleRender();
     return true;
   }
@@ -1164,6 +1397,7 @@ const handleLocalShortcut = (input: string) => {
     const step = altKey("J") ? PAN_FAST_STEP : PAN_STEP;
     viewY += step;
     clampView();
+    userPannedAway = viewY < getMaxViewY();
     scheduleRender();
     return true;
   }
@@ -1213,6 +1447,7 @@ process.stdin.on("data", (data) => {
     applySyncSize();
   }
 
+  userPannedAway = false;
   sendMessage({ type: "input", data: sanitized });
   handleTyping();
 });
@@ -1244,7 +1479,9 @@ process.on("SIGTERM", () => {
 });
 
 process.on("exit", () => {
+  stopDaemonPolling();
   restoreUi();
 });
 
+startDaemonPolling();
 connect();

package/hay/apps/server/src/index.ts

@@ -14,7 +14,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PORT = Number(process.env.PORT ?? 4001);
 const SERVE_WEB = process.env.SERVE_WEB === "true";
 const WEB_DIST_PATH = process.env.WEB_DIST_PATH;
-const CWD = process.env.CWD; // Working directory for PTY sessions
+const CWD = process.env.CWD || process.cwd(); // Working directory for PTY sessions
 
 const app = express();
 app.get("/health", (_req, res) => {
@@ -35,7 +35,7 @@ if (SERVE_WEB && WEB_DIST_PATH) {
 const server = http.createServer(app);
 const wss = new WebSocketServer({ noServer: true });
 
-const rooms = new RoomManager(createPty, CWD);
+const rooms = new RoomManager(createPty);
 
 const toSocketAdapter = (ws: WebSocket) => {
   return {
@@ -81,10 +81,11 @@ wss.on("connection", (ws, req) => {
   const clientId = randomUUID();
   const colorIndex = Math.floor(Math.random() * 1000);
 
+  const cwd = url.searchParams.get("cwd") || CWD;
   const room = rooms.getRoom(roomId, {
     cols: Number.isFinite(cols) ? cols : 80,
     rows: Number.isFinite(rows) ? rows : 24
-  });
+  }, cwd);
 
   room.attachClient(
     {

package/hay/apps/server/src/lib.ts

@@ -79,10 +79,10 @@ export type TermshareServerOptions = {
  * ```
  */
 export function attachTermshare(options: TermshareServerOptions) {
-  const { server, path = "/ws", ptyFactory = createPty, cwd, onConnect, onDisconnect } = options;
+  const { server, path = "/ws", ptyFactory = createPty, cwd = process.cwd(), onConnect, onDisconnect } = options;
 
   const wss = new WebSocketServer({ noServer: true });
-  const rooms = new RoomManager(ptyFactory, cwd);
+  const rooms = new RoomManager(ptyFactory);
 
   const toSocketAdapter = (ws: WebSocket): SocketAdapter => ({
     send: (data: string) => {
@@ -125,10 +125,11 @@ export function attachTermshare(options: TermshareServerOptions) {
     const clientId = randomUUID();
     const colorIndex = Math.floor(Math.random() * 1000);
 
+    const roomCwd = url.searchParams.get("cwd") || cwd;
     const room = rooms.getRoom(roomId, {
       cols: Number.isFinite(cols) ? cols : 80,
       rows: Number.isFinite(rows) ? rows : 24
-    });
+    }, roomCwd);
 
     room.attachClient(
       {

package/hay/apps/server/src/pty.ts

@@ -2,13 +2,20 @@ import os from "node:os";
 import { EventEmitter } from "node:events";
 import pty, { IPty } from "node-pty-prebuilt-multiarch";
 
-export type PtyFactory = (options: {
+export type PtyFactoryOptions = {
   cols: number;
   rows: number;
-  cwd?: string;
-}) => IPty;
+  cwd: string;
+  env?: Record<string, string>;
+  shell?: string;
+};
+
+export type PtyFactory = (options: PtyFactoryOptions) => IPty;
 
-const resolveShell = () => {
+const resolveShell = (shellOverride?: string) => {
+  if (shellOverride) {
+    return shellOverride;
+  }
   if (process.env.SHELL) {
     return process.env.SHELL;
   }
@@ -18,7 +25,7 @@ const resolveShell = () => {
   return "/bin/bash";
 };
 
-export const createPty: PtyFactory = ({ cols, rows, cwd }) => {
+export const createPty: PtyFactory = ({ cols, rows, cwd, env: envOverrides, shell }) => {
   const mode = process.env.PTY_MODE ?? "native";
   if (mode === "mock") {
     return createMockPty();
@@ -30,14 +37,20 @@ export const createPty: PtyFactory = ({ cols, rows, cwd }) => {
         env[key] = value;
       }
     }
+    if (envOverrides && typeof envOverrides === "object") {
+      for (const [key, value] of Object.entries(envOverrides)) {
+        if (!key || typeof value !== "string") continue;
+        env[key] = value;
+      }
+    }
     env.TERM = "xterm-256color";
     if (!env.COLORTERM) {
       env.COLORTERM = "truecolor";
     }
-    return pty.spawn(resolveShell(), [], {
+    return pty.spawn(resolveShell(shell), [], {
       cols,
       rows,
-      cwd: cwd ?? process.cwd(),
+      cwd,
       env
     });
   } catch (error) {