pinomad 0.4.0 → 0.6.0

package/dist/{chunk-7gmkgyaz.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";
 
@@ -290,6 +294,7 @@ function encodeRelayFrame(frame) {
   return JSON.stringify(frame);
 }
 var isString2 = (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) {
   try {
@@ -306,7 +311,7 @@ function decodeRelayToHost(text) {
         throw new Error("malformed challenge");
       return { t: "challenge", nonce: value.nonce };
     case "registered":
-      return { t: "registered" };
+      return decodeRegistered(value);
     case "incoming":
       if (!isString2(value.connId))
         throw new Error("malformed incoming");
@@ -315,6 +320,8 @@ function decodeRelayToHost(text) {
       if (!isBoundedString(value.requestId))
         throw new Error("malformed pairing-request");
       return { t: "pairing-request", requestId: value.requestId };
+    case "push-result":
+      return decodePushResult(value);
     case "joined":
       if (!isString2(value.username))
         throw new Error("malformed joined");
@@ -329,11 +336,56 @@ 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", ...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, ...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") {
+    throw new Error("malformed push-result");
+  }
+  if (value.result === "unregistered") {
+    if (typeof value.unregisteredAt !== "number" || !Number.isFinite(value.unregisteredAt)) {
+      throw new Error("malformed push-result");
+    }
+    return {
+      t: "push-result",
+      requestId: value.requestId,
+      result: "unregistered",
+      reason: value.reason,
+      unregisteredAt: value.unregisteredAt
+    };
+  }
+  if (value.result === "retry") {
+    if (value.retryAfterMs !== undefined && (typeof value.retryAfterMs !== "number" || !Number.isFinite(value.retryAfterMs))) {
+      throw new Error("malformed push-result");
+    }
+    return {
+      t: "push-result",
+      requestId: value.requestId,
+      result: "retry",
+      reason: value.reason,
+      ...value.retryAfterMs === undefined ? {} : { retryAfterMs: value.retryAfterMs }
+    };
+  }
+  return { t: "push-result", requestId: value.requestId, result: value.result, reason: value.reason };
+}
 function decodeHostToRelay(text) {
   const value = decodeJson2(text);
   switch (value?.t) {
     case "register":
       return decodeRegister(value);
+    case "push":
+      return decodePush(value);
     case "pairing":
       if (!isBoundedString(value.requestId) || !isBoundedString(value.secret) || typeof value.expiresAt !== "number" || !Number.isFinite(value.expiresAt)) {
         throw new Error("malformed pairing");
@@ -344,10 +396,33 @@ 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");
   }
 }
+function decodePush(value) {
+  const n = value.notification;
+  if (!isBoundedString(value.requestId) || !isBoundedString(value.token, 256) || value.environment !== "production" && value.environment !== "development" || !isRecord(n) || !isBoundedString(n.title, 512) || !isBoundedString(n.body, 256) || !isBoundedString(n.collapseId, 64) || !isBoundedString(n.hostKey, 64) || typeof n.conversationId !== "number" || !Number.isSafeInteger(n.conversationId) || n.conversationId < 1) {
+    throw new Error("malformed push");
+  }
+  return {
+    t: "push",
+    requestId: value.requestId,
+    token: value.token,
+    environment: value.environment,
+    notification: {
+      title: n.title,
+      body: n.body,
+      collapseId: n.collapseId,
+      hostKey: n.hostKey,
+      conversationId: n.conversationId
+    }
+  };
+}
 function decodeRegister(value) {
   if (value.t !== "register" || !isString2(value.hostId) || !isString2(value.signature)) {
     throw new Error("malformed register");
@@ -362,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,
@@ -417,4 +491,250 @@ function verifyRelayChallengeV2(signature, args) {
   }
 }
 
-export { generateKeyPair, keyPairFromPrivate, respondIK, SECURE_PROLOGUE, encodeHostHello, decodeClientHello, toBase64Url, fromBase64Url, SecureSession, RELAY_CLOSE, encodeRelayFrame, decodeRelayToHost, decodeHostToRelay, relayHostId, signRelayChallenge, verifyRelayChallenge, signRelayChallengeV2, verifyRelayChallengeV2 };
+// apps/host/src/relay-link.ts
+import { randomBytes } from "node:crypto";
+import { WebSocket as WebSocket2 } from "ws";
+function relayWsBase(origin) {
+  const normalized = origin.replace(/\/+$/, "");
+  if (normalized.startsWith("https://"))
+    return `wss://${normalized.slice("https://".length)}`;
+  if (normalized.startsWith("http://"))
+    return `ws://${normalized.slice("http://".length)}`;
+  throw new Error(`relay origin must be an http(s) URL: ${origin}`);
+}
+var REJECTION_REASONS = {
+  [RELAY_CLOSE.badSignature]: () => `the relay rejected this host's registration signature — a version mismatch?`,
+  [RELAY_CLOSE.hostNotAllowed]: (hostId) => `the server does not allow this host (${hostId}); join it to an account with \`pinomad join\``,
+  [RELAY_CLOSE.replaced]: () => `the relay replaced this control connection — another process registered the same hostId`
+};
+var PUSH_TIMEOUT_MS = 1e4;
+function startRelayLink(options) {
+  const origin = options.origin.replace(/\/+$/, "");
+  const wsBase = relayWsBase(origin);
+  const hostId = relayHostId(options.signingKey.publicKey);
+  const minDelay = options.reconnectDelayMs?.min ?? 1000;
+  const maxDelay = options.reconnectDelayMs?.max ?? 30000;
+  const maxPendingAccepts = options.maxPendingAccepts ?? 16;
+  let state = { status: "connecting" };
+  let stopped = false;
+  let control;
+  let delay = minDelay;
+  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;
+    state = next;
+    if (changed)
+      options.onStateChange?.(next);
+  }
+  const watched = new Set;
+  const ponged = new WeakMap;
+  const pingIntervalMs = options.pingIntervalMs ?? 30000;
+  const pingTimer = setInterval(() => {
+    for (const socket of watched) {
+      if (socket.readyState !== WebSocket2.OPEN)
+        continue;
+      if (ponged.get(socket) === true) {
+        ponged.set(socket, false);
+        socket.ping();
+      } else {
+        socket.terminate();
+      }
+    }
+  }, pingIntervalMs);
+  function watch(socket) {
+    watched.add(socket);
+    ponged.set(socket, true);
+    socket.on("pong", () => ponged.set(socket, true));
+    socket.once("close", () => watched.delete(socket));
+    socket.on("error", () => socket.terminate());
+  }
+  function connectControl() {
+    if (stopped)
+      return;
+    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));
+  }
+  function reconnect(at) {
+    if (stopped || retryTimer !== undefined)
+      return;
+    retryTimer = setTimeout(() => {
+      retryTimer = undefined;
+      connectControl();
+    }, at);
+  }
+  function onControlMessage(socket, data, isBinary) {
+    let frame;
+    try {
+      if (isBinary)
+        throw new Error("binary control frame");
+      frame = decodeRelayToHost(data.toString());
+    } catch {
+      socket.close();
+      return;
+    }
+    switch (frame.t) {
+      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"] },
+          ...reportedName === undefined ? {} : { name: reportedName }
+        }));
+        break;
+      }
+      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)
+          break;
+        pushes.delete(frame.requestId);
+        const { t: _t, requestId: _id, ...verdict } = frame;
+        request.settle(verdict);
+        break;
+      }
+      case "pairing-request": {
+        const accountOffer = options.accountOffer;
+        const refused = (reason) => {
+          socket.send(encodeRelayFrame({ t: "pairing-refused", requestId: frame.requestId, reason }));
+        };
+        if (accountOffer === undefined) {
+          refused("unavailable");
+          break;
+        }
+        accountOffer().then((result) => {
+          if (socket !== control || socket.readyState !== WebSocket2.OPEN)
+            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 }));
+        }, () => {
+          if (socket === control && socket.readyState === WebSocket2.OPEN)
+            refused("error");
+        });
+        break;
+      }
+      case "incoming": {
+        if (pendingAccepts >= maxPendingAccepts)
+          break;
+        pendingAccepts += 1;
+        const data2 = new WebSocket2(`${wsBase}/accept/${frame.connId}`, { handshakeTimeout: pingIntervalMs });
+        watch(data2);
+        const release = () => {
+          pendingAccepts -= 1;
+          clearTimeout(ageOut);
+          data2.off("close", release);
+        };
+        const ageOut = setTimeout(release, 1e4);
+        data2.once("close", release);
+        options.accept(data2);
+        break;
+      }
+    }
+  }
+  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);
+        request.settle({ result: "retry", reason: "control closed" });
+      }
+    }
+    if (stopped)
+      return;
+    const rejection = REJECTION_REASONS[code];
+    if (rejection !== undefined) {
+      const reason = `relay ${origin}: ${rejection(hostId)} (${code})`;
+      setState({ status: "rejected", reason });
+      delay = maxDelay;
+      reconnect(maxDelay);
+      return;
+    }
+    setState({ status: "connecting" });
+    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,
+    origin,
+    state: () => state,
+    sendPush(request) {
+      const socket = control;
+      if (stopped || socket === undefined || socket.readyState !== WebSocket2.OPEN || state.status !== "registered") {
+        return Promise.resolve({ result: "retry", reason: "control disconnected" });
+      }
+      const envs = pushEnvironments;
+      if (envs === undefined) {
+        return Promise.resolve({ result: "unavailable", reason: "server does not declare push" });
+      }
+      if (!envs.includes(request.environment)) {
+        return Promise.resolve({ result: "unavailable", reason: `environment ${request.environment} not declared` });
+      }
+      return new Promise((resolve) => {
+        const requestId = randomBytes(16).toString("base64url");
+        const timer = setTimeout(() => {
+          if (pushes.delete(requestId))
+            resolve({ result: "retry", reason: "timeout" });
+        }, PUSH_TIMEOUT_MS);
+        pushes.set(requestId, {
+          socket,
+          settle: (verdict) => {
+            clearTimeout(timer);
+            resolve(verdict);
+          }
+        });
+        socket.send(encodeRelayFrame({ t: "push", requestId, ...request }));
+      });
+    },
+    close() {
+      stopped = true;
+      if (retryTimer !== undefined)
+        clearTimeout(retryTimer);
+      clearInterval(pingTimer);
+      detachName?.();
+      for (const socket of watched)
+        socket.terminate();
+      return Promise.resolve();
+    }
+  };
+}
+
+export { generateKeyPair, keyPairFromPrivate, respondIK, SECURE_PROLOGUE, encodeHostHello, decodeClientHello, toBase64Url, fromBase64Url, SecureSession, RELAY_CLOSE, encodeRelayFrame, decodeRelayToHost, decodeHostToRelay, relayHostId, signRelayChallenge, verifyRelayChallenge, signRelayChallengeV2, verifyRelayChallengeV2, relayWsBase, startRelayLink };

