hop2 0.8.0

package/hay/apps/cli/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}

package/hay/apps/server/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "hay-server",
+  "version": "0.8.0",
+  "type": "module",
+  "private": true,
+  "main": "./dist/lib.js",
+  "types": "./dist/lib.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/lib.js",
+      "types": "./dist/lib.d.ts"
+    },
+    "./standalone": {
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsup src/lib.ts src/index.ts --format esm --dts",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "hay-shared": "*",
+    "express": "^4.21.2",
+    "node-pty-prebuilt-multiarch": "^0.10.1-pre.5",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.10.5",
+    "@types/ws": "^8.5.12",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  }
+}

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

@@ -0,0 +1,103 @@
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import express from "express";
+import { WebSocketServer } from "ws";
+import type { WebSocket } from "ws";
+import { createPty } from "./pty";
+import { RoomManager } from "./rooms";
+import { sanitizeName, sanitizeRoom } from "./utils";
+
+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 app = express();
+app.get("/health", (_req, res) => {
+  res.json({ ok: true });
+});
+
+if (SERVE_WEB && WEB_DIST_PATH) {
+  const distPath = path.isAbsolute(WEB_DIST_PATH)
+    ? WEB_DIST_PATH
+    : path.resolve(__dirname, WEB_DIST_PATH);
+
+  app.use(express.static(distPath));
+  app.get("*", (_req, res) => {
+    res.sendFile(path.join(distPath, "index.html"));
+  });
+}
+
+const server = http.createServer(app);
+const wss = new WebSocketServer({ noServer: true });
+
+const rooms = new RoomManager(createPty, CWD);
+
+const toSocketAdapter = (ws: WebSocket) => {
+  return {
+    send: (data: string) => {
+      if (ws.readyState === ws.OPEN) {
+        ws.send(data);
+      }
+    },
+    onMessage: (handler: (data: string) => void) => {
+      ws.on("message", (data) => handler(data.toString()));
+    },
+    onClose: (handler: () => void) => {
+      ws.on("close", handler);
+    },
+    onError: (handler: (err: Error) => void) => {
+      ws.on("error", handler);
+    },
+    close: () => {
+      ws.close();
+    },
+    isOpen: () => ws.readyState === ws.OPEN
+  };
+};
+
+server.on("upgrade", (req, socket, head) => {
+  const url = new URL(req.url ?? "", `http://${req.headers.host ?? "localhost"}`);
+  if (url.pathname !== "/ws") {
+    socket.destroy();
+    return;
+  }
+  wss.handleUpgrade(req, socket, head, (ws) => {
+    wss.emit("connection", ws, req);
+  });
+});
+
+wss.on("connection", (ws, req) => {
+  const url = new URL(req.url ?? "", `http://${req.headers.host ?? "localhost"}`);
+  const roomId = sanitizeRoom(url.searchParams.get("room"));
+  const name = sanitizeName(url.searchParams.get("name"));
+  const cols = Number(url.searchParams.get("cols") ?? 80);
+  const rows = Number(url.searchParams.get("rows") ?? 24);
+
+  const clientId = randomUUID();
+  const colorIndex = Math.floor(Math.random() * 1000);
+
+  const room = rooms.getRoom(roomId, {
+    cols: Number.isFinite(cols) ? cols : 80,
+    rows: Number.isFinite(rows) ? rows : 24
+  });
+
+  room.attachClient(
+    {
+      id: clientId,
+      name,
+      colorIndex,
+      cols,
+      rows
+    },
+    toSocketAdapter(ws)
+  );
+});
+
+server.listen(PORT, () => {
+  console.log(`Termshare server running on http://localhost:${PORT}`);
+});

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

