pinomad 0.7.0 → 0.8.0

package/dist/{chunk-7qb9tq54.js → chunk-khcpv54k.js}

@@ -1,287 +1,12 @@
 import {
-  HOST_NAME_MAX_UNITS
-} from "./chunk-znhn8af7.js";
+  HOST_NAME_MAX_UNITS,
+  fromBase64Url,
+  parseEndpointSet,
+  toBase64Url
+} from "./chunk-sygeb9qb.js";
 
 // packages/protocol/src/relay.ts
 import { ed25519 } from "@noble/curves/ed25519.js";
-
-// packages/protocol/src/noise.ts
-import { chacha20poly1305 } from "@noble/ciphers/chacha.js";
-import { x25519 } from "@noble/curves/ed25519.js";
-import { blake2s } from "@noble/hashes/blake2.js";
-import { hmac } from "@noble/hashes/hmac.js";
-var PROTOCOL_NAME = new TextEncoder().encode("Noise_IK_25519_ChaChaPoly_BLAKE2s");
-var KEY_LENGTH = 32;
-var TAG_LENGTH = 16;
-var MAX_MESSAGE = 65535;
-var MAX_NONCE = 2n ** 64n - 1n;
-var hash = (data) => blake2s(data, { dkLen: KEY_LENGTH });
-var concat = (...parts) => {
-  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
-  let offset = 0;
-  for (const part of parts) {
-    out.set(part, offset);
-    offset += part.length;
-  }
-  return out;
-};
-function hkdf(chainingKey, ikm, outputs) {
-  const tempKey = hmac(blake2s, chainingKey, ikm);
-  const out1 = hmac(blake2s, tempKey, new Uint8Array([1]));
-  const out2 = hmac(blake2s, tempKey, concat(out1, new Uint8Array([2])));
-  return [out1, out2];
-}
-function generateKeyPair() {
-  return keyPairFromPrivate(x25519.utils.randomSecretKey());
-}
-function keyPairFromPrivate(privateKey) {
-  if (privateKey.length !== KEY_LENGTH)
-    throw new Error(`X25519 private key must be ${KEY_LENGTH} bytes`);
-  return { publicKey: x25519.getPublicKey(privateKey), privateKey };
-}
-var dh = (pair, remotePublic) => x25519.getSharedSecret(pair.privateKey, remotePublic);
-
-class NoiseCipherState {
-  #key;
-  #nonce = 0n;
-  setKey(key) {
-    this.#key = key;
-    this.#nonce = 0n;
-  }
-  encrypt(plaintext, ad = new Uint8Array(0)) {
-    const key = this.#key;
-    if (key === undefined)
-      return plaintext;
-    return chacha20poly1305(key, this.#takeNonce(), ad).encrypt(plaintext);
-  }
-  decrypt(ciphertext, ad = new Uint8Array(0)) {
-    const key = this.#key;
-    if (key === undefined)
-      return ciphertext;
-    return chacha20poly1305(key, this.#takeNonce(), ad).decrypt(ciphertext);
-  }
-  #takeNonce() {
-    if (this.#nonce === MAX_NONCE)
-      throw new Error("nonce exhausted");
-    const nonce = new Uint8Array(12);
-    new DataView(nonce.buffer).setBigUint64(4, this.#nonce, true);
-    this.#nonce += 1n;
-    return nonce;
-  }
-}
-
-class SymmetricState {
-  #ck;
-  #h;
-  cipher = new NoiseCipherState;
-  constructor() {
-    const name = PROTOCOL_NAME;
-    this.#h = name.length <= KEY_LENGTH ? concat(name, new Uint8Array(KEY_LENGTH - name.length)) : hash(name);
-    this.#ck = this.#h.slice();
-  }
-  mixKey(ikm) {
-    const [ck, tempKey] = hkdf(this.#ck, ikm, 2);
-    this.#ck = ck;
-    this.cipher.setKey(tempKey.subarray(0, KEY_LENGTH));
-  }
-  mixHash(data) {
-    this.#h = hash(concat(this.#h, data));
-  }
-  encryptAndHash(plaintext) {
-    const ciphertext = this.cipher.encrypt(plaintext, this.#h);
-    this.mixHash(ciphertext);
-    return ciphertext;
-  }
-  decryptAndHash(ciphertext) {
-    const plaintext = this.cipher.decrypt(ciphertext, this.#h);
-    this.mixHash(ciphertext);
-    return plaintext;
-  }
-  get handshakeHash() {
-    return this.#h;
-  }
-  split() {
-    const [key1, key2] = hkdf(this.#ck, new Uint8Array(0), 2);
-    const first = new NoiseCipherState;
-    first.setKey(key1.subarray(0, KEY_LENGTH));
-    const second = new NoiseCipherState;
-    second.setKey(key2.subarray(0, KEY_LENGTH));
-    return [first, second];
-  }
-}
-function take(message, size) {
-  if (message.offset + size > message.buffer.length)
-    throw new Error("malformed Noise message");
-  const slice = message.buffer.subarray(message.offset, message.offset + size);
-  message.offset += size;
-  return slice;
-}
-function readMessage1(state, message, own) {
-  const remoteEphemeral = take(message, KEY_LENGTH).slice();
-  state.mixHash(remoteEphemeral);
-  state.mixKey(dh(own.static, remoteEphemeral));
-  const remoteStatic = state.decryptAndHash(take(message, KEY_LENGTH + TAG_LENGTH)).slice();
-  if (remoteStatic.length !== KEY_LENGTH)
-    throw new Error("bad remote static key");
-  state.mixKey(dh(own.static, remoteStatic));
-  return { remoteEphemeral, remoteStatic };
-}
-function writeMessage2(state, buffer, own, remoteEphemeral, remoteStatic) {
-  buffer.push(own.ephemeral.publicKey);
-  state.mixHash(own.ephemeral.publicKey);
-  state.mixKey(dh(own.ephemeral, remoteEphemeral));
-  state.mixKey(dh(own.ephemeral, remoteStatic));
-}
-var checkLength = (message, what) => {
-  if (message.length > MAX_MESSAGE)
-    throw new Error(`${what} exceeds ${MAX_MESSAGE} bytes`);
-};
-function initialize(prologue, responderStatic) {
-  const state = new SymmetricState;
-  state.mixHash(prologue);
-  state.mixHash(responderStatic);
-  return state;
-}
-function respondIK(options) {
-  const ephemeral = options.ephemeral ?? generateKeyPair();
-  const state = initialize(options.prologue, options.static.publicKey);
-  let remoteEphemeral;
-  let remoteStatic;
-  return {
-    readMessage1(message) {
-      checkLength(message, "handshake message");
-      const reader = { buffer: message, offset: 0 };
-      const remote = readMessage1(state, reader, { static: options.static });
-      remoteEphemeral = remote.remoteEphemeral;
-      remoteStatic = remote.remoteStatic;
-      const payload = state.decryptAndHash(take(reader, message.length - reader.offset));
-      return { payload, remoteStatic };
-    },
-    writeMessage2(payload) {
-      if (remoteEphemeral === undefined || remoteStatic === undefined)
-        throw new Error("message 2 before message 1");
-      const buffer = [];
-      writeMessage2(state, buffer, { ephemeral }, remoteEphemeral, remoteStatic);
-      buffer.push(state.encryptAndHash(payload));
-      const message = concat(...buffer);
-      checkLength(message, "handshake message");
-      const [receive, send] = state.split();
-      return { message, result: { send, receive, handshakeHash: state.handshakeHash } };
-    }
-  };
-}
-
-// packages/protocol/src/secure-channel.ts
-var SECURE_PROLOGUE = new TextEncoder().encode("pinomad/1");
-var utf8 = new TextEncoder;
-var utf8Decode = new TextDecoder("utf-8", { fatal: true });
-var encodeHostHello = (hello) => utf8.encode(JSON.stringify(hello));
-function decodeJson(bytes) {
-  try {
-    return JSON.parse(utf8Decode.decode(bytes));
-  } catch {
-    throw new Error("handshake payload is not JSON");
-  }
-}
-var isString = (value) => typeof value === "string";
-function decodeClientHello(bytes) {
-  const value = decodeJson(bytes);
-  if (value?.v !== 1)
-    throw new Error("unsupported client hello");
-  const pair = value.pair;
-  if (pair === undefined)
-    return { v: 1 };
-  const secret = pair.secret;
-  const name = pair.name;
-  if (!isString(secret) || !isString(name))
-    throw new Error("malformed pair");
-  return { v: 1, pair: { secret, name } };
-}
-var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-function toBase64Url(bytes) {
-  let out = "";
-  for (let index = 0;index < bytes.length; index += 3) {
-    const a = bytes[index];
-    const b = bytes[index + 1];
-    const c = bytes[index + 2];
-    out += B64_ALPHABET[a >> 2] + B64_ALPHABET[(a & 3) << 4 | (b ?? 0) >> 4];
-    if (b !== undefined)
-      out += B64_ALPHABET[(b & 15) << 2 | (c ?? 0) >> 6];
-    if (c !== undefined)
-      out += B64_ALPHABET[c & 63];
-  }
-  return out;
-}
-function fromBase64Url(text) {
-  if (text.length % 4 === 1)
-    throw new Error("invalid base64url");
-  const lookup = new Map(Array.from(B64_ALPHABET, (char, index) => [char, index]));
-  const bytes = [];
-  for (let index = 0;index < text.length; index += 4) {
-    const quad = text.slice(index, index + 4);
-    const values = [...quad].map((char) => {
-      const value = lookup.get(char);
-      if (value === undefined)
-        throw new Error("invalid base64url");
-      return value;
-    });
-    const packed = values.reduce((bits, value, index2) => bits | value << 18 - index2 * 6, 0);
-    bytes.push(packed >> 16 & 255);
-    if (values.length > 2)
-      bytes.push(packed >> 8 & 255);
-    if (values.length > 3)
-      bytes.push(packed & 255);
-  }
-  return new Uint8Array(bytes);
-}
-var MAX_BODY = 65535 - 16 - 1;
-
-class SecureSession {
-  #send;
-  #receive;
-  #pending = [];
-  constructor(result) {
-    this.#send = result.send;
-    this.#receive = result.receive;
-  }
-  seal(text) {
-    const body = utf8.encode(text);
-    const chunks = [];
-    for (let offset = 0;offset <= body.length; offset += MAX_BODY) {
-      const last = offset + MAX_BODY >= body.length;
-      const record = new Uint8Array(1 + Math.min(MAX_BODY, body.length - offset));
-      record[0] = last ? 0 : 1;
-      record.set(body.subarray(offset, offset + MAX_BODY), 1);
-      chunks.push(this.#send.encrypt(record));
-      if (last)
-        break;
-    }
-    return chunks;
-  }
-  open(chunk) {
-    const record = this.#receive.decrypt(chunk);
-    const flag = record[0];
-    if (flag !== 0 && flag !== 1)
-      throw new Error("bad record flag");
-    this.#pending.push(record.subarray(1));
-    if (flag === 1)
-      return;
-    const whole = concatParts(this.#pending);
-    this.#pending = [];
-    return utf8Decode.decode(whole);
-  }
-}
-function concatParts(parts) {
-  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
-  let offset = 0;
-  for (const part of parts) {
-    out.set(part, offset);
-    offset += part.length;
-  }
-  return out;
-}
-
-// packages/protocol/src/relay.ts
 var RELAY_CLOSE = {
   badSignature: 4601,
   hostNotAllowed: 4603,
@@ -293,10 +18,10 @@ var RELAY_CLOSE = {
 function encodeRelayFrame(frame) {
   return JSON.stringify(frame);
 }
-var isString2 = (value) => typeof value === "string";
+var isString = (value) => typeof value === "string";
 var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-var isBoundedString = (value, max = 64) => isString2(value) && value.length > 0 && value.length <= max;
-function decodeJson2(text) {
+var isBoundedString = (value, max = 64) => isString(value) && value.length > 0 && value.length <= max;
+function decodeJson(text) {
   try {
     return JSON.parse(text);
   } catch {
@@ -304,16 +29,16 @@ function decodeJson2(text) {
   }
 }
 function decodeRelayToHost(text) {
-  const value = decodeJson2(text);
+  const value = decodeJson(text);
   switch (value?.t) {
     case "challenge":
-      if (!isString2(value.nonce))
+      if (!isString(value.nonce))
         throw new Error("malformed challenge");
       return { t: "challenge", nonce: value.nonce };
     case "registered":
       return decodeRegistered(value);
     case "incoming":
-      if (!isString2(value.connId))
+      if (!isString(value.connId))
         throw new Error("malformed incoming");
       return { t: "incoming", connId: value.connId };
     case "pairing-request":
@@ -323,27 +48,27 @@ function decodeRelayToHost(text) {
     case "push-result":
       return decodePushResult(value);
     case "joined":
-      if (!isString2(value.username))
+      if (!isString(value.username))
         throw new Error("malformed joined");
       return { t: "joined", username: value.username };
     case "left":
       return { t: "left" };
     case "refused":
-      if (!isString2(value.reason))
+      if (!isString(value.reason))
         throw new Error("malformed refused");
       return { t: "refused", reason: value.reason };
     default:
       throw new Error("unknown relay frame");
   }
 }
-var isFeatureList = (value) => Array.isArray(value) && value.length <= 16 && value.every((entry) => isString2(entry) && entry.length <= 64);
+var isFeatureList = (value) => Array.isArray(value) && value.length <= 16 && value.every((entry) => isString(entry) && entry.length <= 64);
 function decodeRegistered(value) {
   if (value.features !== undefined && !isFeatureList(value.features))
     throw new Error("malformed registered");
   const declared = value.features === undefined ? {} : { features: value.features };
   if (value.push === undefined)
     return { t: "registered", ...declared };
-  if (!Array.isArray(value.push) || value.push.length > 8 || !value.push.every(isString2)) {
+  if (!Array.isArray(value.push) || value.push.length > 8 || !value.push.every(isString)) {
     throw new Error("malformed registered");
   }
   const push = value.push.filter((entry) => entry === "production" || entry === "development");
@@ -379,8 +104,17 @@ function decodePushResult(value) {
   }
   return { t: "push-result", requestId: value.requestId, result: value.result, reason: value.reason };
 }
+function decodePairingEndpointSet(value) {
+  const parsed = parseEndpointSet(value);
+  if (parsed.kind === "absent" || parsed.kind === "unsupported")
+    return;
+  if (parsed.kind === "malformed" || parsed.endpointSet.endpoints.length === 0) {
+    throw new Error("malformed pairing");
+  }
+  return parsed.endpointSet;
+}
 function decodeHostToRelay(text) {
-  const value = decodeJson2(text);
+  const value = decodeJson(text);
   switch (value?.t) {
     case "register":
       return decodeRegister(value);
@@ -390,7 +124,13 @@ function decodeHostToRelay(text) {
       if (!isBoundedString(value.requestId) || !isBoundedString(value.secret) || typeof value.expiresAt !== "number" || !Number.isFinite(value.expiresAt)) {
         throw new Error("malformed pairing");
       }
-      return { t: "pairing", requestId: value.requestId, secret: value.secret, expiresAt: value.expiresAt };
+      return {
+        t: "pairing",
+        requestId: value.requestId,
+        secret: value.secret,
+        expiresAt: value.expiresAt,
+        ...value.endpointSet === undefined ? {} : { endpointSet: decodePairingEndpointSet(value.endpointSet) }
+      };
     case "pairing-refused":
       if (!isBoundedString(value.requestId) || !isBoundedString(value.reason)) {
         throw new Error("malformed pairing-refused");
@@ -424,18 +164,18 @@ function decodePush(value) {
   };
 }
 function decodeRegister(value) {
-  if (value.t !== "register" || !isString2(value.hostId) || !isString2(value.signature)) {
+  if (value.t !== "register" || !isString(value.hostId) || !isString(value.signature)) {
     throw new Error("malformed register");
   }
   if (value.op !== undefined && value.op !== "join" && value.op !== "leave")
     throw new Error("malformed register");
-  if (value.signatureV2 !== undefined && !isString2(value.signatureV2))
+  if (value.signatureV2 !== undefined && !isString(value.signatureV2))
     throw new Error("malformed register");
-  if (value.noisePublicKey !== undefined && !isString2(value.noisePublicKey))
+  if (value.noisePublicKey !== undefined && !isString(value.noisePublicKey))
     throw new Error("malformed register");
-  if (value.joinToken !== undefined && !isString2(value.joinToken))
+  if (value.joinToken !== undefined && !isString(value.joinToken))
     throw new Error("malformed register");
-  if (value.name !== undefined && !isString2(value.name))
+  if (value.name !== undefined && !isString(value.name))
     throw new Error("malformed register");
   if (value.features !== undefined && !isFeatureList(value.features))
     throw new Error("malformed register");
@@ -456,9 +196,9 @@ function relayHostId(publicKey) {
     throw new Error("Ed25519 public key must be 32 bytes");
   return toBase64Url(publicKey);
 }
-var utf82 = new TextEncoder;
+var utf8 = new TextEncoder;
 function relayChallengeMessage(args) {
-  return utf82.encode(`pinomad-relay/1
+  return utf8.encode(`pinomad-relay/1
 ${args.relayOrigin}
 ${args.hostId}
 ${args.nonce}`);
@@ -474,7 +214,7 @@ function verifyRelayChallenge(signature, args) {
   }
 }
 function relayChallengeMessageV2(args) {
-  return utf82.encode(`pinomad-relay/2
+  return utf8.encode(`pinomad-relay/2
 ${args.relayOrigin}
 ${args.hostId}
 ${args.nonce}
@@ -493,7 +233,7 @@ function verifyRelayChallengeV2(signature, args) {
 
 // apps/host/src/relay-link.ts
 import { randomBytes } from "node:crypto";
-import { WebSocket as WebSocket2 } from "ws";
+import { WebSocket } from "ws";
 function relayWsBase(origin) {
   const normalized = origin.replace(/\/+$/, "");
   if (normalized.startsWith("https://"))
@@ -510,6 +250,8 @@ var REJECTION_REASONS = {
 var PUSH_TIMEOUT_MS = 1e4;
 function startRelayLink(options) {
   const origin = options.origin.replace(/\/+$/, "");
+  if (origin.includes("#"))
+    throw new Error(`relay origin must not include a fragment: ${origin}`);
   const wsBase = relayWsBase(origin);
   const hostId = relayHostId(options.signingKey.publicKey);
   const minDelay = options.reconnectDelayMs?.min ?? 1000;
@@ -536,7 +278,7 @@ function startRelayLink(options) {
   const pingIntervalMs = options.pingIntervalMs ?? 30000;
   const pingTimer = setInterval(() => {
     for (const socket of watched) {
-      if (socket.readyState !== WebSocket2.OPEN)
+      if (socket.readyState !== WebSocket.OPEN)
         continue;
       if (ponged.get(socket) === true) {
         ponged.set(socket, false);
@@ -556,7 +298,7 @@ function startRelayLink(options) {
   function connectControl() {
     if (stopped)
       return;
-    const socket = new WebSocket2(`${wsBase}/host`, { handshakeTimeout: pingIntervalMs });
+    const socket = new WebSocket(`${wsBase}/host`, { handshakeTimeout: pingIntervalMs });
     control = socket;
     pushEnvironments = undefined;
     nameDeclared = false;
@@ -630,11 +372,23 @@ function startRelayLink(options) {
           break;
         }
         accountOffer().then((result) => {
-          if (socket !== control || socket.readyState !== WebSocket2.OPEN)
+          if (socket !== control || socket.readyState !== WebSocket.OPEN)
+            return;
+          const checked = result.ok && result.endpointSet !== undefined ? parseEndpointSet(result.endpointSet) : undefined;
+          if (result.ok && (checked?.kind === "malformed" || checked?.kind === "valid" && checked.endpointSet.endpoints.length === 0)) {
+            refused("invalid_endpoint");
             return;
-          socket.send(encodeRelayFrame(result.ok ? { t: "pairing", requestId: frame.requestId, secret: result.secret, expiresAt: result.expiresAt } : { t: "pairing-refused", requestId: frame.requestId, reason: result.reason }));
+          }
+          const endpointSet = checked?.kind === "valid" ? checked.endpointSet : undefined;
+          socket.send(encodeRelayFrame(result.ok ? {
+            t: "pairing",
+            requestId: frame.requestId,
+            secret: result.secret,
+            expiresAt: result.expiresAt,
+            ...endpointSet === undefined ? {} : { endpointSet }
+          } : { t: "pairing-refused", requestId: frame.requestId, reason: result.reason }));
         }, () => {
-          if (socket === control && socket.readyState === WebSocket2.OPEN)
+          if (socket === control && socket.readyState === WebSocket.OPEN)
             refused("error");
         });
         break;
@@ -643,7 +397,7 @@ function startRelayLink(options) {
         if (pendingAccepts >= maxPendingAccepts)
           break;
         pendingAccepts += 1;
-        const data2 = new WebSocket2(`${wsBase}/accept/${frame.connId}`, { handshakeTimeout: pingIntervalMs });
+        const data2 = new WebSocket(`${wsBase}/accept/${frame.connId}`, { handshakeTimeout: pingIntervalMs });
         watch(data2);
         const release = () => {
           pendingAccepts -= 1;
@@ -686,7 +440,7 @@ function startRelayLink(options) {
     if (name === undefined || name === reportedName)
       return;
     const socket = control;
-    if (socket === undefined || socket.readyState !== WebSocket2.OPEN || !nameDeclared)
+    if (socket === undefined || socket.readyState !== WebSocket.OPEN || !nameDeclared)
       return;
     reportedName = name;
     socket.send(encodeRelayFrame({ t: "name", name }));
@@ -698,7 +452,7 @@ function startRelayLink(options) {
     state: () => state,
     sendPush(request) {
       const socket = control;
-      if (stopped || socket === undefined || socket.readyState !== WebSocket2.OPEN || state.status !== "registered") {
+      if (stopped || socket === undefined || socket.readyState !== WebSocket.OPEN || state.status !== "registered") {
         return Promise.resolve({ result: "retry", reason: "control disconnected" });
       }
       const envs = pushEnvironments;
@@ -737,4 +491,4 @@ function startRelayLink(options) {
   };
 }
 
-export { generateKeyPair, keyPairFromPrivate, respondIK, SECURE_PROLOGUE, encodeHostHello, decodeClientHello, toBase64Url, fromBase64Url, SecureSession, RELAY_CLOSE, encodeRelayFrame, decodeRelayToHost, decodeHostToRelay, relayHostId, signRelayChallenge, verifyRelayChallenge, signRelayChallengeV2, verifyRelayChallengeV2, relayWsBase, startRelayLink };
+export { RELAY_CLOSE, encodeRelayFrame, decodeRelayToHost, decodeHostToRelay, relayHostId, signRelayChallenge, verifyRelayChallenge, signRelayChallengeV2, verifyRelayChallengeV2, relayWsBase, startRelayLink };

package/dist/{chunk-m4c5gvce.js → chunk-mv94ksvb.js}

@@ -1,8 +1,10 @@
 import {
   connectRemoteDurable
-} from "./chunk-sj7rnvh4.js";
-import"./chunk-e4ahjbmz.js";
-import"./chunk-znhn8af7.js";
+} from "./chunk-a4b61tx5.js";
+import"./chunk-jgd38rna.js";
+import {
+  isLoopbackUrl
+} from "./chunk-sygeb9qb.js";
 import {
   hostAddress
 } from "./chunk-ngf1zatm.js";
@@ -10,16 +12,30 @@ import"./chunk-df32avw6.js";
 
 // apps/host/src/cli/pair.ts
 import { renderUnicodeCompact } from "uqr";
+function pairingQr(link) {
+  try {
+    return renderUnicodeCompact(link);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Data too long")
+      return;
+    throw error;
+  }
+}
 async function printPairing({ url, token }) {
   const remote = await connectRemoteDurable({ url, token, reconnectDelayMs: { min: 200, max: 2000 } });
   try {
     const { url: pairing, expiresAt } = await remote.controller.createPairing();
-    if (new URL(pairing).hostname === "127.0.0.1") {
+    if (isLoopbackUrl(pairing)) {
       console.log(pairing);
       console.log("This link only works on this machine — give it to the desktop app.");
       console.log("To pair a phone, restart the host with --remote-port or --relay, then run pair again.");
     } else {
-      console.log(renderUnicodeCompact(pairing));
+      const qr = pairingQr(pairing);
+      if (qr === undefined) {
+        console.log("This link is too long for a QR code. Copy it below and paste it into the app instead.");
+      } else {
+        console.log(qr);
+      }
       console.log(pairing);
     }
     console.log(`Expires at ${new Date(expiresAt).toLocaleTimeString()}`);
@@ -40,5 +56,6 @@ if (false)
   ;
 export {
   printPairing,
+  pairingQr,
   main
 };

package/dist/{chunk-8yme2wep.js → chunk-p15hqqjz.js}

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

package/dist/{chunk-rtwxjb90.js → chunk-p56xf1r8.js}

@@ -1,6 +1,6 @@
 // apps/host/src/distribution.ts
 import { fileURLToPath } from "node:url";
-var packagedVersion = "0.7.0";
+var packagedVersion = "0.8.0";
 var webRoot = fileURLToPath(new URL(packagedVersion === undefined ? "../../web/dist" : "../web/", import.meta.url));
 var hostEntry = packagedVersion === undefined ? { script: fileURLToPath(new URL("./main.ts", import.meta.url)), args: [] } : { script: fileURLToPath(new URL("./pinomad.js", import.meta.url)), args: ["host"] };
 var commandHint = (name) => packagedVersion === undefined ? `bun run ${name}` : `pinomad ${name}`;

package/dist/{chunk-1t58fh0k.js → chunk-ptjyk94f.js}

@@ -2,12 +2,12 @@
 import {
   main,
   restartService
-} from "./chunk-12kaxggg.js";
+} from "./chunk-73vxwjs7.js";
 import"./chunk-kzbzacz9.js";
-import"./chunk-rtwxjb90.js";
-import"./chunk-sj7rnvh4.js";
-import"./chunk-e4ahjbmz.js";
-import"./chunk-znhn8af7.js";
+import"./chunk-p56xf1r8.js";
+import"./chunk-a4b61tx5.js";
+import"./chunk-jgd38rna.js";
+import"./chunk-sygeb9qb.js";
 import"./chunk-ngf1zatm.js";
 import"./chunk-df32avw6.js";
 export {

package/dist/{chunk-0xh6cy9v.js → chunk-r2ssa2ex.js}

@@ -3,7 +3,7 @@ import {
   generateKeyPair,
   keyPairFromPrivate,
   toBase64Url
-} from "./chunk-7qb9tq54.js";
+} from "./chunk-sygeb9qb.js";
 
 // apps/host/src/devices.ts
 import { link, readFile, unlink, writeFile } from "node:fs/promises";