pinomad 0.9.0 → 0.10.0

package/dist/{chunk-3p1eysm9.js → chunk-4h7pkkzr.js}

@@ -6,7 +6,7 @@ import {
   relayWsBase,
   signRelayChallenge,
   signRelayChallengeV2
-} from "./chunk-khcpv54k.js";
+} from "./chunk-cx8k63by.js";
 import {
   toBase64Url
 } from "./chunk-sygeb9qb.js";
@@ -55,6 +55,7 @@ function isSecureServerOrigin(origin) {
   const loopback = host === "localhost" || host.endsWith(".localhost") || ipv4Loopback || host === "::1" || host === "[::1]";
   return url.protocol === "https:" || url.protocol === "http:" && loopback;
 }
+var DEVICE_HOST_STATES = new Set(["registered", "revoking", "revoked"]);
 
 // apps/host/src/cli/server-ops.ts
 function assertSecureServerOrigin(origin) {
@@ -122,7 +123,7 @@ async function runServerOperation(options) {
         finish(() => reject(new Error(`${origin} ignored the operation — the server is too old for accounts; upgrade it first`)));
         return;
       }
-      if (frame.t === "incoming" || frame.t === "pairing-request" || frame.t === "push-result")
+      if (frame.t === "incoming" || frame.t === "pairing-request" || frame.t === "push-result" || frame.t === "revoke-device")
         return;
       finish(() => resolve(frame));
     });

package/dist/{chunk-0tesv2sr.js → chunk-5791mb0b.js}

@@ -3,24 +3,24 @@ import {
   assertSecureServerOrigin,
   probeServerAccounts,
   runServerOperation
-} from "./chunk-3p1eysm9.js";
+} from "./chunk-4h7pkkzr.js";
 import {
   loadHostKey,
   loadRelayKey,
   readServerConfig,
   removeServerConfig
-} from "./chunk-5gp9svzs.js";
+} from "./chunk-8gywfw5n.js";
 import {
   relayHostId
-} from "./chunk-khcpv54k.js";
+} from "./chunk-cx8k63by.js";
 import {
   argValue,
   restartService,
   serviceManager,
   withoutRelayArgs
-} from "./chunk-76pvsg2d.js";
+} from "./chunk-w2m9xkks.js";
 import"./chunk-kzbzacz9.js";
-import"./chunk-vyvyaavr.js";
+import"./chunk-zehwx009.js";
 import"./chunk-4sepcfpy.js";
 import"./chunk-jgd38rna.js";
 import"./chunk-sygeb9qb.js";

package/dist/{chunk-qgexy01f.js → chunk-73efzaf1.js}

@@ -2,13 +2,13 @@
 import {
   restartService,
   serviceManager
-} from "./chunk-76pvsg2d.js";
+} from "./chunk-w2m9xkks.js";
 import"./chunk-kzbzacz9.js";
 import {
   globalPrefixOf,
   packageDir,
   packagedVersion
-} from "./chunk-vyvyaavr.js";
+} from "./chunk-zehwx009.js";
 import"./chunk-4sepcfpy.js";
 import"./chunk-jgd38rna.js";
 import"./chunk-sygeb9qb.js";

package/dist/{chunk-5gp9svzs.js → chunk-8gywfw5n.js}

