pinomad 0.5.0 → 0.7.0

package/dist/chunk-1t58fh0k.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import {
+  main,
+  restartService
+} from "./chunk-12kaxggg.js";
+import"./chunk-kzbzacz9.js";
+import"./chunk-rtwxjb90.js";
+import"./chunk-sj7rnvh4.js";
+import"./chunk-e4ahjbmz.js";
+import"./chunk-znhn8af7.js";
+import"./chunk-ngf1zatm.js";
+import"./chunk-df32avw6.js";
+export {
+  restartService,
+  main
+};

package/dist/{chunk-4by4x5c4.js → chunk-6ysezfy5.js}

@@ -9,11 +9,14 @@ import {
   relayWsBase,
   verifyRelayChallenge,
   verifyRelayChallengeV2
-} from "./chunk-kmbh44dt.js";
+} from "./chunk-7qb9tq54.js";
 import {
   commandHint,
   webRoot
-} from "./chunk-1d9sppj0.js";
+} from "./chunk-rtwxjb90.js";
+import {
+  normalizeHostName
+} from "./chunk-znhn8af7.js";
 import"./chunk-df32avw6.js";
 
 // apps/server/src/main.ts
@@ -325,7 +328,7 @@ async function openAccounts(options) {
           db.exec("ROLLBACK");
           return { status: "refused", reason: failure };
         }
