pinomad 0.5.0 → 0.6.0

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-1d9sppj0.js → chunk-c8nxym2z.js}

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

@@ -1,15 +1,19 @@
+import {
+  isParseArgsError
+} from "./chunk-kzbzacz9.js";
 import {
   commandHint,
   hostEntry,
   packagedVersion
-} from "./chunk-1d9sppj0.js";
+} from "./chunk-c8nxym2z.js";
 import {
+  ProtocolMismatchError,
   connectRemoteDurable
-} from "./chunk-m4q9wafw.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 };

package/dist/{chunk-m4q9wafw.js → chunk-d93kvxvc.js}

@@ -11,7 +11,7 @@ import {
   hostSupportsCall,
   hostSupportsFeature,
   organize
-} from "./chunk-hsp12cjt.js";
+} from "./chunk-n4tjhcb7.js";
 
 // packages/protocol/src/remote-durable.ts
 import { applyImmutable } from "@earendil-works/chord/delta";
@@ -535,6 +535,9 @@ class RemoteClient {
         if (patch.acceptAccountDevices !== undefined && !hostSupportsFeature(this.#hostMinor, "acceptAccountDevices")) {
           throw new Error("The host is too old for this (needs protocol 5.8); run `pinomad upgrade` on the host");
         }
+        if (patch.hostName !== undefined && !hostSupportsFeature(this.#hostMinor, "hostName")) {
+          throw new Error("The host is too old for this (needs protocol 5.12); run `pinomad upgrade` on the host");
+        }
         return this.#call("updateSettings", { patch });
       }),
       createAgent: (role) => this.#request(async () => {
@@ -604,4 +607,4 @@ class RemoteClient {
   }
 }
 
-export { connectRemoteDurable };
+export { connectRemoteDurable, ProtocolMismatchError };

package/dist/chunk-ggb1taqy.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import {
+  main,
+  restartService
+} from "./chunk-d5ypmmr7.js";
+import"./chunk-kzbzacz9.js";
+import"./chunk-c8nxym2z.js";
+import"./chunk-d93kvxvc.js";
+import"./chunk-n4tjhcb7.js";
+import"./chunk-znhn8af7.js";
+import"./chunk-ngf1zatm.js";
+import"./chunk-df32avw6.js";
+export {
+  restartService,
+  main
+};

package/dist/chunk-jn7y815x.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import {
+  restartService,
+  serviceManager
+} from "./chunk-d5ypmmr7.js";
+import"./chunk-kzbzacz9.js";
+import {
+  globalPrefixOf,
+  packageDir,
+  packagedVersion
+} from "./chunk-c8nxym2z.js";
+import"./chunk-d93kvxvc.js";
+import"./chunk-n4tjhcb7.js";
+import"./chunk-znhn8af7.js";
+import {
+  hostAddressOptions
+} from "./chunk-ngf1zatm.js";
+import"./chunk-df32avw6.js";
+
+// apps/host/src/cli/upgrade.ts
+import { execFile, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { parseArgs, promisify } from "node:util";
+var exec = promisify(execFile);
+var repoRoot = fileURLToPath(new URL("../../../../", import.meta.url));
+var step = (command, args) => new Promise((resolve) => {
+  spawn(command, [...args], { cwd: repoRoot, stdio: "inherit" }).once("exit", (code) => resolve(code ?? 1));
+});
+var serviceInstalled = () => Promise.resolve().then(() => serviceManager().state()).then((state) => state.installed, () => false);
+async function main(argv, deps = {}) {
+  const { values } = parseArgs({
+    args: [...argv],
+    options: { force: { type: "boolean", default: false }, ...hostAddressOptions }
+  });
+  const run = deps.run ?? ((command, args) => exec(command, args, { cwd: repoRoot }));
+  const runStep = deps.step ?? step;
+  const restart = deps.restart ?? restartService;
+  if (packagedVersion === undefined) {
+    const { stdout } = await run("git", ["status", "--porcelain"]);
+    if (stdout.trim() !== "") {
+      console.error("upgrade: the checkout has uncommitted changes; commit or stash them first");
+      process.exitCode = 1;
+      return;
+    }
+    for (const [command, args] of [
+      ["git", ["pull", "--ff-only"]],
+      ["bun", ["install"]],
+      ["bun", ["run", "build"]]
+    ]) {
+      const code = await runStep(command, args);
+      if (code !== 0) {
+        process.exitCode = code;
+        return;
+      }
+    }
+  } else {
+    const prefix = globalPrefixOf(packageDir);
+    if (prefix === undefined) {
+      console.error(`upgrade: pinomad isn't a global npm install (${packageDir}); upgrade it the way it was installed`);
+      process.exitCode = 1;
+      return;
+    }
+    const code = await runStep("npm", ["install", "-g", "--prefix", prefix, "pinomad@latest"]);
+    if (code !== 0) {
+      process.exitCode = code;
+      return;
+    }
+  }
+  if (!await (deps.serviceInstalled ?? serviceInstalled)()) {
+    console.log("service not installed; upgrade done, nothing restarted");
+    process.exitCode = 0;
+    return;
+  }
+  (deps.exit ?? process.exit)(await restart({ force: values.force, argv: argv.filter((arg) => arg !== "--force") }));
+}
+if (false) {}
+export {
+  main
+};

package/dist/{chunk-9d59jjmt.js → chunk-k2s1hfq5.js}

@@ -3,43 +3,55 @@ import {
   assertSecureServerOrigin,
   probeServerAccounts,
   runServerOperation
-} from "./chunk-26d04z02.js";
+} from "./chunk-ywmm63ks.js";
+import {
+  constantValue,
+  openHostSettings
+} from "./chunk-b1h374jr.js";
 import {
   loadHostKey,
   loadRelayKey,
   writeServerConfig
-} from "./chunk-ebfaf3k2.js";
+} from "./chunk-0xh6cy9v.js";
 import {
   relayHostId
-} from "./chunk-kmbh44dt.js";
+} from "./chunk-7qb9tq54.js";
 import {
   argValue,
   installSpec,
   restartService,
   serviceManager,
   withoutRelayArgs
-} from "./chunk-aqj4wg33.js";
+} from "./chunk-d5ypmmr7.js";
+import"./chunk-kzbzacz9.js";
 import {
   commandHint,
   hostEntry
-} from "./chunk-1d9sppj0.js";
-import"./chunk-m4q9wafw.js";
-import"./chunk-hsp12cjt.js";
+} from "./chunk-c8nxym2z.js";
+import"./chunk-d93kvxvc.js";
+import"./chunk-n4tjhcb7.js";
+import {
+  cleanHostName,
+  normalizeHostName
+} from "./chunk-znhn8af7.js";
 import {
   DEFAULT_DATA_DIR
-} from "./chunk-cjfmfyjb.js";
+} from "./chunk-ngf1zatm.js";
 import"./chunk-df32avw6.js";
 
 // apps/host/src/cli/join.ts
 import { mkdir } from "node:fs/promises";
 import { homedir, hostname } from "node:os";
