pinomad 0.3.0 → 0.4.0

package/web/index.html

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>PiNomad</title>
-    <script type="module" crossorigin src="/assets/index-CBXdQLua.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CG33GBxM.css">
+    <script type="module" crossorigin src="/assets/index-8mNNPXPT.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BFJJgGGo.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/chunk-4dj2vb8t.js

@@ -1,284 +0,0 @@
-#!/usr/bin/env node
-import {
-  serveWebClient
-} from "./chunk-r6w5aqkw.js";
-import {
-  commandHint,
-  webRoot
-} from "./chunk-3tf23vjq.js";
-import {
-  RELAY_CLOSE,
-  decodeHostToRelay,
-  encodeRelayFrame,
-  verifyRelayChallenge
-} from "./chunk-z4x88s0q.js";
-import"./chunk-df32avw6.js";
-
-// apps/relay/src/main.ts
-import { parseArgs } from "node:util";
-
-// apps/relay/src/relay.ts
-import { randomBytes } from "node:crypto";
-import { once } from "node:events";
-import { createServer } from "node:http";
-import { WebSocket, WebSocketServer } from "ws";
-var MAX_PAYLOAD = 128 * 1024;
-var MAX_BUFFERED = 64 * 1024;
-var HIGH_WATER = 1024 * 1024;
-var LOW_WATER = 256 * 1024;
-var HOST_PATH = "/host";
-var DEVICE_PATH = /^\/c\/([A-Za-z0-9_-]{43})$/;
-var ACCEPT_PATH = /^\/accept\/([A-Za-z0-9_-]{22})$/;
-var isSendableCloseCode = (code) => code >= 1000 && code <= 1003 || code >= 1007 && code <= 1014 || code >= 3000 && code <= 4999;
-var rawLength = (data) => Array.isArray(data) ? data.reduce((sum, part) => sum + part.length, 0) : data.byteLength;
-async function startRelay(options) {
-  const publicOrigin = options.publicOrigin.replace(/\/+$/, "");
-  if (publicOrigin === "")
-    throw new Error("publicOrigin is required");
-  const allowedHosts = new Set(options.allowedHosts);
-  const acceptTimeoutMs = options.acceptTimeoutMs ?? 1e4;
-  const registerTimeoutMs = options.registerTimeoutMs ?? 1e4;
-  const pingIntervalMs = options.pingIntervalMs ?? 30000;
-  const listenHost = options.listenHost ?? "127.0.0.1";
-  const controls = new Map;
-  const pending = new Map;
-  const sockets = new Set;
-  const alive = new WeakMap;
-  function track(socket) {
-    sockets.add(socket);
-    alive.set(socket, true);
-    socket.on("pong", () => alive.set(socket, true));
-    socket.on("close", () => sockets.delete(socket));
-    socket.on("error", () => socket.terminate());
-  }
-  function splice(a, b) {
-    const forward = (from, to) => {
-      from.on("message", (data, isBinary) => {
-        if (to.readyState !== WebSocket.OPEN)
-          return;
-        to.send(data, { binary: isBinary }, () => {
-          if (from.isPaused && to.bufferedAmount <= LOW_WATER)
-            from.resume();
-        });
-        if (to.bufferedAmount > HIGH_WATER)
-          from.pause();
-      });
-      from.on("close", (code, reason) => {
-        if (to.readyState !== WebSocket.OPEN)
-          return;
-        to.close(isSendableCloseCode(code) ? code : 1001, reason);
-      });
-    };
-    forward(a, b);
-    forward(b, a);
-  }
-  function onControl(socket) {
-    track(socket);
-    const nonce = randomBytes(32).toString("base64url");
-    socket.send(encodeRelayFrame({ t: "challenge", nonce }));
-    let hostId;
-    const deadline = setTimeout(() => socket.close(1008, "register timeout"), registerTimeoutMs);
-    socket.on("message", (data, isBinary) => {
-      if (hostId !== undefined || isBinary) {
-        socket.close(1008, "unexpected frame");
-        return;
-      }
-      let frame;
-      try {
-        frame = decodeHostToRelay(data.toString());
-      } catch {
-        socket.close(1008, "malformed frame");
-        return;
-      }
-      const verified = verifyRelayChallenge(frame.signature, { relayOrigin: publicOrigin, hostId: frame.hostId, nonce });
-      if (!verified) {
-        socket.close(RELAY_CLOSE.badSignature);
-        return;
-      }
-      if (!allowedHosts.has(frame.hostId)) {
-        socket.close(RELAY_CLOSE.hostNotAllowed);
-        return;
-      }
-      hostId = frame.hostId;
-      clearTimeout(deadline);
-      const previous = controls.get(hostId);
-      if (previous !== undefined)
-        previous.close(RELAY_CLOSE.replaced);
-      controls.set(hostId, socket);
-      socket.send(encodeRelayFrame({ t: "registered" }));
-    });
-    socket.once("close", () => {
-      clearTimeout(deadline);
-      if (hostId !== undefined && controls.get(hostId) === socket)
-        controls.delete(hostId);
-      for (const [connId, entry] of pending) {
-        if (entry.control === socket) {
-          pending.delete(connId);
-          clearTimeout(entry.timer);
-          entry.socket.close(RELAY_CLOSE.hostOffline);
-        }
-      }
-    });
-  }
-  function onDevice(socket, hostId) {
-    track(socket);
-    const control = controls.get(hostId);
-    if (control === undefined) {
-      socket.close(RELAY_CLOSE.hostOffline);
-      return;
-    }
-    const connId = randomBytes(16).toString("base64url");
-    const entry = {
-      control,
-      socket,
-      buffered: [],
-      bufferedBytes: 0,
-      timer: setTimeout(() => {
-        if (pending.delete(connId))
-          socket.close(RELAY_CLOSE.acceptTimeout);
-      }, acceptTimeoutMs),
-      onMessage(data, isBinary) {
-        entry.buffered.push({ data, isBinary });
-        entry.bufferedBytes += rawLength(data);
-        if (entry.bufferedBytes > MAX_BUFFERED && pending.delete(connId)) {
-          clearTimeout(entry.timer);
-          socket.close(1009);
-        }
-      },
-      onClose() {
-        if (pending.delete(connId))
-          clearTimeout(entry.timer);
-      }
-    };
-    pending.set(connId, entry);
-    socket.on("message", entry.onMessage);
-    socket.once("close", entry.onClose);
-    control.send(encodeRelayFrame({ t: "incoming", connId }));
-  }
-  function onAccept(socket, connId) {
-    track(socket);
-    const entry = pending.get(connId);
-    if (entry === undefined) {
-      socket.close(RELAY_CLOSE.unknownConnection);
-      return;
-    }
-    pending.delete(connId);
-    clearTimeout(entry.timer);
-    const device = entry.socket;
-    device.removeListener("message", entry.onMessage);
-    device.removeListener("close", entry.onClose);
-    splice(socket, device);
-    for (const { data, isBinary } of entry.buffered)
-      socket.send(data, { binary: isBinary });
-  }
-  const httpServer = createServer((request, response) => {
-    if (options.webRoot !== undefined) {
-      serveWebClient(request, response, options.webRoot).catch(() => {
-        if (!response.headersSent)
-          response.writeHead(500);
-        response.end();
-      });
-      return;
-    }
-    response.writeHead(404);
-    response.end();
-  });
-  const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD });
-  httpServer.on("upgrade", (request, socket, head) => {
-    let pathname;
-    try {
-      pathname = new URL(request.url ?? "/", "http://relay.invalid").pathname;
-    } catch {
-      pathname = "";
-    }
-    const upgrade = (handle) => {
-      wss.handleUpgrade(request, socket, head, handle);
-    };
-    const device = DEVICE_PATH.exec(pathname);
-    const accept = ACCEPT_PATH.exec(pathname);
-    if (pathname === HOST_PATH)
-      upgrade(onControl);
-    else if (device !== null)
-      upgrade((ws) => onDevice(ws, device[1]));
-    else if (accept !== null)
-      upgrade((ws) => onAccept(ws, accept[1]));
-    else {
-      socket.write(`HTTP/1.1 404 Not Found\r
-\r
-`);
-      socket.destroy();
-    }
-  });
-  await new Promise((resolveListen, reject) => {
-    httpServer.once("listening", resolveListen);
-    httpServer.once("error", reject);
-    httpServer.listen(options.port, listenHost);
-  });
-  const { port } = httpServer.address();
-  const pingTimer = setInterval(() => {
-    for (const socket of sockets) {
-      if (alive.get(socket) === true) {
-        alive.set(socket, false);
-        socket.ping();
-      } else {
-        socket.terminate();
-      }
-    }
-  }, pingIntervalMs);
-  return {
-    port,
-    url: `ws://${listenHost.includes(":") ? `[${listenHost}]` : listenHost}:${port}`,
-    async close() {
-      clearInterval(pingTimer);
-      for (const entry of pending.values())
-        clearTimeout(entry.timer);
-      pending.clear();
-      for (const socket of sockets)
-        socket.terminate();
-      const closing = once(wss, "close");
-      wss.close();
-      await closing;
-      await new Promise((resolve) => httpServer.close(() => resolve()));
-    }
-  };
-}
-
-// apps/relay/src/main.ts
-async function main(argv) {
-  const { values } = parseArgs({
-    args: [...argv],
-    options: {
-      port: { type: "string", default: "7430" },
-      listen: { type: "string", default: "127.0.0.1" },
-      "public-origin": { type: "string" },
-      "allow-host": { type: "string", multiple: true }
-    }
-  });
-  const allowedHosts = values["allow-host"] ?? [];
-  if (values["public-origin"] === undefined || allowedHosts.length === 0) {
-    console.error(`usage: ${commandHint("relay")} --public-origin ORIGIN --allow-host HOST_ID [--allow-host ...] [--port 7430] [--listen 127.0.0.1]`);
-    process.exit(1);
-  }
-  const relay = await startRelay({
-    port: Number(values.port),
-    listenHost: values.listen,
-    publicOrigin: values["public-origin"],
-    allowedHosts,
-    webRoot
-  });
-  console.log(JSON.stringify({ event: "ready", url: relay.url, publicOrigin: values["public-origin"], allowedHosts: allowedHosts.length }));
-  let stopping = false;
-  const stop = () => {
-    if (stopping)
-      return;
-    stopping = true;
-    relay.close().finally(() => process.exit(0));
-  };
-  process.on("SIGINT", stop);
-  process.on("SIGTERM", stop);
-}
-if (false)
-  ;
-export {
-  main
-};

