pinomad 0.4.0 → 0.5.0

package/dist/{chunk-837gh8nr.js → chunk-ebfaf3k2.js}

@@ -3,10 +3,10 @@ import {
   generateKeyPair,
   keyPairFromPrivate,
   toBase64Url
-} from "./chunk-7gmkgyaz.js";
+} from "./chunk-kmbh44dt.js";
 
 // apps/host/src/devices.ts
-import { readFile, writeFile } from "node:fs/promises";
+import { link, readFile, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { ed25519 } from "@noble/curves/ed25519.js";
@@ -62,14 +62,8 @@ async function loadHostKey(dataDir) {
     if (error.code !== "ENOENT")
       throw error;
     const pair = generateKeyPair();
-    try {
-      await writeFile(path, `${toBase64Url(pair.privateKey)}
-`, { flag: "wx", mode: 384 });
-    } catch (race) {
-      if (race.code !== "EEXIST")
-        throw race;
+    if (!await createKeyFile(path, toBase64Url(pair.privateKey)))
       return loadHostKey(dataDir);
-    }
     return pair;
   }
 }
@@ -84,17 +78,26 @@ async function loadRelayKey(dataDir) {
     if (error.code !== "ENOENT")
       throw error;
     const { secretKey, publicKey } = ed25519.keygen();
-    try {
-      await writeFile(path, `${toBase64Url(secretKey)}
-`, { flag: "wx", mode: 384 });
-    } catch (race) {
-      if (race.code !== "EEXIST")
-        throw race;
+    if (!await createKeyFile(path, toBase64Url(secretKey)))
       return loadRelayKey(dataDir);
-    }
     return { secretKey, publicKey };
   }
 }
+async function createKeyFile(path, key) {
+  const tmp = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+  try {
+    await writeFile(tmp, `${key}
+`, { flag: "wx", mode: 384 });
+    await link(tmp, path);
+    return true;
+  } catch (race) {
+    if (race.code !== "EEXIST")
+      throw race;
+    return false;
+  } finally {
+    await unlink(tmp).catch(() => {});
+  }
+}
 function pairingOffers(ttlMs = 5 * 60 * 1000) {
   const live = new Map;
   const prune = () => {
@@ -135,4 +138,53 @@ function pairingOffers(ttlMs = 5 * 60 * 1000) {
   };
 }
 
-export { DevicesDoc, ensureDevices, RevocationsDoc, admitDevice, loadHostKey, loadRelayKey, pairingOffers };
+// apps/host/src/server-config.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { readFile as readFile2, rename, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var SERVER_CONFIG_FILE = "server.json";
+var normalizeOrigin = (origin) => origin.replace(/\/+$/, "");
+async function readServerConfig(dataDir) {
+  let text;
+  try {
+    text = await readFile2(join2(dataDir, SERVER_CONFIG_FILE), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error(`${join2(dataDir, SERVER_CONFIG_FILE)} is not valid JSON — delete it or run \`pinomad leave\``);
+  }
+  const origin = value?.origin;
+  if (typeof origin !== "string" || origin.trim() === "") {
+    throw new Error(`${join2(dataDir, SERVER_CONFIG_FILE)} is missing a string "origin"`);
+  }
+  const binding = value.binding;
+  return {
+    origin,
+    ...typeof binding === "string" && binding !== "" ? { binding } : {}
+  };
+}
+async function writeServerConfig(dataDir, config) {
+  const path = join2(dataDir, SERVER_CONFIG_FILE);
+  const tmp = `${path}.tmp-${process.pid}`;
+  await writeFile2(tmp, `${JSON.stringify({ origin: normalizeOrigin(config.origin), binding: randomBytes2(16).toString("base64url") })}
+`, { mode: 384 });
+  await rename(tmp, path);
+}
+var removeServerConfig = (dataDir) => rm(join2(dataDir, SERVER_CONFIG_FILE), { force: true });
+async function readServerBinding(dataDir) {
+  return (await readServerConfig(dataDir))?.binding;
+}
+function resolveRelayOrigin(flag, config) {
+  if (flag !== undefined && config !== undefined && normalizeOrigin(flag) !== normalizeOrigin(config.origin)) {
+    throw new Error(`--relay ${flag} disagrees with ${SERVER_CONFIG_FILE} (${config.origin}) — remove one`);
+  }
+  return flag ?? config?.origin;
+}
+
+export { DevicesDoc, ensureDevices, RevocationsDoc, admitDevice, loadHostKey, loadRelayKey, pairingOffers, normalizeOrigin, readServerConfig, writeServerConfig, removeServerConfig, readServerBinding, resolveRelayOrigin };

package/dist/{chunk-xhwkx9bd.js → chunk-f0v3sht0.js}

@@ -3,28 +3,25 @@ import {
   assertSecureServerOrigin,
   probeServerAccounts,
   runServerOperation
-} from "./chunk-5785kwej.js";
+} from "./chunk-26d04z02.js";
 import {
+  loadHostKey,
+  loadRelayKey,
   readServerConfig,
   removeServerConfig
-} from "./chunk-302y6by9.js";
-import"./chunk-knaw1a9g.js";
+} from "./chunk-ebfaf3k2.js";
+import {
+  relayHostId
+} from "./chunk-kmbh44dt.js";
 import {
   argValue,
   restartService,
   serviceManager,
   withoutRelayArgs
-} from "./chunk-akgxwg8f.js";
-import"./chunk-fgx2sh7d.js";
-import"./chunk-374zqx5h.js";
-import"./chunk-myjp910s.js";
-import {
-  loadHostKey,
-  loadRelayKey
-} from "./chunk-837gh8nr.js";
-import {
-  relayHostId
-} from "./chunk-7gmkgyaz.js";
+} from "./chunk-aqj4wg33.js";
+import"./chunk-1d9sppj0.js";
+import"./chunk-m4q9wafw.js";
+import"./chunk-hsp12cjt.js";
 import {
   DEFAULT_DATA_DIR
 } from "./chunk-cjfmfyjb.js";