package/dist/{chunk-d4y99pfy.js → chunk-7s1f4z4g.js}

@@ -1,10 +1,11 @@
 import {
   connectRemoteDurable
-} from "./chunk-374zqx5h.js";
-import"./chunk-myjp910s.js";
+} from "./chunk-d93kvxvc.js";
+import"./chunk-n4tjhcb7.js";
+import"./chunk-znhn8af7.js";
 import {
   hostAddress
-} from "./chunk-cjfmfyjb.js";
+} from "./chunk-ngf1zatm.js";
 import"./chunk-df32avw6.js";
 
 // apps/host/src/cli/pair.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 };

package/dist/{chunk-fgx2sh7d.js → chunk-c8nxym2z.js}

@@ -1,6 +1,6 @@
 // apps/host/src/distribution.ts
 import { fileURLToPath } from "node:url";
-var packagedVersion = "0.4.0";
+var packagedVersion = "0.6.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-akgxwg8f.js → chunk-d5ypmmr7.js}

@@ -1,15 +1,19 @@
+import {
+  isParseArgsError
+} from "./chunk-kzbzacz9.js";
 import {
   commandHint,
   hostEntry,
   packagedVersion
-} from "./chunk-fgx2sh7d.js";
+} from "./chunk-c8nxym2z.js";
 import {
+  ProtocolMismatchError,
   connectRemoteDurable
-} from "./chunk-374zqx5h.js";
+} from "./chunk-d93kvxvc.js";
 import {
   DEFAULT_DATA_DIR,
   hostAddress
-} from "./chunk-cjfmfyjb.js";
+} from "./chunk-ngf1zatm.js";
 
 // apps/host/src/cli/service.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -375,7 +379,7 @@ function serviceManager(platform = process.platform) {
 var run2 = promisify2(execFile2);
 var repoRoot = fileURLToPath(new URL("../../../../", import.meta.url));
 var message = (error) => error instanceof Error ? error.message : String(error);
