hop2 0.9.0 → 0.10.0

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) {

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

@@ -1,4 +1,6 @@
 import { EventEmitter } from "node:events";
+import { execFile } from "node:child_process";
+import { readlink } from "node:fs";
 import type { IPty } from "node-pty-prebuilt-multiarch";
 import { pickPresenceColor, safeParseClientMessage } from "hay-shared";
 import type { ClientMessage, PresenceClient, ServerMessage } from "hay-shared";
@@ -21,6 +23,19 @@ export type ClientInfo = {
   rows: number;
 };
 
+export type RoomCreateOptions = {
+  cwd: string;
+  env?: Record<string, string>;
+  shell?: string;
+};
+
+export type RoomSummary = {
+  id: string;
+  cwd: string;
+  liveCwd: string;
+  clientCount: number;
+};
+
 const MAX_BUFFER_SIZE = 200_000;
 // Keep rooms alive indefinitely; only explicit kill/remove should end a session.
 const CLEANUP_DELAY_MS = 0;
@@ -67,6 +82,8 @@ class ClientState {
 export class Room extends EventEmitter {
   id: string;
   private pty: IPty;
+  private readonly initialCwd: string;
+  private liveCwd: string;
   private clients = new Map<string, ClientState>();
   private collabMode = true;
   private controllerId: string | null = null;
@@ -77,13 +94,23 @@ export class Room extends EventEmitter {
   private alternateScreen = false;
   private cursorHidden = false;
   private controlSequenceTail = "";
+  private oscBuffer = "";
   private cleanupTimer: NodeJS.Timeout | null = null;
   private ended = false;
+  private cwdPollTimer: NodeJS.Timeout | null = null;
 
-  constructor(id: string, ptyFactory: PtyFactory, initialSize: { cols: number; rows: number }, cwd?: string) {
+  constructor(id: string, ptyFactory: PtyFactory, initialSize: { cols: number; rows: number }, options: RoomCreateOptions) {
     super();
     this.id = id;
-    this.pty = ptyFactory({ cols: initialSize.cols, rows: initialSize.rows, cwd });
+    this.initialCwd = options.cwd;
+    this.liveCwd = options.cwd;
+    this.pty = ptyFactory({
+      cols: initialSize.cols,
+      rows: initialSize.rows,
+      cwd: options.cwd,
+      env: options.env,
+      shell: options.shell
+    });
     this.activeCols = initialSize.cols;
     this.activeRows = initialSize.rows;
 
@@ -91,6 +118,7 @@ export class Room extends EventEmitter {
       this.outputBuffer = clampBuffer(this.outputBuffer + data);
       this.updateTerminalState(data);
       this.broadcast({ type: "output", data });
+      this.emit("pty_output", { roomId: this.id, data, timestamp: now() });
     });
 
     const handleExit = (exitCode?: number | null, signal?: number | string) => {
@@ -118,6 +146,9 @@ export class Room extends EventEmitter {
         handleExit(exitCode, signal);
       });
     }
+
+    // Start PID-based cwd polling as fallback for shells without OSC 7
+    this.startCwdPolling();
   }
 
   attachClient(info: ClientInfo, socket: SocketAdapter) {
@@ -158,6 +189,12 @@ export class Room extends EventEmitter {
       } satisfies ServerMessage));
     }
 
+    // Send current cwd to the new client
+    socket.send(JSON.stringify({
+      type: "cwd_changed",
+      cwd: this.liveCwd
+    } satisfies ServerMessage));
+
     this.broadcastPresence();
 
     socket.onMessage((payload) => {
@@ -226,6 +263,8 @@ export class Room extends EventEmitter {
 
   private updateTerminalState(data: string) {
     const combined = this.controlSequenceTail + data;
+
+    // Parse CSI mode sequences (cursor visibility, alternate screen)
     const regex = /\x1b\[\?([0-9;]*)([hl])/g;
     let match: RegExpExecArray | null;
     let nextAlternate = this.alternateScreen;
@@ -243,31 +282,177 @@ export class Room extends EventEmitter {
       }
     }
 
+    let stateChanged = false;
     if (nextAlternate !== this.alternateScreen) {
       if (DEBUG_STATE) {
         console.log(`[hay] room=${this.id} alternateScreen=${nextAlternate}`);
       }
       this.alternateScreen = nextAlternate;
+      stateChanged = true;
     }
     if (nextCursorHidden !== this.cursorHidden) {
       if (DEBUG_STATE) {
         console.log(`[hay] room=${this.id} cursorHidden=${nextCursorHidden}`);
       }
       this.cursorHidden = nextCursorHidden;
+      stateChanged = true;
+    }
+
+    if (stateChanged) {
+      this.emit("pty_state", {
+        roomId: this.id,
+        alternateScreen: this.alternateScreen,
+        cursorHidden: this.cursorHidden,
+        timestamp: now()
+      });
+    }
+
+    // Parse OSC 7 — only scan when ESC is present (fast path: skip most data chunks)
+    if (data.includes("\x1b]7;") || this.oscBuffer) {
+      this.parseOsc7(data);
     }
 
     this.controlSequenceTail = combined.slice(-CONTROL_SEQUENCE_TAIL);
   }
 
+  // Regex: matches OSC 7 with BEL (\x07) or ST (\x1b\\) terminator
+  private static readonly OSC7_RE = /\x1b\]7;([^\x07\x1b]*?)(?:\x07|\x1b\\)/g;
+
+  private parseOsc7(data: string) {
+    const chunk = this.oscBuffer + data;
+    this.oscBuffer = "";
+
+    // Fast regex scan — no allocations when there's no match
+    Room.OSC7_RE.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = Room.OSC7_RE.exec(chunk)) !== null) {
+      this.handleOsc7Uri(match[1]);
+    }
+
+    // Check for a partial OSC 7 at the end of the chunk (split across packets)
+    const tailIdx = chunk.lastIndexOf("\x1b]7;");
+    if (tailIdx !== -1) {
+      const tail = chunk.slice(tailIdx);
+      // If the regex didn't consume this position, it's incomplete
+      if (tail.indexOf("\x07") === -1 && tail.indexOf("\x1b\\") === -1 && tail.length < 512) {
+        this.oscBuffer = tail;
+      }
+    }
+  }
+
+  private handleOsc7Uri(uri: string) {
+    // Parse file://hostname/path URI
+    try {
+      let cwdPath: string;
+      if (uri.startsWith("file://")) {
+        // Extract path portion, skipping hostname
+        const withoutScheme = uri.slice(7);
+        const slashIdx = withoutScheme.indexOf("/");
+        if (slashIdx === -1) return;
+        cwdPath = decodeURIComponent(withoutScheme.slice(slashIdx));
+      } else if (uri.startsWith("/")) {
+        cwdPath = decodeURIComponent(uri);
+      } else {
+        return;
+      }
+
+      if (cwdPath && cwdPath !== this.liveCwd) {
+        if (DEBUG_STATE) {
+          console.log(`[hay] room=${this.id} cwd=${cwdPath}`);
+        }
+        this.liveCwd = cwdPath;
+        this.broadcast({ type: "cwd_changed", cwd: cwdPath });
+        this.emit("cwd_changed", { roomId: this.id, cwd: cwdPath, timestamp: now() });
+      }
+    } catch {
+      // Malformed URI — ignore
+    }
+  }
+
+  /**
+   * Start polling PID-based cwd as fallback for shells that don't emit OSC 7.
+   * Uses a long interval to avoid system overhead (lsof is expensive on macOS).
+   * OSC 7 parsing is the primary mechanism; this is a best-effort fallback.
+   */
+  startCwdPolling(intervalMs = 15000) {
+    this.stopCwdPolling();
+    const pid = (this.pty as unknown as { pid?: number }).pid;
+    if (!pid) return;
+
+    const updateCwd = (cwdPath: string) => {
+      if (cwdPath && cwdPath !== this.liveCwd) {
+        if (DEBUG_STATE) {
+          console.log(`[hay] room=${this.id} cwd(poll)=${cwdPath}`);
+        }
+        this.liveCwd = cwdPath;
+        this.broadcast({ type: "cwd_changed", cwd: cwdPath });
+        this.emit("cwd_changed", { roomId: this.id, cwd: cwdPath, timestamp: now() });
+      }
+    };
+
+    const poll = () => {
+      if (this.ended) return;
+      if (process.platform === "darwin") {
+        execFile("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], { timeout: 5000 }, (err, stdout) => {
+          if (err || !stdout) return;
+          for (const line of stdout.split("\n")) {
+            if (line.startsWith("n/")) {
+              updateCwd(line.slice(1));
+              break;
+            }
+          }
+        });
+      } else if (process.platform === "linux") {
+        readlink(`/proc/${pid}/cwd`, (err, target) => {
+          if (err || !target) return;
+          updateCwd(target);
+        });
+      }
+    };
+
+    this.cwdPollTimer = setInterval(poll, intervalMs);
+    // Initial poll with a generous delay to not interfere with startup
+    setTimeout(poll, 3000);
+  }
+
+  stopCwdPolling() {
+    if (this.cwdPollTimer) {
+      clearInterval(this.cwdPollTimer);
+      this.cwdPollTimer = null;
+    }
+  }
+
   kill() {
+    this.stopCwdPolling();
     if (this.cleanupTimer) {
       clearTimeout(this.cleanupTimer);
       this.cleanupTimer = null;
     }
-    this.pty.kill();
+    try {
+      this.pty.kill();
+    } catch (e) {
+      /* swallow – PTY may already be dead */
+    }
     this.endSession({ exitCode: null, signal: null, message: "Session terminated" });
   }
 