-import { resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 var message = (error) => error instanceof Error ? error.message : String(error);
 async function joinServer(args, deps) {
   const origin = args.origin.replace(/\/+$/, "");
   const dataDir = resolve(args.dataDir);
   assertSecureServerOrigin(origin);
+  if (args.name !== undefined && cleanHostName(args.name) === "") {
+    throw new Error(`Invalid host name: ${JSON.stringify(args.name)}`);
+  }
   await mkdir(dataDir, { recursive: true });
   const signingKey = await loadRelayKey(dataDir);
   const hostKey = await loadHostKey(dataDir);
@@ -56,13 +68,25 @@ async function joinServer(args, deps) {
   if (probe === "disabled") {
     throw new Error(`${origin} does not run server accounts — the server is too old or was started without a data dir`);
   }
+  const settings = await openHostSettings({
+    path: join(dataDir, "settings.json"),
+    fallback: {
+      defaultModel: () => null,
+      defaultThinkingLevel: () => null,
+      steeringMode: () => "one-at-a-time",
+      followUpMode: () => "one-at-a-time"
+    },
+    models: constantValue([])
+  });
+  const current = settings.value;
+  const storedName = current.custom.includes("hostName") ? current.hostName : undefined;
   const reply = await runServerOperation({
     origin,
     signingKey,
     noisePublicKey: hostKey.publicKey,
     op: "join",
     joinToken: args.token,
-    name: args.name ?? deps?.hostname ?? hostname()
+    name: normalizeHostName(args.name ?? storedName ?? deps?.hostname ?? hostname())
   });
   if (reply.t === "refused") {
     throw new Error(reply.reason === "expired_token" ? "the join token expired — generate a fresh one" : reply.reason === "invalid_token" ? "the join token is invalid or already spent — generate a fresh one" : `the server refused the join: ${reply.reason}`);
@@ -73,6 +97,8 @@ async function joinServer(args, deps) {
   let service;
   try {
     await writeServerConfig(dataDir, { origin });
+    if (args.name !== undefined)
+      await settings.update({ hostName: args.name });
     const freshSpec = installSpec(["--data-dir", dataDir], {
       execPath: process.execPath,
       env: process.env,

package/dist/chunk-kzbzacz9.js

@@ -0,0 +1,12 @@
+// apps/host/src/cli/args.ts
+function isParseArgsError(error) {
+  const code = error.code;
+  return typeof code === "string" && code.startsWith("ERR_PARSE_ARGS_");
+}
+function reportParseArgsError(command, error) {
+  console.error(`${command}: ${error instanceof Error ? error.message : String(error)}`);
+  console.error(`run "${command} --help" for usage`);
+  process.exitCode = 2;
+}
+
+export { isParseArgsError, reportParseArgsError };

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

@@ -1,16 +1,8 @@
-// packages/protocol/src/settings.ts
-var HOST_SETTING_KEY_SET = {
-  defaultModel: true,
-  defaultThinkingLevel: true,
-  steeringMode: true,
-  followUpMode: true,
-  acceptAccountDevices: 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";
+import {
+  HOST_SETTING_KEYS,
+  isQueueMode,
+  isThinkingLevel
+} from "./chunk-znhn8af7.js";
 
 // packages/protocol/src/frames.ts
 var HOST_STREAMS = { conversations: 0, index: 0, devices: 0, mcp: 0, models: 1, auth: 1, settings: 2, agents: 6 };
@@ -22,7 +14,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: 10 };
+var PROTOCOL = { major: 5, minor: 12 };
 var CALL_SINCE = {
   logout: 1,
   updateSettings: 2,
@@ -37,7 +29,14 @@ var CALL_SINCE = {
 function hostSupportsCall(hostMinor, method) {
   return hostMinor >= (CALL_SINCE[method] ?? 0);
 }
-var FEATURE_SINCE = { images: 5, acceptAccountDevices: 8, apnsPush: 9, agentConversations: 10 };
+var FEATURE_SINCE = {
+  images: 5,
+  acceptAccountDevices: 8,
+  apnsPush: 9,
+  agentConversations: 10,
+  liveBranch: 11,
+  hostName: 12
+};
 function hostSupportsFeature(hostMinor, feature) {
   return hostMinor >= FEATURE_SINCE[feature];
 }
@@ -101,7 +100,8 @@ var SETTING_VALIDATORS = {
   defaultThinkingLevel: (value) => value === null || isThinkingLevel(value),
   steeringMode: (value) => value === null || isQueueMode(value),
   followUpMode: (value) => value === null || isQueueMode(value),
-  acceptAccountDevices: (value) => value === null || typeof value === "boolean"
+  acceptAccountDevices: (value) => value === null || typeof value === "boolean",
+  hostName: (value) => value === null || typeof value === "string"
 };
 function validCallArgs(method, args) {
   const conversationId = () => typeof args.conversationId === "number" && Number.isSafeInteger(args.conversationId) && args.conversationId >= 1;
@@ -254,4 +254,4 @@ function homeOf(index, summaries, id) {
   return;
 }
 
-export { HOST_SETTING_KEYS, THINKING_LEVELS, isThinkingLevel, isQueueMode, HOST_STREAM_NAMES, hostStreams, conversationStream, docStream, UNAUTHORIZED_CLOSE_CODE, INVALID_FRAME_CLOSE_CODE, PROTOCOL, hostSupportsCall, hostSupportsFeature, parseClientFrame, organize, checkoutOf, homeOf };
+export { HOST_STREAM_NAMES, hostStreams, conversationStream, docStream, UNAUTHORIZED_CLOSE_CODE, INVALID_FRAME_CLOSE_CODE, PROTOCOL, hostSupportsCall, hostSupportsFeature, parseClientFrame, organize, checkoutOf, homeOf };

package/dist/{chunk-cjfmfyjb.js → chunk-ngf1zatm.js}

@@ -4,18 +4,19 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 var DEFAULT_DATA_DIR = process.env.PINOMAD_DATA_DIR ?? join(homedir(), ".pinomad");
+var hostAddressOptions = {
+  "data-dir": { type: "string" },
+  url: { type: "string", default: "ws://127.0.0.1:7420" },
+  token: { type: "string" }
+};
 async function hostAddress(argv) {
   const { values } = parseArgs({
     args: [...argv],
-    options: {
-      "data-dir": { type: "string" },
-      url: { type: "string", default: "ws://127.0.0.1:7420" },
-      token: { type: "string" }
-    }
+    options: hostAddressOptions
   });
   const dataDir = resolve(values["data-dir"] ?? DEFAULT_DATA_DIR);
   const token = values.token ?? (await readFile(join(dataDir, "token"), "utf8")).trim();
   return { url: values.url, token, dataDir };
 }
 
-export { DEFAULT_DATA_DIR, hostAddress };
+export { DEFAULT_DATA_DIR, hostAddressOptions, hostAddress };

package/dist/{chunk-4by4x5c4.js → chunk-wqvp1fwh.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-c8nxym2z.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();
@@ -1041,6 +1047,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 +1108,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);