hop2 0.8.0 → 0.9.1

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

@@ -21,6 +21,18 @@ export type ClientInfo = {
   rows: number;
 };
 
+export type RoomCreateOptions = {
+  cwd: string;
+  env?: Record<string, string>;
+  shell?: string;
+};
+
+export type RoomSummary = {
+  id: string;
+  cwd: 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 +79,7 @@ class ClientState {
 export class Room extends EventEmitter {
   id: string;
   private pty: IPty;
+  private readonly cwd: string;
   private clients = new Map<string, ClientState>();
   private collabMode = true;
   private controllerId: string | null = null;
@@ -80,10 +93,17 @@ export class Room extends EventEmitter {
   private cleanupTimer: NodeJS.Timeout | null = null;
   private ended = false;
 
-  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.cwd = 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 +111,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) => {
@@ -243,17 +264,29 @@ 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()
+      });
     }
 
     this.controlSequenceTail = combined.slice(-CONTROL_SEQUENCE_TAIL);
@@ -264,10 +297,31 @@ export class Room extends EventEmitter {
       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 +331,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 +352,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() });
     }
   }
 
@@ -369,32 +425,49 @@ export class Room extends EventEmitter {
     }
     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.cwd,
+      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 +482,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 +495,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);
+  });
 });