package/dist/{chunk-n73t5xzw.js → chunk-gqr7ahv4.js}

@@ -1,6 +1,6 @@
 import {
   packagedVersion
-} from "./chunk-fgx2sh7d.js";
+} from "./chunk-1d9sppj0.js";
 import {
   hostAddress
 } from "./chunk-cjfmfyjb.js";

package/dist/{chunk-myjp910s.js → chunk-hsp12cjt.js}

@@ -22,7 +22,7 @@ var conversationStream = (id) => `conversation:${id}`;
 var docStream = (kind, id) => `doc:${kind}:${id}`;
 var UNAUTHORIZED_CLOSE_CODE = 4401;
 var INVALID_FRAME_CLOSE_CODE = 4400;
-var PROTOCOL = { major: 5, minor: 8 };
+var PROTOCOL = { major: 5, minor: 10 };
 var CALL_SINCE = {
   logout: 1,
   updateSettings: 2,
@@ -31,12 +31,13 @@ var CALL_SINCE = {
   createAgent: 6,
   updateAgent: 6,
   deleteAgent: 6,
-  setPushToken: 7
+  setPushToken: 7,
+  listFiles: 10
 };
 function hostSupportsCall(hostMinor, method) {
   return hostMinor >= (CALL_SINCE[method] ?? 0);
 }
-var FEATURE_SINCE = { images: 5, acceptAccountDevices: 8 };
+var FEATURE_SINCE = { images: 5, acceptAccountDevices: 8, apnsPush: 9, agentConversations: 10 };
 function hostSupportsFeature(hostMinor, feature) {
   return hostMinor >= FEATURE_SINCE[feature];
 }
@@ -92,7 +93,8 @@ var CALL_METHODS = [
   "createAgent",
   "updateAgent",
   "deleteAgent",
-  "setPushToken"
+  "setPushToken",
+  "listFiles"
 ];
 var SETTING_VALIDATORS = {
   defaultModel: (value) => value === null || record(value) && nonempty(value.provider) && nonempty(value.modelId),
@@ -128,7 +130,9 @@ function validCallArgs(method, args) {
     case "listFolders":
       return args.path === undefined || nonempty(args.path);
     case "createConversation":
-      return record(args.home) && (args.home.kind === "chat" || args.home.kind === "project" && nonempty(args.home.path)) && typeof args.text === "string" && (nonempty(args.text) || Array.isArray(args.images) && args.images.length > 0) && nonempty(args.requestId) && images() && (args.checkout === undefined || args.checkout === "worktree" || args.checkout === "project") && (args.model === undefined || record(args.model) && nonempty(args.model.provider) && nonempty(args.model.modelId)) && (args.thinkingLevel === undefined || nonempty(args.thinkingLevel));
+      return record(args.home) && (args.home.kind === "chat" || args.home.kind === "project" && nonempty(args.home.path)) && typeof args.text === "string" && (nonempty(args.text) || Array.isArray(args.images) && args.images.length > 0) && nonempty(args.requestId) && images() && (args.checkout === undefined || args.checkout === "worktree" || args.checkout === "project") && (args.model === undefined || record(args.model) && nonempty(args.model.provider) && nonempty(args.model.modelId)) && (args.thinkingLevel === undefined || nonempty(args.thinkingLevel)) && (args.agent === undefined || nonempty(args.agent));
+    case "listFiles":
+      return typeof args.query === "string" && record(args.scope) && (args.scope.kind === "conversation" && typeof args.scope.conversationId === "number" && Number.isSafeInteger(args.scope.conversationId) && args.scope.conversationId >= 1 || args.scope.kind === "project" && nonempty(args.scope.path) && (args.scope.checkout === "worktree" || args.scope.checkout === "project"));
     case "archive":
       return conversationId() && typeof args.archived === "boolean";
     case "renameConversation":
@@ -145,7 +149,7 @@ function validCallArgs(method, args) {
     case "deleteAgent":
       return typeof args.name === "string";
     case "setPushToken":
-      return args.token === null || typeof args.token === "string";
+      return args.token === null || typeof args.token === "string" || record(args.token) && typeof args.token.apns === "string" && (args.token.environment === "production" || args.token.environment === "development");
     case "updateSettings":
       return record(args.patch) && Object.keys(args.patch).every((key) => HOST_SETTING_KEYS.includes(key)) && Object.entries(args.patch).every(([key, value]) => SETTING_VALIDATORS[key]?.(value) === true);
   }

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

@@ -290,6 +290,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 +307,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 +316,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 +332,52 @@ function decodeRelayToHost(text) {
       throw new Error("unknown relay frame");
   }
 }
+function decodeRegistered(value) {
+  if (value.push === undefined)
+    return { t: "registered" };
+  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 };
+}
+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");
@@ -348,6 +392,25 @@ function decodeHostToRelay(text) {
       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");
@@ -417,4 +480,225 @@ 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;
+  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;
+    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 };
+        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"] }
+        }));
+        break;
+      }
+      case "registered":
+        delay = minDelay;
+        pushEnvironments = frame.push;
+        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;
+    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);
+  }
+  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);
+      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-374zqx5h.js → chunk-m4q9wafw.js}