@@ -0,0 +1,161 @@
+// Termshare Server Library
+// Export everything needed for embedding into other apps
+
+export { Room, RoomManager, type SocketAdapter, type ClientInfo } from "./rooms";
+export { createPty, type PtyFactory } from "./pty";
+export { sanitizeName, sanitizeRoom } from "./utils";
+
+// Re-export shared types
+export {
+  type ClientMessage,
+  type ServerMessage,
+  type PresenceClient,
+  safeParseClientMessage,
+  safeParseServerMessage,
+  pickPresenceColor
+} from "hay-shared";
+
+import http from "node:http";
+import { randomUUID } from "node:crypto";
+import { WebSocketServer } from "ws";
+import type { WebSocket } from "ws";
+import { RoomManager, type SocketAdapter } from "./rooms";
+import { createPty, type PtyFactory } from "./pty";
+import { sanitizeName, sanitizeRoom } from "./utils";
+
+export const generateClientId = () => randomUUID();
+
+export const createSocketAdapter = (ws: WebSocket): SocketAdapter => ({
+  send: (data: string) => {
+    if (ws.readyState === ws.OPEN) {
+      ws.send(data);
+    }
+  },
+  onMessage: (handler: (data: string) => void) => {
+    ws.on("message", (data) => handler(data.toString()));
+  },
+  onClose: (handler: () => void) => {
+    ws.on("close", handler);
+  },
+  onError: (handler: (err: Error) => void) => {
+    ws.on("error", handler);
+  },
+  close: () => {
+    ws.close();
+  },
+  isOpen: () => ws.readyState === ws.OPEN
+});
+
+export type TermshareServerOptions = {
+  /** HTTP server to attach WebSocket to */
+  server: http.Server;
+  /** WebSocket path (default: "/ws") */
+  path?: string;
+  /** Custom PTY factory (default: native pty) */
+  ptyFactory?: PtyFactory;
+  /** Working directory for new PTY sessions (default: process.cwd()) */
+  cwd?: string;
+  /** Called when a client connects */
+  onConnect?: (clientId: string, roomId: string, name: string) => void;
+  /** Called when a client disconnects */
+  onDisconnect?: (clientId: string, roomId: string) => void;
+};
+
+/**
+ * Attach termshare to an existing HTTP server.
+ * This is the main entry point for embedding termshare into other apps.
+ *
+ * @example
+ * ```ts
+ * import http from "http";
+ * import { attachTermshare } from "@termshare/server";
+ *
+ * const server = http.createServer();
+ * const termshare = attachTermshare({ server });
+ *
+ * server.listen(4001, () => {
+ *   console.log("Server running on http://localhost:4001");
+ * });
+ * ```
+ */
+export function attachTermshare(options: TermshareServerOptions) {
+  const { server, path = "/ws", ptyFactory = createPty, cwd, onConnect, onDisconnect } = options;
+
+  const wss = new WebSocketServer({ noServer: true });
+  const rooms = new RoomManager(ptyFactory, cwd);
+
+  const toSocketAdapter = (ws: WebSocket): SocketAdapter => ({
+    send: (data: string) => {
+      if (ws.readyState === ws.OPEN) {
+        ws.send(data);
+      }
+    },
+    onMessage: (handler: (data: string) => void) => {
+      ws.on("message", (data) => handler(data.toString()));
+    },
+    onClose: (handler: () => void) => {
+      ws.on("close", handler);
+    },
+    onError: (handler: (err: Error) => void) => {
+      ws.on("error", handler);
+    },
+    close: () => {
+      ws.close();
+    },
+    isOpen: () => ws.readyState === ws.OPEN
+  });
+
+  server.on("upgrade", (req, socket, head) => {
+    const url = new URL(req.url ?? "", `http://${req.headers.host ?? "localhost"}`);
+    if (url.pathname !== path) {
+      return; // Let other handlers deal with it
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req);
+    });
+  });
+
+  wss.on("connection", (ws, req) => {
+    const url = new URL(req.url ?? "", `http://${req.headers.host ?? "localhost"}`);
+    const roomId = sanitizeRoom(url.searchParams.get("room"));
+    const name = sanitizeName(url.searchParams.get("name"));
+    const cols = Number(url.searchParams.get("cols") ?? 80);
+    const rows = Number(url.searchParams.get("rows") ?? 24);
+
+    const clientId = randomUUID();
+    const colorIndex = Math.floor(Math.random() * 1000);
+
+    const room = rooms.getRoom(roomId, {
+      cols: Number.isFinite(cols) ? cols : 80,
+      rows: Number.isFinite(rows) ? rows : 24
+    });
+
+    room.attachClient(
+      {
+        id: clientId,
+        name,
+        colorIndex,
+        cols,
+        rows
+      },
+      toSocketAdapter(ws)
+    );
+
+    onConnect?.(clientId, roomId, name);
+
+    ws.on("close", () => {
+      onDisconnect?.(clientId, roomId);
+    });
+  });
+
+  return {
+    /** The WebSocket server instance */
+    wss,
+    /** The room manager instance */
+    rooms,
+    /** Close all connections and clean up */
+    close: () => {
+      wss.close();
+    }
+  };
+}

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

@@ -0,0 +1,68 @@
+import os from "node:os";
+import { EventEmitter } from "node:events";
+import pty, { IPty } from "node-pty-prebuilt-multiarch";
+
+export type PtyFactory = (options: {
+  cols: number;
+  rows: number;
+  cwd?: string;
+}) => IPty;
+
+const resolveShell = () => {
+  if (process.env.SHELL) {
+    return process.env.SHELL;
+  }
+  if (os.platform() === "win32") {
+    return process.env.COMSPEC ?? "cmd.exe";
+  }
+  return "/bin/bash";
+};
+
+export const createPty: PtyFactory = ({ cols, rows, cwd }) => {
+  const mode = process.env.PTY_MODE ?? "native";
+  if (mode === "mock") {
+    return createMockPty();
+  }
+  try {
+    const env: Record<string, string> = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (typeof value === "string") {
+        env[key] = value;
+      }
+    }
+    env.TERM = "xterm-256color";
+    if (!env.COLORTERM) {
+      env.COLORTERM = "truecolor";
+    }
+    return pty.spawn(resolveShell(), [], {
+      cols,
+      rows,
+      cwd: cwd ?? process.cwd(),
+      env
+    });
+  } catch (error) {
+    if (mode === "auto") {
+      return createMockPty();
+    }
+    throw error;
+  }
+};
+
+const createMockPty = (): IPty => {
+  const emitter = new EventEmitter();
+  return {
+    onData: (handler: (data: string) => void) => {
+      emitter.on("data", handler);
+      return {
+        dispose: () => emitter.off("data", handler)
+      };
+    },
+    write: (data: string) => {
+      const echo = data.replace(/\r/g, "\r\n");
+      setTimeout(() => emitter.emit("data", echo), 10);
+    },
+    resize: () => {},
+    kill: () => {},
+    onExit: () => ({ dispose: () => {} })
+  } as unknown as IPty;
+};