npm - webtty - Versions diffs - 0.0.0-development → 1.1.0 - Mend

webtty 0.0.0-development → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/server/index.js ADDED Viewed

@@ -0,0 +1,680 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+// src/pty/bun.ts
+var exports_bun = {};
+__export(exports_bun, {
+  spawn: () => spawn
+});
+import { homedir } from "node:os";
+function spawn(shell, cols, rows) {
+  let onDataCb;
+  let onExitCb;
+  const proc = Bun.spawn([shell], {
+    terminal: {
+      cols,
+      rows,
+      data(_term, data) {
+        onDataCb?.(Buffer.from(data).toString("utf8"));
+      }
+    },
+    cwd: homedir(),
+    env: { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor" }
+  });
+  proc.exited.then((exitCode) => {
+    onExitCb?.({ exitCode: exitCode ?? 0 });
+  });
+  return {
+    onData(cb) {
+      onDataCb = cb;
+    },
+    onExit(cb) {
+      onExitCb = cb;
+    },
+    write(data) {
+      proc.terminal?.write(data);
+    },
+    resize(cols2, rows2) {
+      proc.terminal?.resize(cols2, rows2);
+    },
+    kill() {
+      proc.kill();
+    }
+  };
+}
+var init_bun = () => {};
+// src/pty/node.ts
+var exports_node = {};
+__export(exports_node, {
+  spawn: () => spawn2
+});
+import { homedir as homedir2 } from "node:os";
+import nodePty from "@lydell/node-pty";
+function spawn2(shell, cols, rows) {
+  const ptyProc = nodePty.spawn(shell, [], {
+    name: "xterm-256color",
+    cols,
+    rows,
+    cwd: homedir2(),
+    env: { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor" }
+  });
+  return {
+    onData(cb) {
+      ptyProc.onData(cb);
+    },
+    onExit(cb) {
+      ptyProc.onExit(cb);
+    },
+    write(data) {
+      ptyProc.write(data);
+    },
+    resize(cols2, rows2) {
+      ptyProc.resize(cols2, rows2);
+    },
+    kill() {
+      ptyProc.kill();
+    }
+  };
+}
+var init_node = () => {};
+// src/server/index.ts
+import http from "node:http";
+// src/server/routes.ts
+import path3 from "node:path";
+// src/server/client.ts
+function render(sessionId) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>webtty — ${sessionId}</title>
+    <style>
+      * { margin: 0; padding: 0; box-sizing: border-box; }
+      html, body, #terminal { width: 100%; height: 100%; overflow: hidden; background: #282A36; }
+      #terminal canvas { display: block; }
+    </style>
+  </head>
+  <body>
+    <div id="terminal"></div>
+    <script type="module">
+      import { init, Terminal, FitAddon } from '/dist/ghostty-web.js';
+      await init();
+      const term = new Terminal({
+        cols: 80,
+        rows: 24,
+        cursorBlink: true,
+        fontSize: 14,
+        fontFamily: "'FiraMono Nerd Font', Menlo, Monaco, 'Courier New', monospace",
+        scrollback: 10000,
+        theme: {
+          background:   '#282A36',
+          foreground:   '#F8F8F2',
+          cursor:       '#F8F8F2',
+          selection:    '#44475A',
+          black:        '#21222C',
+          red:          '#FF5555',
+          green:        '#50FA7B',
+          yellow:       '#F1FA8C',
+          blue:         '#BD93F9',
+          purple:       '#FF79C6',
+          cyan:         '#8BE9FD',
+          white:        '#F8F8F2',
+          brightBlack:  '#6272A4',
+          brightRed:    '#FF6E6E',
+          brightGreen:  '#69FF94',
+          brightYellow: '#FFFFA5',
+          brightBlue:   '#D6ACFF',
+          brightPurple: '#FF92DF',
+          brightCyan:   '#A4FFFF',
+          brightWhite:  '#FFFFFF',
+        },
+      });
+      const fitAddon = new FitAddon();
+      term.loadAddon(fitAddon);
+      const container = document.getElementById('terminal');
+      await term.open(container);
+      fitAddon.fit();
+      fitAddon.observeResize();
+      const sessionId = ${JSON.stringify(sessionId)};
+      const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+      let ws;
+      function connect() {
+        const wsUrl = protocol + '//' + window.location.host + '/ws/' + sessionId + '?cols=' + term.cols + '&rows=' + term.rows;
+        ws = new WebSocket(wsUrl);
+        ws.onopen = () => {
+          console.log('[webtty] connected to session ' + sessionId);
+          ws.send(JSON.stringify({ type: 'resize', cols: term.cols, rows: term.rows }));
+        };
+        ws.onmessage = (event) => {
+          term.write(event.data);
+        };
+        ws.onclose = (event) => {
+          if (event.code === 4001) {
+            term.write('\\r\\n\\x1b[31mSession removed.\\x1b[0m\\r\\n');
+            setTimeout(() => window.close(), 500);
+            return;
+          }
+          console.log('[webtty] disconnected, reconnecting in 2s...');
+          term.write('\\r\\n\\x1b[31mConnection closed. Reconnecting in 2s...\\x1b[0m\\r\\n');
+          setTimeout(connect, 2000);
+        };
+        ws.onerror = () => {
+          console.error('[webtty] websocket error');
+        };
+      }
+      connect();
+      term.onData((data) => {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.send(data);
+        }
+      });
+      term.onResize(({ cols, rows }) => {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'resize', cols, rows }));
+        }
+      });
+      window.addEventListener('resize', () => {
+        fitAddon.fit();
+      });
+    </script>
+  </body>
+</html>`;
+}
+// src/server/session.ts
+var SCROLLBACK_MAX = 256 * 1024;
+var sessionRegistry = new Map;
+var lastUsedId = null;
+function setLastUsedId(id) {
+  lastUsedId = id;
+}
+var ID_RE = /^[a-z0-9\-_.]{1,64}$/;
+function isValidId(id) {
+  return ID_RE.test(id);
+}
+function generateId() {
+  return Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0");
+}
+function createSession(id) {
+  const session = {
+    id,
+    createdAt: Date.now(),
+    pty: null,
+    clients: new Set,
+    scrollback: ""
+  };
+  sessionRegistry.set(id, session);
+  return session;
+}
+function sessionToJson(s) {
+  return { id: s.id, createdAt: s.createdAt, connected: s.clients.size > 0 };
+}
+// src/server/static.ts
+import fs from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+// src/utils.ts
+import path from "node:path";
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".wasm": "application/wasm",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon"
+};
+function mimeType(filePath) {
+  const ext = path.extname(filePath);
+  return MIME_TYPES[ext] ?? "application/octet-stream";
+}
+function ghosttyWebRootFromMain(mainPath) {
+  return mainPath.replace(/[/\\]dist[/\\].*$/, "");
+}
+// src/server/static.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path2.dirname(__filename2);
+var require2 = createRequire2(import.meta.url);
+function findGhosttyWeb() {
+  try {
+    const ghosttyWebMain = require2.resolve("ghostty-web");
+    const ghosttyWebRoot = ghosttyWebRootFromMain(ghosttyWebMain);
+    const distPath = path2.join(ghosttyWebRoot, "dist");
+    const wasmPath = path2.join(ghosttyWebRoot, "ghostty-vt.wasm");
+    if (fs.existsSync(path2.join(distPath, "ghostty-web.js")) && fs.existsSync(wasmPath)) {
+      return { distPath, wasmPath };
+    }
+  } catch {}
+  console.error("Error: Could not find ghostty-web package.");
+  process.exit(1);
+}
+function serveFile(filePath, res) {
+  const contentType = mimeType(filePath);
+  fs.readFile(filePath, (err, data) => {
+    if (err) {
+      res.writeHead(404);
+      res.end("Not Found");
+      return;
+    }
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(data);
+  });
+}
+// src/server/routes.ts
+var MAX_BODY = 64 * 1024;
+function decodeId(raw) {
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    return null;
+  }
+}
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+      if (body.length > MAX_BODY) {
+        req.destroy();
+        reject(Object.assign(new Error("payload too large"), { status: 413 }));
+      }
+    });
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch {
+        reject(new Error("invalid JSON"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+async function handleRequest(req, res, distPath, wasmPath, onStop) {
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "127.0.0.1"}`);
+  const pathname = url.pathname;
+  if (req.method === "POST" && pathname === "/api/server/stop") {
+    res.writeHead(200, { "Content-Type": "text/plain" });
+    res.end("stopping");
+    onStop();
+    return;
+  }
+  if (pathname === "/api/sessions") {
+    if (req.method === "GET") {
+      const list = [...sessionRegistry.values()].map(sessionToJson);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(list));
+      return;
+    }
+    if (req.method === "POST") {
+      let body;
+      try {
+        body = await readJson(req);
+      } catch (err) {
+        const status = err.status === 413 ? 413 : 400;
+        res.writeHead(status);
+        res.end(status === 413 ? "Payload Too Large" : "invalid JSON");
+        return;
+      }
+      const id = body.id ?? generateId();
+      if (!isValidId(id)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: `invalid id: ${id}` }));
+        return;
+      }
+      if (sessionRegistry.has(id)) {
+        res.writeHead(409, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: `session already exists: ${id}` }));
+        return;
+      }
+      const session = createSession(id);
+      res.writeHead(201, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(sessionToJson(session)));
+      return;
+    }
+  }
+  const sessionMatch = pathname.match(/^\/api\/sessions\/([^/]+)$/);
+  if (sessionMatch) {
+    const id = decodeId(sessionMatch[1]);
+    if (!id) {
+      res.writeHead(400);
+      res.end("Bad Request");
+      return;
+    }
+    if (req.method === "GET") {
+      const session = sessionRegistry.get(id);
+      if (!session) {
+        res.writeHead(404);
+        res.end("Not Found");
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(sessionToJson(session)));
+      return;
+    }
+    if (req.method === "PATCH") {
+      let body;
+      try {
+        body = await readJson(req);
+      } catch (err) {
+        const status = err.status === 413 ? 413 : 400;
+        res.writeHead(status);
+        res.end(status === 413 ? "Payload Too Large" : "invalid JSON");
+        return;
+      }
+      const session = sessionRegistry.get(id);
+      if (!session) {
+        res.writeHead(404);
+        res.end("Not Found");
+        return;
+      }
+      const newId = body.id;
+      if (!newId) {
+        res.writeHead(400);
+        res.end("missing id");
+        return;
+      }
+      if (!isValidId(newId)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: `invalid id: ${newId}` }));
+        return;
+      }
+      if (sessionRegistry.has(newId)) {
+        res.writeHead(409, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: `session already exists: ${newId}` }));
+        return;
+      }
+      sessionRegistry.delete(id);
+      session.id = newId;
+      sessionRegistry.set(newId, session);
+      if (lastUsedId === id)
+        setLastUsedId(newId);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(sessionToJson(session)));
+      return;
+    }
+    if (req.method === "DELETE") {
+      const session = sessionRegistry.get(id);
+      if (!session) {
+        res.writeHead(404);
+        res.end("Not Found");
+        return;
+      }
+      sessionRegistry.delete(id);
+      if (lastUsedId === id)
+        setLastUsedId(null);
+      for (const client of session.clients)
+        client.close(4001, "session deleted");
+      session.pty?.kill();
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+  }
+  if (req.method === "GET" && (pathname === "/" || pathname === "/index.html")) {
+    let targetId = lastUsedId ?? null;
+    if (!targetId || !sessionRegistry.has(targetId)) {
+      if (!sessionRegistry.has("main"))
+        createSession("main");
+      targetId = "main";
+    }
+    res.writeHead(302, { Location: `/s/${targetId}` });
+    res.end();
+    return;
+  }
+  const clientMatch = pathname.match(/^\/s\/([^/]+)$/);
+  if (req.method === "GET" && clientMatch) {
+    const id = decodeId(clientMatch[1]);
+    if (!id || !isValidId(id) || !sessionRegistry.has(id)) {
+      res.writeHead(404);
+      res.end("Not Found");
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(render(id));
+    return;
+  }
+  if (pathname.startsWith("/dist/")) {
+    const filePath = path3.resolve(distPath, pathname.slice(6));
+    if (!filePath.startsWith(path3.resolve(distPath) + path3.sep) && filePath !== path3.resolve(distPath)) {
+      res.writeHead(404);
+      res.end("Not Found");
+      return;
+    }
+    serveFile(filePath, res);
+    return;
+  }
+  if (pathname === "/ghostty-vt.wasm") {
+    serveFile(wasmPath, res);
+    return;
+  }
+  res.writeHead(404);
+  res.end("Not Found");
+}
+// src/server/websocket.ts
+import { WebSocketServer } from "ws";
+// src/pty/index.ts
+var isBun = !!process.versions.bun;
+console.log(`pty: ${isBun ? "Bun.Terminal" : "node-pty"}`);
+var { spawn: _spawn } = await (isBun ? Promise.resolve().then(() => (init_bun(), exports_bun)) : Promise.resolve().then(() => (init_node(), exports_node)));
+function spawnForSession(cols, rows) {
+  const shell = process.platform === "win32" ? process.env.COMSPEC ?? "cmd.exe" : process.env.SHELL ?? "/bin/bash";
+  return _spawn(shell, cols, rows);
+}
+// src/server/websocket.ts
+function createWebSocketServer(httpServer) {
+  const wss = new WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (req, socket, head) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "127.0.0.1"}`);
+    if (url.pathname.match(/^\/ws\/([^/]+)$/)) {
+      wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
+    } else {
+      socket.destroy();
+    }
+  });
+  wss.on("connection", (ws, req) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "127.0.0.1"}`);
+    const wsMatch = url.pathname.match(/^\/ws\/([^/]+)$/);
+    if (!wsMatch) {
+      ws.close();
+      return;
+    }
+    let id;
+    try {
+      id = decodeURIComponent(wsMatch[1]);
+    } catch {
+      ws.close(1008, "Bad Request");
+      return;
+    }
+    const cols = Math.max(1, Math.min(1000, Number.parseInt(url.searchParams.get("cols") ?? "80", 10) || 80));
+    const rows = Math.max(1, Math.min(500, Number.parseInt(url.searchParams.get("rows") ?? "24", 10) || 24));
+    if (!sessionRegistry.has(id)) {
+      ws.close(4001, "session deleted");
+      return;
+    }
+    const session = sessionRegistry.get(id);
+    if (!session) {
+      ws.close(4001, "session deleted");
+      return;
+    }
+    session.clients.add(ws);
+    setLastUsedId(id);
+    if (!session.pty) {
+      session.pty = spawnForSession(cols, rows);
+      session.pty.onData((data) => {
+        session.scrollback = (session.scrollback + data).slice(-SCROLLBACK_MAX);
+        for (const client of session.clients) {
+          if (client.readyState === client.OPEN) {
+            client.send(data, { binary: false });
+          }
+        }
+      });
+      session.pty.onExit(() => {
+        sessionRegistry.delete(session.id);
+        for (const client of session.clients) {
+          if (client.readyState === client.OPEN) {
+            client.close(4001, "shell exited");
+          }
+        }
+        session.pty = null;
+      });
+      const C = "\x1B[1;36m";
+      const G = "\x1B[1;32m";
+      const Y = "\x1B[1;33m";
+      const R = "\x1B[0m";
+      const banner = [
+        `${C}╔══════════════════════════════════════════════════════════════╗${R}\r
+`,
+        `${C}║${R}  ${G}Welcome to webtty!${R}                                          ${C}║${R}\r
+`,
+        `${C}║${R}                                                              ${C}║${R}\r
+`,
+        `${C}║${R}  You have a real shell session with full PTY support.        ${C}║${R}\r
+`,
+        `${C}║${R}  Try: ${Y}ls${R}, ${Y}cd${R}, ${Y}top${R}, ${Y}vim${R}, or any command!                      ${C}║${R}\r
+`,
+        `${C}╚══════════════════════════════════════════════════════════════╝${R}\r
+\r
+`
+      ].join("");
+      ws.send(banner);
+      session.scrollback = banner;
+      session.pty.write(`
+`);
+    } else {
+      if (session.scrollback) {
+        ws.send(session.scrollback, { binary: false });
+      }
+      session.pty.resize(cols, rows);
+    }
+    ws.on("message", (data) => {
+      const message = data.toString("utf8");
+      if (message.startsWith("{")) {
+        try {
+          const msg = JSON.parse(message);
+          if (msg.type === "resize") {
+            const c = Math.max(1, Math.min(1000, Math.trunc(msg.cols) || 80));
+            const r = Math.max(1, Math.min(500, Math.trunc(msg.rows) || 24));
+            session.pty?.resize(c, r);
+            return;
+          }
+        } catch {}
+      }
+      session.pty?.write(message);
+    });
+    ws.on("close", () => {
+      session.clients.delete(ws);
+    });
+    ws.on("error", () => {});
+  });
+  return wss;
+}
+// src/server/index.ts
+var HTTP_PORT = Number(process.env.PORT) || 2346;
+var { distPath, wasmPath } = findGhosttyWeb();
+var httpServer = http.createServer((req, res) => {
+  handleRequest(req, res, distPath, wasmPath, () => {
+    for (const session of sessionRegistry.values()) {
+      session.pty?.kill();
+      for (const client of session.clients)
+        client.close();
+    }
+    wss.close();
+    httpServer.close(() => process.exit(0));
+  });
+});
+var wss = createWebSocketServer(httpServer);
+process.on("SIGINT", () => {
+  console.log(`
+Shutting down...`);
+  for (const session of sessionRegistry.values()) {
+    session.pty?.kill();
+    for (const client of session.clients)
+      client.close();
+  }
+  wss.close();
+  process.exit(0);
+});
+httpServer.listen(HTTP_PORT, "127.0.0.1", () => {
+  console.log(`listening on http://127.0.0.1:${HTTP_PORT}`);
+});
+//# debugId=102CAB57A485E36364756E2164756E21