@@ -11,7 +11,7 @@ import {
   hostSupportsCall,
   hostSupportsFeature,
   organize
-} from "./chunk-myjp910s.js";
+} from "./chunk-hsp12cjt.js";
 
 // packages/protocol/src/remote-durable.ts
 import { applyImmutable } from "@earendil-works/chord/delta";
@@ -440,6 +440,9 @@ class RemoteClient {
         if (images.length > 0 && !hostSupportsFeature(this.#hostMinor, "images")) {
           throw new Error("The host is too old for images (needs protocol 5.5); run `pinomad upgrade` on the host");
         }
+        if (options?.agent !== undefined && !hostSupportsFeature(this.#hostMinor, "agentConversations")) {
+          throw new Error("The host is too old for named agents (needs protocol 5.10); run `pinomad upgrade` on the host");
+        }
         const { conversationId: conversationId2 } = await this.#call("createConversation", {
           home,
           text,
@@ -447,6 +450,7 @@ class RemoteClient {
           ...options?.checkout === undefined ? {} : { checkout: options.checkout },
           ...options?.model === undefined ? {} : { model: options.model },
           ...options?.thinkingLevel === undefined ? {} : { thinkingLevel: options.thinkingLevel },
+          ...options?.agent === undefined ? {} : { agent: options.agent },
           ...images.length === 0 ? {} : { images }
         });
         await this.#switch(conversationId2);
@@ -510,6 +514,12 @@ class RemoteClient {
       }),
       answer: (kind, requestId, answers, target) => this.#command(() => this.#call("answer", { conversationId: target ?? conversationId(), kind, requestId, answers })),
       changes: () => this.#request(() => this.#call("changes", { conversationId: conversationId() })),
+      listFiles: (scope, query) => {
+        if (!hostSupportsCall(this.#hostMinor, "listFiles")) {
+          return Promise.reject(new Error("The host is too old for this (needs protocol 5.10); run `pinomad upgrade` on the host"));
+        }
+        return this.#call("listFiles", { scope, query });
+      },
       createPairing: () => this.#request(() => this.#call("createPairing", {})),
       revokeDevice: (publicKey) => this.#command(() => this.#call("revokeDevice", { publicKey })),
       logout: (providerId) => this.#command(() => {
@@ -549,6 +559,9 @@ class RemoteClient {
         if (!hostSupportsCall(this.#hostMinor, "setPushToken")) {
           throw new Error("The host is too old for this (needs protocol 5.7); run `pinomad upgrade` on the host");
         }
+        if (token !== null && typeof token !== "string" && !hostSupportsFeature(this.#hostMinor, "apnsPush")) {
+          throw new Error("The host is too old for this (needs protocol 5.9); run `pinomad upgrade` on the host");
+        }
         await this.#call("setPushToken", { token });
       })
     };

package/dist/{chunk-d4y99pfy.js → chunk-zttf1hvh.js}

@@ -1,7 +1,7 @@
 import {
   connectRemoteDurable
-} from "./chunk-374zqx5h.js";
-import"./chunk-myjp910s.js";
+} from "./chunk-m4q9wafw.js";
+import"./chunk-hsp12cjt.js";
 import {
   hostAddress
 } from "./chunk-cjfmfyjb.js";

package/dist/pinomad.js

@@ -1,35 +1,35 @@
 #!/usr/bin/env node
 import {
   packagedVersion
-} from "./chunk-fgx2sh7d.js";
+} from "./chunk-1d9sppj0.js";
 import {
   __require
 } from "./chunk-df32avw6.js";
 
 // apps/cli/src/pinomad.ts
 var COMMANDS = {
-  host: () => import("./chunk-z5pmcscx.js"),
-  relay: () => import("./chunk-vw5yb5pd.js"),
-  service: () => import("./chunk-prhvksh3.js"),
-  upgrade: () => import("./chunk-17p6bfvy.js"),
-  link: () => import("./chunk-n73t5xzw.js"),
-  pair: () => import("./chunk-d4y99pfy.js"),
-  "relay-id": () => import("./chunk-xrvmnymc.js"),
-  join: () => import("./chunk-b3f0ced1.js"),
-  leave: () => import("./chunk-xhwkx9bd.js")
+  host: () => import("./chunk-d4wdt5qs.js"),
+  server: () => import("./chunk-4by4x5c4.js"),
+  relay: () => import("./chunk-4by4x5c4.js"),
+  service: () => import("./chunk-5ng86fmy.js"),
+  upgrade: () => import("./chunk-crv3dqzp.js"),
+  link: () => import("./chunk-gqr7ahv4.js"),
+  pair: () => import("./chunk-zttf1hvh.js"),
+  join: () => import("./chunk-9d59jjmt.js"),
+  leave: () => import("./chunk-f0v3sht0.js")
 };
-var USAGE = `pinomad — PiNomad host, relay, and utilities
+var USAGE = `pinomad — PiNomad host, server, and utilities
 
 usage: pinomad <command> [args…]
 
   host [host args…]                    run the host in the foreground
-  relay --public-origin O [--allow-host H…] [--data-dir D] [--trust-proxy]   run the server
-  relay passwd [--data-dir D] [--user U]   change the account password (stdin)
+  server --public-origin O [--data-dir D] [--trust-proxy]   run the server
+  server passwd [--data-dir D] [--user U]   change the account password (stdin)
+  relay …                              old name of server
   service install|uninstall|status|restart|logs   user-level host service
   upgrade [--force] [address flags]    upgrade the package and restart the service
   link [--data-dir D|--url U …]        print the browser link
   pair [--data-dir D|--url U …]        print a pairing QR
-  relay-id [--data-dir D]              print this host's relay id (for --allow-host)
   join <origin> <token> [--data-dir D] join this host to a server account
   leave [--data-dir D]                 leave the server account
   --version, -v                        print the version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinomad",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "PiNomad — self-hosted coding agent: host, relay, and web client in one package",
   "license": "Apache-2.0",
   "type": "module",