-function connect(url, token, timeoutMs = 3000) {
+function connectToHost(url, token, timeoutMs = 3000) {
   const connecting = connectRemoteDurable({ url, token, reconnectDelayMs: { min: 200, max: 2000 } });
   const timedOut = Symbol("timedOut");
   return Promise.race([
@@ -416,7 +420,7 @@ async function status(argv) {
   }
   try {
     const { url, token } = await hostAddress(argv);
-    const remote = await connect(url, token);
+    const remote = await connectToHost(url, token);
     if (remote.view.current().tasks === undefined)
       await remote.controller.toggleTasks();
     const tasks = remote.view.current().tasks;
@@ -424,6 +428,8 @@ async function status(argv) {
     console.log(`host: reachable at ${url}, ${count} live task${count === 1 ? "" : "s"}`);
     remote.close();
   } catch (error) {
+    if (isParseArgsError(error))
+      throw error;
     console.log(`host: unreachable (${message(error)})`);
   }
 }
@@ -431,13 +437,18 @@ async function restartService({
   force,
   argv,
   manager = serviceManager(),
-  restart
+  restart,
+  connect = connectToHost,
+  pollTimeoutMs = 30000,
+  pollDelayMs = 500
 }) {
   if (!(await manager.state()).installed) {
     console.log(`service not installed (${commandHint("service")} install)`);
     return 1;
   }
-  const address = await hostAddress(argv).catch(() => {
+  const address = await hostAddress(argv).catch((error) => {
+    if (isParseArgsError(error))
+      throw error;
     return;
   });
   if (!force && address !== undefined) {
@@ -457,7 +468,7 @@ async function restartService({
     console.log("restart requested (host address unknown; not polling)");
     return 0;
   }
-  const deadline = Date.now() + 30000;
+  const deadline = Date.now() + pollTimeoutMs;
   for (;; ) {
     try {
       const remote = await connect(address.url, address.token, 2000);
@@ -465,11 +476,16 @@ async function restartService({
       console.log(`host restarted, reachable at ${address.url}`);
       return 0;
     } catch (error) {
+      if (error instanceof ProtocolMismatchError && error.direction === "client-older") {
+        const newer = error.hostVersion ?? `protocol major ${error.hostMajor}`;
+        console.log(`host restarted (${newer}, newer than this upgrader), reachable at ${address.url}`);
+        return 0;
+      }
       if (Date.now() > deadline) {
-        console.error(`host did not answer within 30s after restart: ${message(error)}`);
+        console.error(`host did not answer within ${pollTimeoutMs / 1000}s after restart: ${message(error)}`);
         return 1;
       }
-      await new Promise((resolve3) => setTimeout(resolve3, 500));
+      await new Promise((resolve3) => setTimeout(resolve3, pollDelayMs));
     }
   }
 }
@@ -512,11 +528,12 @@ async function main(argv) {
         process.exitCode = 1;
     }
   } catch (error) {
+    if (isParseArgsError(error))
+      throw error;
     console.error(message(error));
     process.exitCode = 1;
   }
 }
-if (false)
-  ;
+if (false) {}
 
 export { installSpec, argValue, withoutRelayArgs, serviceManager, restartService, main };