@@ -52,7 +52,7 @@ async function admitDevice(harness, input, context) {
     if (revocations.revoked.includes(input.publicKey)) {
       revocations.revoked = revocations.revoked.filter((key) => key !== input.publicKey);
     }
-    return { outcome: "admitted", entry };
+    return { outcome: "admitted", entry, ...offer.requestId === undefined ? {} : { requestId: offer.requestId } };
   }, context);
 }
 async function loadHostKey(dataDir) {
@@ -117,7 +117,7 @@ function pairingOffers(ttlMs = 5 * 60 * 1000) {
   };
   return {
     create: (source) => mint({ source }),
-    createAccount: (binding) => mint({ source: "account", binding }),
+    createAccount: (binding, requestId) => mint({ source: "account", binding, ...requestId === undefined ? {} : { requestId } }),
     consume(secret) {
       prune();
       const candidate = Buffer.from(secret);

package/dist/{chunk-m824ds0q.js → chunk-bhtx2c8a.js}

@@ -2,9 +2,9 @@
 import {
   main,
   restartService
-} from "./chunk-76pvsg2d.js";
+} from "./chunk-w2m9xkks.js";
 import"./chunk-kzbzacz9.js";
-import"./chunk-vyvyaavr.js";
+import"./chunk-zehwx009.js";
 import"./chunk-4sepcfpy.js";
 import"./chunk-jgd38rna.js";
 import"./chunk-sygeb9qb.js";

package/dist/{chunk-yhf7bj5q.js → chunk-c05g401k.js}

@@ -3,7 +3,7 @@ import {
   assertSecureServerOrigin,
   probeServerAccounts,
   runServerOperation
-} from "./chunk-3p1eysm9.js";
+} from "./chunk-4h7pkkzr.js";
 import {
   constantValue,
   openHostSettings
@@ -12,22 +12,22 @@ import {
   loadHostKey,
   loadRelayKey,
   writeServerConfig
-} from "./chunk-5gp9svzs.js";
+} from "./chunk-8gywfw5n.js";
 import {
   relayHostId
-} from "./chunk-khcpv54k.js";
+} from "./chunk-cx8k63by.js";
 import {
   argValue,
   installSpec,
   restartService,
   serviceManager,
   withoutRelayArgs
-} from "./chunk-76pvsg2d.js";
+} from "./chunk-w2m9xkks.js";
 import"./chunk-kzbzacz9.js";
 import {
   commandHint,
   hostEntry
-} from "./chunk-vyvyaavr.js";
+} from "./chunk-zehwx009.js";
 import"./chunk-4sepcfpy.js";
 import"./chunk-jgd38rna.js";
 import {

package/dist/{chunk-014b7ne7.js → chunk-c5p9xkd8.js}

@@ -1,6 +1,6 @@
 import {
   packagedVersion
-} from "./chunk-vyvyaavr.js";
+} from "./chunk-zehwx009.js";
 import {
   hostAddress
 } from "./chunk-ngf1zatm.js";

package/dist/{chunk-khcpv54k.js → chunk-cx8k63by.js}

