pinomad 0.7.0 → 0.9.0

package/dist/chunk-sygeb9qb.js

@@ -0,0 +1,430 @@
+// packages/protocol/src/endpoints.ts
+var ENDPOINT_SET_SCHEMA_VERSION = 1;
+var MAX_HOST_ENDPOINTS = 4;
+var MAX_HOST_ENDPOINT_URL_LENGTH = 1024;
+function isLoopbackHostname(hostname) {
+  const host = hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+  return host === "localhost" || host.endsWith(".localhost") || host === "::1" || /^127(?:\.\d{1,3}){3}$/.test(host);
+}
+function isLoopbackUrl(url) {
+  try {
+    return isLoopbackHostname(new URL(url).hostname);
+  } catch {
+    return false;
+  }
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isSocketUrl = (value) => {
+  if (value.length === 0)
+    return false;
+  try {
+    const protocol = new URL(value).protocol;
+    return protocol === "ws:" || protocol === "wss:";
+  } catch {
+    return false;
+  }
+};
+function parseEndpointSet(value) {
+  if (value === undefined)
+    return { kind: "absent" };
+  if (!isRecord(value))
+    return { kind: "malformed" };
+  const version = value.schemaVersion;
+  if (typeof version !== "number")
+    return { kind: "malformed" };
+  if (version !== ENDPOINT_SET_SCHEMA_VERSION)
+    return { kind: "unsupported" };
+  const raw = value.endpoints;
+  if (!Array.isArray(raw))
+    return { kind: "malformed" };
+  if (raw.length > MAX_HOST_ENDPOINTS)
+    return { kind: "malformed" };
+  const endpoints = [];
+  const roles = new Map;
+  for (const entry of raw) {
+    if (!isRecord(entry))
+      return { kind: "malformed" };
+    const transport = entry.transport;
+    if (typeof transport !== "string")
+      return { kind: "malformed" };
+    if (transport !== "webSocket")
+      continue;
+    const role = entry.role;
+    if (role !== "direct" && role !== "relay")
+      return { kind: "malformed" };
+    const url = entry.url;
+    if (typeof url !== "string" || url.length > MAX_HOST_ENDPOINT_URL_LENGTH)
+      return { kind: "malformed" };
+    if (!isSocketUrl(url))
+      return { kind: "malformed" };
+    const prior = roles.get(url);
+    if (prior !== undefined) {
+      if (prior !== role)
+        return { kind: "malformed" };
+      continue;
+    }
+    roles.set(url, role);
+    endpoints.push({ transport: "webSocket", role, url });
+  }
+  if (endpoints.length === 0 && raw.length > 0)
+    return { kind: "unsupported" };
+  return { kind: "valid", endpointSet: { schemaVersion: ENDPOINT_SET_SCHEMA_VERSION, endpoints } };
+}
+function encodeEndpointSetParam(endpointSet) {
+  return encodeURIComponent(JSON.stringify(endpointSet));
+}
+
+// packages/protocol/src/settings.ts
+var HOST_SETTING_KEY_SET = {
+  defaultModel: true,
+  defaultThinkingLevel: true,
+  steeringMode: true,
+  followUpMode: true,
+  acceptAccountDevices: true,
+  rtcStun: true,
+  hostName: true
+};
+var HOST_SETTING_KEYS = Object.keys(HOST_SETTING_KEY_SET);
+var THINKING_LEVEL_KEYS = { off: true, minimal: true, low: true, medium: true, high: true, xhigh: true, max: true };
+var THINKING_LEVELS = Object.keys(THINKING_LEVEL_KEYS);
+var isThinkingLevel = (value) => typeof value === "string" && Object.prototype.hasOwnProperty.call(THINKING_LEVEL_KEYS, value);
+var isQueueMode = (value) => value === "all" || value === "one-at-a-time";
+var HOST_NAME_FALLBACK = "pinomad";
+var HOST_NAME_MAX_UNITS = 64;
+var isHostNameControl = (code) => code < 32 || code >= 127 && code <= 159;
+function cleanHostName(name) {
+  let cleaned = name;
+  for (;; ) {
+    const local = cleaned.endsWith(".local") ? cleaned.slice(0, -".local".length) : cleaned;
+    const next = [...local.trim()].filter((c) => !isHostNameControl(c.codePointAt(0))).join("").slice(0, HOST_NAME_MAX_UNITS);
+    if (next === cleaned)
+      return next;
+    cleaned = next;
+  }
+}
+function normalizeHostName(name) {
+  const cleaned = cleanHostName(name);
+  return cleaned === "" ? HOST_NAME_FALLBACK : cleaned;
+}
+
+// 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 writeMessage1(state, buffer, own, remoteStatic) {
+  buffer.push(own.ephemeral.publicKey);
+  state.mixHash(own.ephemeral.publicKey);
+  state.mixKey(dh(own.ephemeral, remoteStatic));
+  buffer.push(state.encryptAndHash(own.static.publicKey));
+  state.mixKey(dh(own.static, remoteStatic));
+}
+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));
+}
+function readMessage2Tokens(state, message, own) {
+  const remoteEphemeral = take(message, KEY_LENGTH).slice();
+  state.mixHash(remoteEphemeral);
+  state.mixKey(dh(own.ephemeral, remoteEphemeral));
+  state.mixKey(dh(own.static, remoteEphemeral));
+  return remoteEphemeral;
+}
+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 initiateIK(options) {
+  const ephemeral = options.ephemeral ?? generateKeyPair();
+  const state = initialize(options.prologue, options.remoteStatic);
+  return {
+    writeMessage1(payload) {
+      const buffer = [];
+      writeMessage1(state, buffer, { static: options.static, ephemeral }, options.remoteStatic);
+      buffer.push(state.encryptAndHash(payload));
+      const message = concat(...buffer);
+      checkLength(message, "handshake message");
+      return message;
+    },
+    readMessage2(message) {
+      checkLength(message, "handshake message");
+      const reader = { buffer: message, offset: 0 };
+      readMessage2Tokens(state, reader, { ephemeral, static: options.static });
+      const payload = state.decryptAndHash(take(reader, message.length - reader.offset));
+      const [send, receive] = state.split();
+      return { payload, result: { send, receive, handshakeHash: state.handshakeHash } };
+    }
+  };
+}
+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 SIGNAL_PROLOGUE = new TextEncoder().encode("pinomad-signal/1");
+var utf8 = new TextEncoder;
+var utf8Decode = new TextDecoder("utf-8", { fatal: true });
+var encodeClientHello = (hello) => utf8.encode(JSON.stringify(hello));
+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 } };
+}
+function decodeHostHello(bytes) {
+  const value = decodeJson(bytes);
+  if (value?.v !== 1)
+    throw new Error("unsupported host hello");
+  return { v: 1 };
+}
+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;
+}
+
+export { ENDPOINT_SET_SCHEMA_VERSION, MAX_HOST_ENDPOINT_URL_LENGTH, isLoopbackUrl, parseEndpointSet, encodeEndpointSetParam, HOST_SETTING_KEYS, THINKING_LEVELS, isThinkingLevel, isQueueMode, HOST_NAME_MAX_UNITS, cleanHostName, normalizeHostName, generateKeyPair, keyPairFromPrivate, initiateIK, respondIK, SECURE_PROLOGUE, SIGNAL_PROLOGUE, encodeClientHello, encodeHostHello, decodeClientHello, decodeHostHello, toBase64Url, fromBase64Url, SecureSession };