-        const hostName = name === undefined || name.trim() === "" ? "Unknown host" : name.trim().slice(0, 64);
+        const hostName = name === undefined ? "Unknown host" : normalizeHostName(name);
         db.prepare(`INSERT INTO hosts (host_id, user_id, noise_public_key, name, joined_at, last_seen_at)
            VALUES (?, ?, ?, ?, ?, ?)
            ON CONFLICT(host_id) DO UPDATE SET
@@ -358,6 +361,9 @@ async function openAccounts(options) {
     markHostSeen(hostId) {
       db.prepare("UPDATE hosts SET last_seen_at = ? WHERE host_id = ?").run(now(), hostId);
     },
+    renameHost(hostId, name) {
+      db.prepare("UPDATE hosts SET name = ? WHERE host_id = ?").run(normalizeHostName(name), hostId);
+    },
     async close() {
       db.close();
       await release();
@@ -396,7 +402,7 @@ async function changePassword(options) {
 
 // apps/server/src/apns.ts
 import { createPrivateKey, sign } from "node:crypto";
-import { connect } from "node:http2";
+import { connect, constants } from "node:http2";
 var AUTHORITIES = {
   production: "https://api.push.apple.com",
   development: "https://api.sandbox.push.apple.com"
@@ -465,19 +471,25 @@ function openApns(config) {
     state.token = { jwt, issuedAt: now };
     return jwt;
   };
+  const dropSession = (state, session) => {
+    if (state.session === session)
+      state.session = undefined;
+    if (!session.destroyed)
+      session.destroy();
+  };
+  const retireSession = (state, session) => {
+    if (state.session === session)
+      state.session = undefined;
+    if (!session.closed && !session.destroyed)
+      session.close();
+  };
   const sessionFor = (environment, state) => {
     const existing = state.session;
     if (existing !== undefined && !existing.destroyed && !existing.closed)
       return existing;
     const session = connect(state.authority);
-    const drop = () => {
-      if (state.session === session)
-        state.session = undefined;
-      if (!session.destroyed)
-        session.destroy();
-    };
-    session.once("goaway", drop);
-    session.once("error", drop);
+    session.once("goaway", () => dropSession(state, session));
+    session.once("error", () => dropSession(state, session));
     session.once("close", () => {
       if (state.session === session)
         state.session = undefined;
@@ -560,6 +572,7 @@ function openApns(config) {
           resolve({ result: "retry", reason: "session unavailable" });
           return;
         }
+        let responded = false;
         let status = 0;
         let responseHeaders = {};
         const chunks = [];
@@ -574,11 +587,16 @@ function openApns(config) {
         };
         const timer = setTimeout(() => finish({ result: "retry", reason: "apns timeout" }), REQUEST_TIMEOUT_MS);
         stream.on("response", (headers) => {
+          responded = true;
           status = Number(headers[":status"] ?? 0);
           responseHeaders = headers;
         });
         stream.on("data", (chunk) => chunks.push(chunk));
         stream.on("end", () => {
+          if (!responded) {
+            finish({ result: "retry", reason: "connection closed" });
+            return;
+          }
           let body2;
           try {
             body2 = JSON.parse(Buffer.concat(chunks).toString("utf8"));
@@ -587,7 +605,12 @@ function openApns(config) {
           }
           finish(classify(request.environment, status, responseHeaders, body2, state));
         });
-        stream.on("error", () => finish({ result: "retry", reason: "connection error" }));
+        stream.on("error", () => {
+          const refused = stream.rstCode === constants.NGHTTP2_REFUSED_STREAM;
+          finish({ result: "retry", reason: "connection error" });
+          if (refused)
+            retireSession(state, session);
+        });
         stream.on("aborted", () => finish({ result: "retry", reason: "connection aborted" }));
         stream.end(body);
       });
@@ -1041,6 +1064,11 @@ async function startRelay(options) {
           handlePush(socket, hostId, answer);
           return;
         }
+        if (answer.t === "name") {
+          if (controls.get(hostId)?.socket === socket)
+            accounts?.renameHost(hostId, answer.name);
+          return;
+        }
         if (answer.t === "pairing" || answer.t === "pairing-refused") {
           const request = pairingRequests.get(answer.requestId);
           if (request === undefined || request.control !== socket)
@@ -1097,7 +1125,9 @@ async function startRelay(options) {
         ...frame.features === undefined ? {} : { features: frame.features }
       });
       accounts?.markHostSeen(hostId);
-      socket.send(encodeRelayFrame({ t: "registered", push: pushEnvironments }));
+      if (frame.name !== undefined)
+        accounts?.renameHost(hostId, frame.name);
+      socket.send(encodeRelayFrame({ t: "registered", push: pushEnvironments, features: ["name"] }));
     });
     socket.once("close", () => {
       clearTimeout(deadline);

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

@@ -1,3 +1,7 @@
+import {
+  HOST_NAME_MAX_UNITS
+} from "./chunk-znhn8af7.js";
+
 // packages/protocol/src/relay.ts
 import { ed25519 } from "@noble/curves/ed25519.js";
 
@@ -332,14 +336,18 @@ function decodeRelayToHost(text) {
       throw new Error("unknown relay frame");
   }
 }
+var isFeatureList = (value) => Array.isArray(value) && value.length <= 16 && value.every((entry) => isString2(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" };
+    return { t: "registered", ...declared };
   if (!Array.isArray(value.push) || value.push.length > 8 || !value.push.every(isString2)) {
     throw new Error("malformed registered");
   }
   const push = value.push.filter((entry) => entry === "production" || entry === "development");
-  return { t: "registered", push };
+  return { t: "registered", push, ...declared };
 }
 function decodePushResult(value) {
   if (!isBoundedString(value.requestId) || !isBoundedString(value.reason, 256) || value.result !== "accepted" && value.result !== "unregistered" && value.result !== "retry" && value.result !== "rejected" && value.result !== "unavailable") {
@@ -388,6 +396,10 @@ function decodeHostToRelay(text) {
         throw new Error("malformed pairing-refused");
       }
       return { t: "pairing-refused", requestId: value.requestId, reason: value.reason };
+    case "name":
+      if (!isBoundedString(value.name, HOST_NAME_MAX_UNITS))
+        throw new Error("malformed name");
+      return { t: "name", name: value.name };
     default:
       throw new Error("unknown host frame");
   }
@@ -425,9 +437,8 @@ function decodeRegister(value) {
     throw new Error("malformed register");
   if (value.name !== undefined && !isString2(value.name))
     throw new Error("malformed register");
-  if (value.features !== undefined && (!Array.isArray(value.features) || value.features.length > 16 || !value.features.every((feature) => isString2(feature) && feature.length <= 64))) {
+  if (value.features !== undefined && !isFeatureList(value.features))
     throw new Error("malformed register");
-  }
   return {
     t: "register",
     hostId: value.hostId,
@@ -511,6 +522,8 @@ function startRelayLink(options) {
   let retryTimer;
   let pendingAccepts = 0;
   let pushEnvironments;
+  let reportedName;
+  let nameDeclared = false;
   const pushes = new Map;
   function setState(next) {
     const changed = state.status !== next.status || state.status === "rejected" && next.status === "rejected" && state.reason !== next.reason;
@@ -546,6 +559,8 @@ function startRelayLink(options) {
     const socket = new WebSocket2(`${wsBase}/host`, { handshakeTimeout: pingIntervalMs });
     control = socket;
     pushEnvironments = undefined;
+    nameDeclared = false;
+    reportedName = undefined;
     watch(socket);
     socket.on("message", (data, isBinary) => onControlMessage(socket, data, isBinary));
     socket.once("close", (code) => onControlClosed(socket, code));
@@ -572,21 +587,30 @@ function startRelayLink(options) {
       case "challenge": {
         const noisePublicKey = toBase64Url(options.noisePublicKey);
         const challenge = { relayOrigin: origin, hostId, nonce: frame.nonce };
+        reportedName = options.hostName?.value;
         socket.send(encodeRelayFrame({
           t: "register",
           hostId,
           signature: signRelayChallenge(options.signingKey.secretKey, challenge),
           signatureV2: signRelayChallengeV2(options.signingKey.secretKey, { ...challenge, noisePublicKey }),
           noisePublicKey,
-          ...options.accountOffer === undefined ? {} : { features: ["pairing"] }
+          ...options.accountOffer === undefined ? {} : { features: ["pairing"] },
+          ...reportedName === undefined ? {} : { name: reportedName }
         }));
         break;
       }
-      case "registered":
+      case "registered": {
         delay = minDelay;
         pushEnvironments = frame.push;
+        nameDeclared = frame.features?.includes("name") === true;
+        const current = options.hostName?.value;
+        if (nameDeclared && current !== undefined && current !== reportedName) {
+          reportedName = current;
+          socket.send(encodeRelayFrame({ t: "name", name: current }));
+        }
         setState({ status: "registered", ...frame.push === undefined ? {} : { push: frame.push } });
         break;
+      }
       case "push-result": {
         const request = pushes.get(frame.requestId);
         if (request === undefined || request.socket !== socket)
@@ -636,6 +660,8 @@ function startRelayLink(options) {
   function onControlClosed(socket, code) {
     control = undefined;
     pushEnvironments = undefined;
+    nameDeclared = false;
+    reportedName = undefined;
     for (const [requestId, request] of pushes) {
       if (request.socket === socket) {
         pushes.delete(requestId);
@@ -656,6 +682,15 @@ function startRelayLink(options) {
     reconnect(delay);
     delay = Math.min(maxDelay, delay * 2);
   }
+  const detachName = options.hostName?.subscribe((name) => {
+    if (name === undefined || name === reportedName)
+      return;
+    const socket = control;
+    if (socket === undefined || socket.readyState !== WebSocket2.OPEN || !nameDeclared)
+      return;
+    reportedName = name;
+    socket.send(encodeRelayFrame({ t: "name", name }));
+  });
   connectControl();
   return {
     hostId,
@@ -694,6 +729,7 @@ function startRelayLink(options) {
       if (retryTimer !== undefined)
         clearTimeout(retryTimer);
       clearInterval(pingTimer);
+      detachName?.();
       for (const socket of watched)
         socket.terminate();
       return Promise.resolve();

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

@@ -1,9 +1,9 @@
 import {
   packagedVersion
-} from "./chunk-1d9sppj0.js";
+} from "./chunk-rtwxjb90.js";
 import {
   hostAddress
-} from "./chunk-cjfmfyjb.js";
+} from "./chunk-ngf1zatm.js";
 import"./chunk-df32avw6.js";
 
 // apps/host/src/cli/web-link.ts

package/dist/chunk-b1h374jr.js

@@ -0,0 +1,159 @@
+import {
+  HOST_SETTING_KEYS,
+  cleanHostName,
+  isQueueMode,
+  isThinkingLevel,
+  normalizeHostName
+} from "./chunk-znhn8af7.js";
+
+// apps/host/src/host-value.ts
+function constantValue(value) {
+  return {
+    value,
+    subscribe: () => () => {}
+  };
+}
+
+class Published {
+  #listeners = new Set;
+  #equal;
+  #value;
+  constructor(value, equal) {
+    this.#value = value;
+    this.#equal = equal;
+  }
+  get value() {
+    return this.#value;
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  set(next) {
+    if (this.#equal(this.#value, next))
+      return;
+    this.#value = next;
+    for (const listener of this.#listeners)
+      listener(next);
+  }
+}
+var sameList = (a, b, same) => a.length === b.length && a.every((entry, index) => same(entry, b[index]));
+
+// apps/host/src/host-settings.ts
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { hostname } from "node:os";
+import { dirname } from "node:path";
+function settingsDefaults(settings) {
+  return {
+    ...settings.defaultModel === null ? {} : { model: settings.defaultModel },
+    ...settings.defaultThinkingLevel === null ? {} : { thinkingLevel: settings.defaultThinkingLevel }
+  };
+}
+var isModelRef = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.provider === "string" && value.provider !== "" && typeof value.modelId === "string" && value.modelId !== "";
+var fileValueError = (key, value, models) => {
+  switch (key) {
+    case "defaultModel":
+      if (!isModelRef(value))
+        return "malformed";
+      return models.some((each) => each.provider === value.provider && each.modelId === value.modelId) ? undefined : "unavailable";
+    case "defaultThinkingLevel":
+      return isThinkingLevel(value) ? undefined : "malformed";
+    case "steeringMode":
+    case "followUpMode":
+      return isQueueMode(value) ? undefined : "malformed";
+    case "acceptAccountDevices":
+      return typeof value === "boolean" ? 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 parse = (path, text) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Invalid settings file ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Invalid settings file ${path}: expected a JSON object`);
+  }
+  return parsed;
+};
+async function openHostSettings(options) {
+  const read = () => readFile(options.path, "utf8").then((text) => parse(options.path, text), (error) => {
+    if (error.code === "ENOENT")
+      return {};
+    throw new Error(`Cannot read settings file ${options.path}: ${error instanceof Error ? error.message : String(error)}`);
+  });
+  let file = await read();
+  const warned = new Set;
+  const compute = () => {
+    const fileValues = {};
+    const custom = [];
+    for (const key of HOST_SETTING_KEYS) {
+      if (!Object.hasOwn(file, key))
+        continue;
+      const value = file[key];
+      const invalid = fileValueError(key, value, options.models.value);
+      if (invalid === "malformed" && !warned.has(key)) {
+        warned.add(key);
+        console.error(`${options.path}: ignoring invalid value for settings key "${key}": ${JSON.stringify(value)}`);
+      }
+      if (invalid !== undefined)
+        continue;
+      fileValues[key] = value;
+      custom.push(key);
+    }
+    const { fallback } = options;
+    return {
+      defaultModel: fileValues.defaultModel ?? fallback.defaultModel(),
+      defaultThinkingLevel: fileValues.defaultThinkingLevel ?? fallback.defaultThinkingLevel(),
+      steeringMode: fileValues.steeringMode ?? fallback.steeringMode(),
+      followUpMode: fileValues.followUpMode ?? fallback.followUpMode(),
+      acceptAccountDevices: fileValues.acceptAccountDevices ?? true,
+      hostName: normalizeHostName(fileValues.hostName ?? hostname()),
+      custom
+    };
+  };
+  const published = new Published(compute(), sameSettings);
+  options.models.subscribe(() => published.set(compute()));
+  let tail = Promise.resolve();
+  const write = async (patch) => {
+    const model = patch.defaultModel;
+    if (model !== undefined && model !== null && !options.models.value.some((each) => each.provider === model.provider && each.modelId === model.modelId)) {
+      throw new Error(`Unknown model: ${model.provider}/${model.modelId}`);
+    }
+    const name = patch.hostName;
+    if (name !== undefined && name !== null && cleanHostName(name) === "") {
+      throw new Error(`Invalid host name: ${JSON.stringify(name)}`);
+    }
+    const next = { ...await read() };
+    for (const key of HOST_SETTING_KEYS) {
+      const value = patch[key];
+      if (value === undefined)
+        continue;
+      if (value === null)
+        delete next[key];
+      else
+        next[key] = key === "hostName" ? cleanHostName(value) : value;
+    }
+    const tmp = `${options.path}.tmp`;
+    await mkdir(dirname(options.path), { recursive: true });
+    await writeFile(tmp, `${JSON.stringify(next, null, 2)}
+`, { mode: 384 });
+    await rename(tmp, options.path);
+    file = next;
+    published.set(compute());
+  };
+  return {
+    get value() {
+      return published.value;
+    },
+    subscribe: (listener) => published.subscribe(listener),
+    update: (patch) => tail = tail.then(() => write(patch), () => write(patch))
+  };
+}
+
+export { constantValue, Published, sameList, settingsDefaults, openHostSettings };