@@ -12,8 +12,11 @@ var RELAY_CLOSE = {
   hostNotAllowed: 4603,
   hostOffline: 4604,
   unknownConnection: 4605,
+  handshakeTimeout: 4608,
   replaced: 4609,
-  acceptTimeout: 4610
+  acceptTimeout: 4610,
+  tooManyConnections: 4629,
+  trafficLimit: 4630
 };
 function encodeRelayFrame(frame) {
   return JSON.stringify(frame);
@@ -21,6 +24,7 @@ function encodeRelayFrame(frame) {
 var isString = (value) => typeof value === "string";
 var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var isBoundedString = (value, max = 64) => isString(value) && value.length > 0 && value.length <= max;
+var isDeviceKey = (value) => isBoundedString(value) && /^[A-Za-z0-9_-]+$/.test(value);
 function decodeJson(text) {
   try {
     return JSON.parse(text);
@@ -45,6 +49,10 @@ function decodeRelayToHost(text) {
       if (!isBoundedString(value.requestId))
         throw new Error("malformed pairing-request");
       return { t: "pairing-request", requestId: value.requestId };
+    case "revoke-device":
+      if (!isDeviceKey(value.publicKey))
+        throw new Error("malformed revoke-device");
+      return { t: "revoke-device", publicKey: value.publicKey };
     case "push-result":
       return decodePushResult(value);
     case "joined":
@@ -140,6 +148,14 @@ function decodeHostToRelay(text) {
       if (!isBoundedString(value.name, HOST_NAME_MAX_UNITS))
         throw new Error("malformed name");
       return { t: "name", name: value.name };
+    case "device-admitted":
+      if (!isBoundedString(value.requestId) || !isDeviceKey(value.publicKey))
+        throw new Error("malformed device-admitted");
+      return { t: "device-admitted", requestId: value.requestId, publicKey: value.publicKey };
+    case "device-revoked":
+      if (!isDeviceKey(value.publicKey))
+        throw new Error("malformed device-revoked");
+      return { t: "device-revoked", publicKey: value.publicKey };
     default:
       throw new Error("unknown host frame");
   }
@@ -234,6 +250,7 @@ function verifyRelayChallengeV2(signature, args) {
 // apps/host/src/relay-link.ts
 import { randomBytes } from "node:crypto";
 import { WebSocket } from "ws";
+var MAX_UNSENT_REPORTS = 64;
 function relayWsBase(origin) {
   const normalized = origin.replace(/\/+$/, "");
   if (normalized.startsWith("https://"))
@@ -257,6 +274,10 @@ function startRelayLink(options) {
   const minDelay = options.reconnectDelayMs?.min ?? 1000;
   const maxDelay = options.reconnectDelayMs?.max ?? 30000;
   const maxPendingAccepts = options.maxPendingAccepts ?? 16;
+  const features = [
+    ...options.accountOffer === undefined ? [] : ["pairing"],
+    ...options.deviceReports === undefined ? [] : ["device-reports"]
+  ];
   let state = { status: "connecting" };
   let stopped = false;
   let control;
@@ -266,6 +287,8 @@ function startRelayLink(options) {
   let pushEnvironments;
   let reportedName;
   let nameDeclared = false;
+  let reportsDeclared = false;
+  const unsentReports = [];
   const pushes = new Map;
   function setState(next) {
     const changed = state.status !== next.status || state.status === "rejected" && next.status === "rejected" && state.reason !== next.reason;
@@ -302,6 +325,7 @@ function startRelayLink(options) {
     control = socket;
     pushEnvironments = undefined;
     nameDeclared = false;
+    reportsDeclared = false;
     reportedName = undefined;
     watch(socket);
     socket.on("message", (data, isBinary) => onControlMessage(socket, data, isBinary));
@@ -336,7 +360,7 @@ function startRelayLink(options) {
           signature: signRelayChallenge(options.signingKey.secretKey, challenge),
           signatureV2: signRelayChallengeV2(options.signingKey.secretKey, { ...challenge, noisePublicKey }),
           noisePublicKey,
-          ...options.accountOffer === undefined ? {} : { features: ["pairing"] },
+          ...features.length === 0 ? {} : { features },
           ...reportedName === undefined ? {} : { name: reportedName }
         }));
         break;
@@ -345,6 +369,12 @@ function startRelayLink(options) {
         delay = minDelay;
         pushEnvironments = frame.push;
         nameDeclared = frame.features?.includes("name") === true;
+        reportsDeclared = options.deviceReports !== undefined && frame.features?.includes("device-reports") === true;
+        if (reportsDeclared) {
+          for (const report of unsentReports.splice(0)) {
+            socket.send(encodeRelayFrame({ t: "device-admitted", ...report }));
+          }
+        }
         const current = options.hostName?.value;
         if (nameDeclared && current !== undefined && current !== reportedName) {
           reportedName = current;
@@ -371,7 +401,7 @@ function startRelayLink(options) {
           refused("unavailable");
           break;
         }
-        accountOffer().then((result) => {
+        accountOffer(frame.requestId).then((result) => {
           if (socket !== control || socket.readyState !== WebSocket.OPEN)
             return;
           const checked = result.ok && result.endpointSet !== undefined ? parseEndpointSet(result.endpointSet) : undefined;
@@ -393,6 +423,18 @@ function startRelayLink(options) {
         });
         break;
       }
+      case "revoke-device": {
+        const reports = options.deviceReports;
+        if (reports === undefined)
+          break;
+        const { publicKey } = frame;
+        reports.revoke(publicKey).then(() => {
+          if (socket === control && socket.readyState === WebSocket.OPEN) {
+            socket.send(encodeRelayFrame({ t: "device-revoked", publicKey }));
+          }
+        }, () => {});
+        break;
+      }
       case "incoming": {
         if (pendingAccepts >= maxPendingAccepts)
           break;
@@ -415,6 +457,7 @@ function startRelayLink(options) {
     control = undefined;
     pushEnvironments = undefined;
     nameDeclared = false;
+    reportsDeclared = false;
     reportedName = undefined;
     for (const [requestId, request] of pushes) {
       if (request.socket === socket) {
@@ -478,6 +521,18 @@ function startRelayLink(options) {
         socket.send(encodeRelayFrame({ t: "push", requestId, ...request }));
       });
     },
+    reportAdmitted(requestId, publicKey) {
+      if (options.deviceReports === undefined)
+        return;
+      const socket = control;
+      if (reportsDeclared && socket !== undefined && socket.readyState === WebSocket.OPEN) {
+        socket.send(encodeRelayFrame({ t: "device-admitted", requestId, publicKey }));
+        return;
+      }
+      unsentReports.push({ requestId, publicKey });
+      if (unsentReports.length > MAX_UNSENT_REPORTS)
+        unsentReports.shift();
+    },
     close() {
       stopped = true;
       if (retryTimer !== undefined)

package/dist/{chunk-ctzgjctt.js → chunk-czj9nfrz.js}

@@ -21,16 +21,16 @@ import {
   readServerBinding,
   readServerConfig,
   resolveRelayOrigin
-} from "./chunk-5gp9svzs.js";
+} from "./chunk-8gywfw5n.js";
 import {
   relayHostId,
   relayWsBase,
   startRelayLink
-} from "./chunk-khcpv54k.js";
+} from "./chunk-cx8k63by.js";
 import {
   packagedVersion,
   webRoot
-} from "./chunk-vyvyaavr.js";
+} from "./chunk-zehwx009.js";
 import {
   ATTACHMENT_TTL_MS,
   INVALID_FRAME_CLOSE_CODE,
@@ -3355,6 +3355,14 @@ async function startGateway(options) {
   };
   let remote;
   let relay;
+  const closeDevice = (publicKey) => {
+    for (const connection of [...connections]) {
+      if (connection.devicePublicKey === publicKey) {
+        connection.closeConnection(UNAUTHORIZED_CLOSE_CODE, "device revoked");
+      }
+    }
+    rtc?.closeDevice(publicKey);
+  };
   const currentAdvertisement = () => {
     const advertiseUrl = remote?.advertiseUrl;
     const endpoints = remoteEndpointCandidates({
@@ -3381,14 +3389,7 @@ async function startGateway(options) {
         rtc?.closeOwner(self);
         self.dispose();
       },
-      closeDevice: (publicKey) => {
-        for (const connection2 of [...connections]) {
-          if (connection2.devicePublicKey === publicKey) {
-            connection2.closeConnection(UNAUTHORIZED_CLOSE_CODE, "device revoked");
-          }
-        }
-        rtc?.closeDevice(publicKey);
-      },
+      closeDevice,
       rtcOffer: (owner, key, attempt, sdp) => {
         if (rtc === undefined)
           throw new Error("WebRTC is not available on this host");
@@ -3462,7 +3463,8 @@ async function startGateway(options) {
     acceptAccountDevices: () => options.settings.value.acceptAccountDevices,
     serverBinding: async () => await readServerBinding(options.dataDir).catch(() => {
       return;
-    })
+    }),
+    accountAdmitted: (requestId, publicKey) => relay?.reportAdmitted(requestId, publicKey)
   };
   const secure = options.secure;
   const handshakeHandlers = {
@@ -3515,6 +3517,16 @@ async function startGateway(options) {
   });
   if (secure?.relay !== undefined) {
     const relayOrigin = secure.relay.origin;
+    const currentBinding = async () => {
+      const config = await readServerConfig(options.dataDir).catch(() => {
+        return;
+      });
+      if (config?.binding === undefined)
+        return { refused: "not_joined" };
+      if (normalizeOrigin(config.origin) !== normalizeOrigin(relayOrigin))
+        return { refused: "rebinding" };
+      return { binding: config.binding };
+    };
     let link;
     link = startRelayLink({
       origin: relayOrigin,
@@ -3527,17 +3539,12 @@ async function startGateway(options) {
         },
         subscribe: (listener) => options.settings.subscribe((settings) => listener(settings.hostName))
       },
-      accountOffer: async () => {
+      accountOffer: async (requestId) => {
         if (!options.settings.value.acceptAccountDevices)
           return { ok: false, reason: "disabled" };
-        const config = await readServerConfig(options.dataDir).catch(() => {
-          return;
-        });
-        if (config?.binding === undefined)
-          return { ok: false, reason: "not_joined" };
-        if (normalizeOrigin(config.origin) !== normalizeOrigin(relayOrigin)) {
-          return { ok: false, reason: "rebinding" };
-        }
+        const bound = await currentBinding();
+        if ("refused" in bound)
+          return { ok: false, reason: bound.refused };
         let endpointSet;
         try {
           const current = checkedEndpointSet(currentAdvertisement().endpoints);
@@ -3545,9 +3552,18 @@ async function startGateway(options) {
         } catch {
           return { ok: false, reason: "invalid_endpoint" };
         }
-        const { secret, expiresAt } = secure.offers.createAccount(config.binding);
+        const { secret, expiresAt } = secure.offers.createAccount(bound.binding, requestId);
         return { ok: true, secret, expiresAt, ...endpointSet === undefined ? {} : { endpointSet } };
       },
+      deviceReports: {
+        revoke: async (publicKey) => {
+          const bound = await currentBinding();
+          if ("refused" in bound)
+            throw new Error(`revocation refused: ${bound.refused}`);
+          await revokeDevice(options.harness, publicKey, context3);
+          closeDevice(publicKey);
+        }
+      },
       onStateChange: (state) => {
         if (state.status === "registered") {
           const push = state.push === undefined ? "undeclared" : state.push.length === 0 ? "none" : state.push.join(",");
@@ -3817,6 +3833,9 @@ function secureHandshake(carrier, secure, policy, handlers) {
           carrier.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
           return;
         }
+        if (decision.outcome === "admitted" && decision.requestId !== undefined) {
+          policy.accountAdmitted(decision.requestId, deviceKey);
+        }
         const { message, result: result2 } = responder.writeMessage2(encodeHostHello({ v: 1 }));
         return {
           result: result2,