package/dist/{chunk-b1h374jr.js → chunk-v414b5pp.js}

@@ -1,10 +1,13 @@
+import {
+  RTC_DEFAULT_STUN
+} from "./chunk-jgd38rna.js";
 import {
   HOST_SETTING_KEYS,
   cleanHostName,
   isQueueMode,
   isThinkingLevel,
   normalizeHostName
-} from "./chunk-znhn8af7.js";
+} from "./chunk-sygeb9qb.js";
 
 // apps/host/src/host-value.ts
 function constantValue(value) {
@@ -63,12 +66,14 @@ var fileValueError = (key, value, models) => {
       return isQueueMode(value) ? undefined : "malformed";
     case "acceptAccountDevices":
       return typeof value === "boolean" ? undefined : "malformed";
+    case "rtcStun":
+      return Array.isArray(value) && value.every((entry) => typeof entry === "string" && entry !== "") ? undefined : "malformed";
     case "hostName":
       return typeof value === "string" ? undefined : "malformed";
   }
 };
 var sameModel = (a, b) => a === b || a !== null && b !== null && a.provider === b.provider && a.modelId === b.modelId;
-var sameSettings = (a, b) => a.steeringMode === b.steeringMode && a.followUpMode === b.followUpMode && a.acceptAccountDevices === b.acceptAccountDevices && a.defaultThinkingLevel === b.defaultThinkingLevel && sameModel(a.defaultModel, b.defaultModel) && a.hostName === b.hostName && sameList(a.custom, b.custom, (x, y) => x === y);
+var sameSettings = (a, b) => a.steeringMode === b.steeringMode && a.followUpMode === b.followUpMode && a.acceptAccountDevices === b.acceptAccountDevices && a.defaultThinkingLevel === b.defaultThinkingLevel && sameModel(a.defaultModel, b.defaultModel) && (a.rtcStun === undefined || b.rtcStun === undefined ? a.rtcStun === b.rtcStun : sameList(a.rtcStun, b.rtcStun, (x, y) => x === y)) && a.hostName === b.hostName && sameList(a.custom, b.custom, (x, y) => x === y);
 var parse = (path, text) => {
   let parsed;
   try {
@@ -113,6 +118,7 @@ async function openHostSettings(options) {
       steeringMode: fileValues.steeringMode ?? fallback.steeringMode(),
       followUpMode: fileValues.followUpMode ?? fallback.followUpMode(),
       acceptAccountDevices: fileValues.acceptAccountDevices ?? true,
+      rtcStun: fileValues.rtcStun ?? RTC_DEFAULT_STUN,
       hostName: normalizeHostName(fileValues.hostName ?? hostname()),
       custom
     };

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

@@ -1,8 +1,10 @@
 import {
   connectRemoteDurable
-} from "./chunk-sj7rnvh4.js";
-import"./chunk-e4ahjbmz.js";
-import"./chunk-znhn8af7.js";
+} from "./chunk-4sepcfpy.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
 };