package/dist/chunk-fxaewke2.js

@@ -1,113 +0,0 @@
-import {
-  fromBase64Url,
-  generateKeyPair,
-  keyPairFromPrivate,
-  toBase64Url
-} from "./chunk-z4x88s0q.js";
-
-// apps/host/src/devices.ts
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { randomBytes, timingSafeEqual } from "node:crypto";
-import { ed25519 } from "@noble/curves/ed25519.js";
-import { defineDoc } from "@earendil-works/pi-durable";
-var DevicesDoc = defineDoc({
-  kind: "pinomad.devices",
-  version: 1,
-  scope: "session",
-  initial: () => ({ devices: [] })
-});
-async function ensureDevices(harness, context) {
-  await harness.commit(async (tx) => void await tx.doc(DevicesDoc), context);
-}
-async function isRegistered(harness, publicKey, context) {
-  return await harness.commit(async (tx) => (await tx.doc(DevicesDoc)).devices.some((entry) => entry.publicKey === publicKey), context);
-}
-async function registerDevice(harness, device, context) {
-  return await harness.commit(async (tx) => {
-    const doc = await tx.doc(DevicesDoc);
-    const existing = doc.devices.find((entry2) => entry2.publicKey === device.publicKey);
-    if (existing !== undefined)
-      return { ...existing };
-    const name = device.name.trim().slice(0, 64) || "Unknown device";
-    const entry = { publicKey: device.publicKey, name, pairedAt: Date.now() };
-    doc.devices.push(entry);
-    return entry;
-  }, context);
-}
-async function revokeDevice(harness, publicKey, context) {
-  await harness.commit(async (tx) => {
-    const doc = await tx.doc(DevicesDoc);
-    doc.devices = doc.devices.filter((entry) => entry.publicKey !== publicKey);
-  }, context);
-}
-async function loadHostKey(dataDir) {
-  const path = join(dataDir, "host-key");
-  try {
-    const text = (await readFile(path, "utf8")).trim();
-    return keyPairFromPrivate(fromBase64Url(text));
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-    const pair = generateKeyPair();
-    await writeFile(path, `${toBase64Url(pair.privateKey)}
-`, { mode: 384 });
-    return pair;
-  }
-}
-async function loadRelayKey(dataDir) {
-  const path = join(dataDir, "relay-key");
-  try {
-    const secretKey = fromBase64Url((await readFile(path, "utf8")).trim());
-    if (secretKey.length !== 32)
-      throw new Error(`bad relay key in ${path}`);
-    return { secretKey, publicKey: ed25519.getPublicKey(secretKey) };
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-    const { secretKey, publicKey } = ed25519.keygen();
-    try {
-      await writeFile(path, `${toBase64Url(secretKey)}
-`, { flag: "wx", mode: 384 });
-    } catch (race) {
-      if (race.code !== "EEXIST")
-        throw race;
-      return loadRelayKey(dataDir);
-    }
-    return { secretKey, publicKey };
-  }
-}
-function pairingOffers(ttlMs = 5 * 60 * 1000) {
-  const live = new Map;
-  const prune = () => {
-    const now = Date.now();
-    for (const [secret, expiresAt] of live)
-      if (expiresAt <= now)
-        live.delete(secret);
-  };
-  return {
-    create() {
-      prune();
-      const secret = toBase64Url(randomBytes(16));
-      const expiresAt = Date.now() + ttlMs;
-      live.set(secret, expiresAt);
-      return { secret, expiresAt };
-    },
-    consume(secret) {
-      prune();
-      const candidate = Buffer.from(secret);
-      for (const offer of live.keys()) {
-        const offerBytes = Buffer.from(offer);
-        if (offerBytes.length !== candidate.length)
-          continue;
-        if (timingSafeEqual(offerBytes, candidate)) {
-          live.delete(offer);
-          return true;
-        }
-      }
-      return false;
-    }
-  };
-}
-
-export { DevicesDoc, ensureDevices, isRegistered, registerDevice, revokeDevice, loadHostKey, loadRelayKey, pairingOffers };