+  notifySessionRenamed(displayName: string) {
+    this.broadcast({ type: "session_renamed", displayName });
+  }
+
+  sendSystemInput(data: string, source = "system") {
+    if (!data) return;
+    this.pty.write(data);
+    this.emit("pty_input", {
+      roomId: this.id,
+      clientId: null,
+      actor: "system",
+      source,
+      data,
+      timestamp: now()
+    });
+  }
+
   private handleInput(client: ClientState, data: string) {
     if (!this.collabMode && this.controllerId !== client.id) {
       client.socket.send(
@@ -277,6 +462,7 @@ export class Room extends EventEmitter {
     }
     client.lastActive = now();
     this.pty.write(data);
+    this.emit("pty_input", { roomId: this.id, clientId: client.id, data, timestamp: now() });
   }
 
   private handleResize(client: ClientState, cols: number, rows: number) {
@@ -297,6 +483,7 @@ export class Room extends EventEmitter {
       this.activeClientId = client.id;
       // Broadcast the new active size to other clients so they can adjust
       this.broadcastActiveSize(client);
+      this.emit("pty_resize", { roomId: this.id, clientId: client.id, cols, rows, timestamp: now() });
     }
   }
 
@@ -363,38 +550,57 @@ export class Room extends EventEmitter {
   private endSession(payload: { exitCode: number | null; signal: string | null; message: string }) {
     if (this.ended) return;
     this.ended = true;
+    this.stopCwdPolling();
     if (this.cleanupTimer) {
       clearTimeout(this.cleanupTimer);
       this.cleanupTimer = null;
     }
     const message = JSON.stringify({ type: "session_ended", ...payload } satisfies ServerMessage);
     for (const client of this.clients.values()) {
-      if (client.socket.isOpen()) {
-        client.socket.send(message);
+      try {
+        if (client.socket.isOpen()) {
+          client.socket.send(message);
+        }
+        client.socket.close();
+      } catch (e) {
+        /* swallow – don't let one bad socket kill the loop */
       }
-      client.socket.close();
     }
     this.clients.clear();
+    this.emit("session_end", { roomId: this.id, ...payload, timestamp: now() });
     this.emit("empty");
   }
+
+  getSummary(): RoomSummary {
+    return {
+      id: this.id,
+      cwd: this.initialCwd,
+      liveCwd: this.liveCwd,
+      clientCount: this.clients.size
+    };
+  }
 }
 
 export class RoomManager {
   private rooms = new Map<string, Room>();
   private ptyFactory: PtyFactory;
-  private cwd?: string;
 
-  constructor(ptyFactory: PtyFactory, cwd?: string) {
+  constructor(ptyFactory: PtyFactory) {
     this.ptyFactory = ptyFactory;
-    this.cwd = cwd;
   }
 
-  getRoom(roomId: string, initialSize: { cols: number; rows: number }, cwd?: string) {
+  getRoom(roomId: string, initialSize: { cols: number; rows: number }, cwdOrOptions: string | RoomCreateOptions) {
     const existing = this.rooms.get(roomId);
     if (existing) {
       return existing;
     }
-    const room = new Room(roomId, this.ptyFactory, initialSize, cwd ?? this.cwd);
+    const options = typeof cwdOrOptions === "string"
+      ? { cwd: cwdOrOptions }
+      : cwdOrOptions;
+    if (!options.cwd) {
+      throw new Error(`[RoomManager] cwd is required when creating room "${roomId}"`);
+    }
+    const room = new Room(roomId, this.ptyFactory, initialSize, options);
     room.on("empty", () => {
       this.rooms.delete(roomId);
     });
@@ -409,7 +615,11 @@ export class RoomManager {
   closeRoom(roomId: string) {
     const room = this.rooms.get(roomId);
     if (!room) return;
-    room.kill();
+    try {
+      room.kill();
+    } catch (e) {
+      /* swallow – ensure we still remove the room from the map */
+    }
     this.rooms.delete(roomId);
   }
 
@@ -418,4 +628,8 @@ export class RoomManager {
       this.closeRoom(roomId);
     }
   }
+
+  listRooms(): RoomSummary[] {
+    return Array.from(this.rooms.values()).map((room) => room.getSummary());
+  }
 }

package/hay/apps/server/test/rooms.test.ts

@@ -81,6 +81,25 @@ const findMessages = (socket: FakeSocket, type: string) => {
 };
 
 describe("Room", () => {
+  it("passes room create options to the PTY factory", () => {
+    let capturedOptions: any = null;
+    const factory: PtyFactory = (options) => {
+      capturedOptions = options;
+      return new FakePty() as any;
+    };
+
+    const manager = new RoomManager(factory);
+    manager.getRoom("opts", { cols: 80, rows: 24 }, {
+      cwd: "/tmp/demo",
+      env: { HISTFILE: "/tmp/.history" },
+      shell: "/bin/zsh",
+    });
+
+    expect(capturedOptions?.cwd).toBe("/tmp/demo");
+    expect(capturedOptions?.env?.HISTFILE).toBe("/tmp/.history");
+    expect(capturedOptions?.shell).toBe("/bin/zsh");
+  });
+
   it("broadcasts pty output to all clients", () => {
     let ptyInstance: FakePty | null = null;
     const factory: PtyFactory = () => {
@@ -89,7 +108,7 @@ describe("Room", () => {
     };
 
     const manager = new RoomManager(factory);
-    const room = manager.getRoom("alpha", { cols: 80, rows: 24 });
+    const room = manager.getRoom("alpha", { cols: 80, rows: 24 }, "/tmp");
     const socketA = new FakeSocket();
     const socketB = new FakeSocket();
 
@@ -113,7 +132,7 @@ describe("Room", () => {
     };
 
     const manager = new RoomManager(factory);
-    const room = manager.getRoom("bravo", { cols: 80, rows: 24 });
+    const room = manager.getRoom("bravo", { cols: 80, rows: 24 }, "/tmp");
     const socketA = new FakeSocket();
     const socketB = new FakeSocket();
 
@@ -130,7 +149,7 @@ describe("Room", () => {
 
   it("updates presence on disconnect", () => {
     const manager = new RoomManager(() => new FakePty() as any);
-    const room = manager.getRoom("charlie", { cols: 80, rows: 24 });
+    const room = manager.getRoom("charlie", { cols: 80, rows: 24 }, "/tmp");
     const socketA = new FakeSocket();
     const socketB = new FakeSocket();
 
@@ -143,4 +162,64 @@ describe("Room", () => {
     const latest = presenceMessages.at(-1) as any;
     expect(latest?.clients).toHaveLength(1);
   });
+
+  it("emits room PTY lifecycle events for embedding servers", () => {
+    let ptyInstance: FakePty | null = null;
+    const factory: PtyFactory = () => {
+      ptyInstance = new FakePty() as unknown as FakePty;
+      return ptyInstance as any;
+    };
+
+    const manager = new RoomManager(factory);
+    const room = manager.getRoom("events", { cols: 80, rows: 24 }, "/tmp");
+    const socket = new FakeSocket();
+    room.attachClient({ id: "a", name: "Alex", colorIndex: 0, cols: 80, rows: 24 }, socket);
+
+    const inputs: any[] = [];
+    const outputs: any[] = [];
+    const resizes: any[] = [];
+    const states: any[] = [];
+    const ends: any[] = [];
+    room.on("pty_input", (payload) => inputs.push(payload));
+    room.on("pty_output", (payload) => outputs.push(payload));
+    room.on("pty_resize", (payload) => resizes.push(payload));
+    room.on("pty_state", (payload) => states.push(payload));
+    room.on("session_end", (payload) => ends.push(payload));
+
+    socket.emitMessage({ type: "input", data: "pwd\n" });
+    ptyInstance?.emit("ok\n");
+    ptyInstance?.emit("\x1b[?1049h");
+    ptyInstance?.emit("\x1b[?1049l");
+    socket.emitMessage({ type: "resize", cols: 100, rows: 30 });
+    room.kill();
+
+    expect(inputs.at(-1)?.clientId).toBe("a");
+    expect(inputs.at(-1)?.data).toBe("pwd\n");
+    expect(outputs.some((payload) => payload?.data === "ok\n")).toBe(true);
+    expect(resizes.at(-1)?.cols).toBe(100);
+    expect(resizes.at(-1)?.rows).toBe(30);
+    expect(states.at(0)?.alternateScreen).toBe(true);
+    expect(states.at(1)?.alternateScreen).toBe(false);
+    expect(ends.at(-1)?.message).toBe("Session terminated");
+  });
+
+  it("supports system input writes for host-level session setup", () => {
+    let ptyInstance: FakePty | null = null;
+    const factory: PtyFactory = () => {
+      ptyInstance = new FakePty() as unknown as FakePty;
+      return ptyInstance as any;
+    };
+
+    const manager = new RoomManager(factory);
+    const room = manager.getRoom("system", { cols: 80, rows: 24 }, "/tmp");
+    const inputs: any[] = [];
+    room.on("pty_input", (payload) => inputs.push(payload));
+
+    room.sendSystemInput("export HISTFILE=/tmp/demo.history\\n", "hop");
+
+    expect(ptyInstance?.writes.at(-1)).toBe("export HISTFILE=/tmp/demo.history\\n");
+    expect(inputs.at(-1)?.actor).toBe("system");
+    expect(inputs.at(-1)?.source).toBe("hop");
+    expect(inputs.at(-1)?.clientId).toBe(null);
+  });
 });