@atolljs/devtools 0.1.7

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { createServer } from "node:http";
+import { existsSync, readFileSync } from "node:fs";
+import { join, normalize, extname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/ws.ts
+import { createHash, randomBytes } from "node:crypto";
+var WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+var OPCODES = { continuation: 0, text: 1, close: 8, ping: 9, pong: 10 };
+var acceptKey = (key) => createHash("sha1").update(key + WS_GUID).digest("base64");
+function encodeTextFrame(text) {
+  const payload = Buffer.from(text, "utf8");
+  const len = payload.length;
+  let header;
+  if (len < 126) {
+    header = Buffer.from([128 | OPCODES.text, len]);
+  } else if (len < 65536) {
+    header = Buffer.alloc(4);
+    header[0] = 128 | OPCODES.text;
+    header[1] = 126;
+    header.writeUInt16BE(len, 2);
+  } else {
+    header = Buffer.alloc(10);
+    header[0] = 128 | OPCODES.text;
+    header[1] = 127;
+    header.writeBigUInt64BE(BigInt(len), 2);
+  }
+  return Buffer.concat([header, payload]);
+}
+var encodeControl = (opcode, payload = Buffer.alloc(0)) => Buffer.concat([Buffer.from([128 | opcode, payload.length]), payload]);
+function decodeFrames(buf) {
+  const frames = [];
+  for (; ; ) {
+    if (buf.length < 2) break;
+    const fin = (buf[0] & 128) !== 0;
+    const opcode = buf[0] & 15;
+    const masked = (buf[1] & 128) !== 0;
+    let len = buf[1] & 127;
+    let off = 2;
+    if (len === 126) {
+      if (buf.length < off + 2) break;
+      len = buf.readUInt16BE(off);
+      off += 2;
+    } else if (len === 127) {
+      if (buf.length < off + 8) break;
+      len = Number(buf.readBigUInt64BE(off));
+      off += 8;
+    }
+    const maskLen = masked ? 4 : 0;
+    if (buf.length < off + maskLen + len) break;
+    let payload = buf.subarray(off + maskLen, off + maskLen + len);
+    if (masked) {
+      const mask = buf.subarray(off, off + 4);
+      const un = Buffer.alloc(len);
+      for (let i = 0; i < len; i++) un[i] = payload[i] ^ mask[i & 3];
+      payload = un;
+    }
+    buf = buf.subarray(off + maskLen + len);
+    frames.push({ fin, opcode, payload });
+  }
+  return { frames, rest: buf };
+}
+function acceptWebSocket(req, socket) {
+  const key = req.headers["sec-websocket-key"];
+  socket.write(
+    `HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: ${acceptKey(String(key ?? randomBytes(16).toString("base64")))}\r
+\r
+`
+  );
+  let buf = Buffer.alloc(0);
+  let fragments = [];
+  let closed = false;
+  const conn = {
+    send(text) {
+      if (!closed) socket.write(encodeTextFrame(text));
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      try {
+        socket.write(encodeControl(OPCODES.close));
+        socket.end();
+      } catch {
+      }
+      conn.onClose?.();
+    },
+    onMessage: null,
+    onClose: null,
+    get closed() {
+      return closed;
+    }
+  };
+  const die = () => {
+    if (!closed) {
+      closed = true;
+      conn.onClose?.();
+    }
+  };
+  const drain = () => {
+    const { frames, rest } = decodeFrames(buf);
+    buf = rest;
+    for (const { fin, opcode, payload } of frames) {
+      if (opcode === OPCODES.close) {
+        conn.close();
+        return;
+      }
+      if (opcode === OPCODES.ping) {
+        socket.write(encodeControl(OPCODES.pong, payload));
+        continue;
+      }
+      if (opcode === OPCODES.pong) continue;
+      if (opcode === OPCODES.text || opcode === OPCODES.continuation) {
+        fragments.push(payload);
+        if (fin) {
+          const text = Buffer.concat(fragments).toString("utf8");
+          fragments = [];
+          conn.onMessage?.(text);
+        }
+      }
+    }
+  };
+  socket.on("data", (chunk) => {
+    buf = Buffer.concat([buf, chunk]);
+    drain();
+  });
+  socket.on("error", die);
+  socket.on("close", die);
+  return conn;
+}
+
+// src/server.ts
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".map": "application/json"
+};
+var defaultAppDir = () => fileURLToPath(new URL("../app/", import.meta.url));
+var serveStatic = (appDir, req, res) => {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  let path = normalize(decodeURIComponent(url.pathname)).replace(/^([/\\])+/, "");
+  if (path === "" || path === ".") path = "index.html";
+  const file = join(appDir, path);
+  if (!file.startsWith(normalize(appDir)) || !existsSync(file)) {
+    res.writeHead(404).end("not found");
+    return;
+  }
+  res.writeHead(200, { "content-type": MIME[extname(file)] ?? "application/octet-stream" });
+  res.end(readFileSync(file));
+};
+function createDevtoolsServer(opts = {}) {
+  const host = opts.host ?? "127.0.0.1";
+  const appDir = opts.appDir ?? defaultAppDir();
+  const replayCap = opts.replayBatches ?? 500;
+  const viewers = /* @__PURE__ */ new Set();
+  const sessions = /* @__PURE__ */ new Map();
+  const closedSessions = [];
+  const closedCap = 20;
+  const closedTtlMs = opts.closedTtlMs ?? 30 * 60 * 1e3;
+  const tail = [];
+  const sessionList = () => [...sessions.values(), ...closedSessions];
+  const evictClosed = (sessionId) => {
+    const i = closedSessions.findIndex((s) => s.id === sessionId);
+    if (i < 0) return false;
+    closedSessions.splice(i, 1);
+    for (let j = tail.length - 1; j >= 0; j--) {
+      const m = tail[j];
+      if (m.type === "batch" && m.session.id === sessionId) tail.splice(j, 1);
+    }
+    return true;
+  };
+  const broadcast = (msg) => {
+    if (msg.type === "batch") {
+      tail.push(msg);
+      if (tail.length > replayCap) tail.shift();
+    }
+    const text = JSON.stringify(msg);
+    for (const v of viewers) v.send(text);
+  };
+  const server2 = createServer((req, res) => {
+    if (req.url === "/health") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ ok: true, sessions: sessions.size }));
+      return;
+    }
+    serveStatic(appDir, req, res);
+  });
+  server2.on("upgrade", (req, socket, head) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (url.pathname !== "/events" && url.pathname !== "/view") {
+      socket.destroy();
+      return;
+    }
+    const conn = acceptWebSocket(req, socket);
+    if (head?.length) socket.unshift(head);
+    if (url.pathname === "/view") {
+      viewers.add(conn);
+      conn.onClose = () => viewers.delete(conn);
+      conn.onMessage = (text) => {
+        let msg;
+        try {
+          msg = JSON.parse(text);
+        } catch {
+          return;
+        }
+        if (msg.type === "dismiss") {
+          if (evictClosed(msg.sessionId)) {
+            broadcast({ type: "sessions", sessions: sessionList() });
+          }
+        } else if (msg.type === "pin") {
+          const s = closedSessions.find((s2) => s2.id === msg.sessionId);
+          if (!s || s.pinned === msg.pinned) return;
+          s.pinned = msg.pinned;
+          broadcast({ type: "sessions", sessions: sessionList() });
+        }
+      };
+      conn.send(JSON.stringify({ type: "sessions", sessions: sessionList() }));
+      for (const msg of tail) conn.send(JSON.stringify(msg));
+      return;
+    }
+    let greeted = false;
+    conn.onMessage = (text) => {
+      let msg;
+      try {
+        msg = JSON.parse(text);
+      } catch {
+        return;
+      }
+      if (msg.type === "hello") {
+        greeted = true;
+        sessions.set(conn, msg.session);
+        broadcast({ type: "sessions", sessions: sessionList() });
+        return;
+      }
+      if (msg.type === "batch" && greeted) {
+        broadcast({ type: "batch", session: sessions.get(conn), events: msg.events });
+      }
+    };
+    conn.onClose = () => {
+      const info = sessions.get(conn);
+      if (sessions.delete(conn) && info) {
+        info.closed = true;
+        info.closedAt = Date.now();
+        closedSessions.push(info);
+        if (closedSessions.length > closedCap) {
+          const i = closedSessions.findIndex((s) => !s.pinned);
+          if (i >= 0) evictClosed(closedSessions[i].id);
+        }
+        broadcast({ type: "sessions", sessions: sessionList() });
+      }
+    };
+  });
+  const sweep = setInterval(() => {
+    const cutoff = Date.now() - closedTtlMs;
+    let changed = false;
+    for (const s of [...closedSessions]) {
+      if (!s.pinned && s.closedAt !== void 0 && s.closedAt < cutoff) {
+        changed = evictClosed(s.id) || changed;
+      }
+    }
+    if (changed) broadcast({ type: "sessions", sessions: sessionList() });
+  }, opts.sweepMs ?? 6e4);
+  sweep.unref();
+  return new Promise((resolve, reject) => {
+    server2.once("error", reject);
+    server2.listen(opts.port ?? 4780, host, () => {
+      const address = server2.address();
+      const port2 = typeof address === "object" && address ? address.port : opts.port ?? 4780;
+      const url = `http://${host}:${port2}`;
+      opts.onListen?.(url);
+      resolve({
+        port: port2,
+        url,
+        sessions: () => [...sessions.values()],
+        close: () => new Promise((done) => {
+          clearInterval(sweep);
+          for (const v of viewers) v.close();
+          for (const c of sessions.keys()) c.close();
+          server2.close(() => done());
+        })
+      });
+    });
+  });
+}
+
+// src/bin.ts
+var arg = (name) => {
+  const i = process.argv.indexOf(`--${name}`);
+  return i >= 0 ? process.argv[i + 1] : void 0;
+};
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+  console.log("usage: atoll-devtools [--port N]  \u2014 serve the devtools dashboard + event ingest (default port 4780)");
+  process.exit(0);
+}
+var port = Number(arg("port") ?? 4780);
+var server = await createDevtoolsServer({
+  port: Number.isFinite(port) ? port : 4780
+});
+console.log(`atoll devtools \u2192 ${server.url}`);
+console.log("  dashboard: " + server.url);
+console.log("  ingest:    " + server.url.replace("http://", "ws://") + "/events");
+console.log("\nIn the app:  import { connectDevtools } from '@atolljs/devtools'; connectDevtools()");

package/dist/broadcast.d.ts

@@ -0,0 +1,3 @@
+import { type SessionInfo } from './protocol.js';
+import type { ConnectDevtoolsOptions, DevtoolsConnection } from './client.js';
+export declare function connectBroadcast(opts: ConnectDevtoolsOptions, session: SessionInfo): DevtoolsConnection;