pinomad 0.11.0 → 0.13.0

package/dist/{chunk-n1m1tjrk.js → chunk-d4tq62yr.js}

@@ -3,35 +3,39 @@ import {
   joinServer,
   openServiceSlot,
   writeService
-} from "./chunk-gtdpjqa3.js";
-import"./chunk-ncbqa8jk.js";
-import"./chunk-44pnts98.js";
+} from "./chunk-d9mq5d46.js";
+import"./chunk-7mn38n4f.js";
+import"./chunk-563fnad9.js";
 import"./chunk-t91zt5f0.js";
 import {
   normalizeOrigin,
+  readRemovalNotice,
   readServerConfig
-} from "./chunk-etf7ef97.js";
-import"./chunk-y127fe1a.js";
+} from "./chunk-nq57fdnq.js";
+import"./chunk-g3ahp7b9.js";
 import {
+  LAUNCHER_EXECUTABLE,
   argValue,
+  isLauncher,
   serviceManager,
   withoutArg,
   withoutRelayArgs
-} from "./chunk-vvj9b1gc.js";
-import"./chunk-jt34g8st.js";
+} from "./chunk-wd7aracm.js";
+import"./chunk-4fferbxw.js";
 import"./chunk-kzbzacz9.js";
-import"./chunk-xqycs43g.js";
+import"./chunk-kmzzjv53.js";
 import"./chunk-pqe7q1s7.js";
 import {
   DEFAULT_DATA_DIR
 } from "./chunk-ngf1zatm.js";
 import {
   commandHint
-} from "./chunk-sd5fkxjj.js";
+} from "./chunk-s0h7c7da.js";
 import"./chunk-df32avw6.js";
 
 // apps/host/src/cli/up.ts
-import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 var OFFICIAL_SERVER_ORIGIN = "https://app.pinomad.si";
@@ -44,6 +48,9 @@ function resolveReach(flags, current) {
     return { server: flags.server ?? current.server, lan: flags.lan ?? current.lan };
   return { server: flags.server ?? !flags.lan, lan: flags.lan ?? !flags.server };
 }
+var lastRemovedOrigin = async (dataDir) => (await readRemovalNotice(dataDir).catch(() => {
+  return;
+}))?.origin;
 async function currentReach(dataDir, deps) {
   const slot = await openServiceSlot(dataDir, deps?.manager ?? serviceManager());
   const config = await readServerConfig(dataDir);
@@ -73,7 +80,7 @@ async function upHost(args, deps) {
   const manager = deps?.manager ?? serviceManager();
   const slot = await openServiceSlot(dataDir, manager);
   const config = await readServerConfig(dataDir);
-  const origin = normalizeOrigin(args.origin ?? config?.origin ?? OFFICIAL_SERVER_ORIGIN);
+  const origin = normalizeOrigin(args.origin ?? config?.origin ?? await lastRemovedOrigin(dataDir) ?? OFFICIAL_SERVER_ORIGIN);
   if (reach.server && config !== undefined && normalizeOrigin(config.origin) !== origin) {
     throw new Error(`this host is joined to ${config.origin} — run \`${commandHint("leave")}\` first to join ${origin}, ` + `or leave out --origin to stay`);
   }
@@ -81,7 +88,14 @@ async function upHost(args, deps) {
   const lan = (hostArgs) => withLan(hostArgs, lanPort);
   const notes = [];
   if (reach.server && config === undefined) {
-    const joined = await joinServer({ origin, dataDir, editHostArgs: lan }, { ...deps, manager });
+    const joined = await joinServer({
+      origin,
+      dataDir,
+      code: args.code,
+      ...args.token === undefined ? {} : { token: args.token },
+      ...args.launcher === undefined ? {} : { launcher: args.launcher },
+      editHostArgs: lan
+    }, { ...deps, manager });
     return {
       joined: { origin: joined.origin, username: joined.username, fresh: true },
       ...lanPort === undefined ? {} : { lanPort },
@@ -90,7 +104,7 @@ async function upHost(args, deps) {
     };
   }
   const edit = reach.server ? (hostArgs) => lan(withoutRelayArgs(hostArgs)) : lan;
-  const service = await writeService(slot, edit, { changed: reach.server });
+  const service = await writeService(slot, edit, { changed: reach.server, launcher: args.launcher });
   if (!reach.server && config !== undefined) {
     notes.push(`still joined to ${config.origin} — run \`${commandHint("leave")}\` to leave it`);
   }
@@ -101,6 +115,12 @@ async function upHost(args, deps) {
     notes
   };
 }
+async function readAllStdin() {
+  let text = "";
+  for await (const chunk of process.stdin)
+    text += String(chunk);
+  return text;
+}
 async function askOnTerminal(question) {
   const terminal = createInterface({ input: process.stdin, output: process.stdout });
   try {
@@ -135,7 +155,8 @@ var FLAGS = `choose with flags:
   --server [--origin URL]   through a PiNomad server (default ${OFFICIAL_SERVER_ORIGIN})
   --lan [--remote-port N]   only on the local network and tailnet (default port ${DEFAULT_REMOTE_PORT})
   --server --lan            both
-  --yes                     keep what this host has, or the server on a new host`;
+  --yes                     keep what this host has, or the server on a new host
+  --token-stdin             join with a one-time token read from stdin, without a code`;
 async function main(argv, deps) {
   const { values } = parseArgs({
     args: [...argv],
@@ -145,6 +166,9 @@ async function main(argv, deps) {
       lan: { type: "boolean" },
       yes: { type: "boolean", short: "y" },
       origin: { type: "string" },
+      code: { type: "boolean" },
+      "token-stdin": { type: "boolean" },
+      launcher: { type: "string" },
       "remote-port": { type: "string" },
       "data-dir": { type: "string" }
     }
@@ -152,7 +176,21 @@ async function main(argv, deps) {
   const log = deps?.log ?? ((line) => console.log(line));
   try {
     const dataDir = resolve(values["data-dir"] ?? DEFAULT_DATA_DIR);
-    const origin = normalizeOrigin(values.origin ?? (await readServerConfig(dataDir))?.origin ?? OFFICIAL_SERVER_ORIGIN);
+    const launcher = values.launcher;
+    if (launcher !== undefined && process.platform !== "darwin")
+      throw new Error("--launcher is for the Mac App's service only");
+    if (launcher !== undefined && !(isAbsolute(launcher) && isLauncher(launcher))) {
+      throw new Error(`--launcher ${launcher}: not a path to the launcher inside an app (….app/Contents/MacOS/${LAUNCHER_EXECUTABLE})`);
+    }
+    if (launcher !== undefined && !existsSync(launcher))
+      throw new Error(`--launcher ${launcher}: no such file`);
+    let token;
+    if (values["token-stdin"] === true) {
+      token = (await (deps?.readStdin ?? readAllStdin)()).trim();
+      if (token === "")
+        throw new Error("--token-stdin: no join token on stdin");
+    }
+    const origin = normalizeOrigin(values.origin ?? (await readServerConfig(dataDir))?.origin ?? await lastRemovedOrigin(dataDir) ?? OFFICIAL_SERVER_ORIGIN);
     const current = await currentReach(dataDir, deps);
     let reach = resolveReach({ server: values.server, lan: values.lan }, current);
     if (reach === undefined) {
@@ -176,7 +214,10 @@ async function main(argv, deps) {
       dataDir,
       origin,
       reach,
-      ...values["remote-port"] === undefined ? {} : { remotePort: values["remote-port"] }
+      ...values["remote-port"] === undefined ? {} : { remotePort: values["remote-port"] },
+      ...values.code === true ? { code: true } : {},
+      ...token === undefined ? {} : { token },
+      ...launcher === undefined ? {} : { launcher }
     }, deps);
     if (outcome.joined !== undefined) {
       const who = outcome.joined.username ?? "an account";

package/dist/{chunk-gtdpjqa3.js → chunk-d9mq5d46.js}

@@ -3,28 +3,28 @@ import {
   isSecureServerOrigin,
   probeServerAccounts,
   runServerOperation
-} from "./chunk-ncbqa8jk.js";
+} from "./chunk-7mn38n4f.js";
 import {
   constantValue,
   openHostSettings
-} from "./chunk-44pnts98.js";
+} from "./chunk-563fnad9.js";
 import {
   loadHostKey,
   loadRelayKey
 } from "./chunk-t91zt5f0.js";
 import {
   writeServerConfig
-} from "./chunk-etf7ef97.js";
+} from "./chunk-nq57fdnq.js";
 import {
   relayHostId
-} from "./chunk-y127fe1a.js";
+} from "./chunk-g3ahp7b9.js";
 import {
   argValue,
   installSpec,
   restartService,
   serviceManager,
   withoutRelayArgs
-} from "./chunk-vvj9b1gc.js";
+} from "./chunk-wd7aracm.js";
 import {
   cleanHostName,
   normalizeHostName
@@ -35,7 +35,7 @@ import {
 import {
   commandHint,
   hostEntry
-} from "./chunk-sd5fkxjj.js";
+} from "./chunk-s0h7c7da.js";
 
 // apps/host/src/cli/join.ts
 import { mkdir } from "node:fs/promises";
@@ -45,7 +45,10 @@ import { parseArgs } from "node:util";
 
 // apps/host/src/cli/host-link.ts
 import { spawn } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
 import { arch, platform } from "node:os";
+var CODE_EXPIRED = "the code expired before anyone confirmed it — run the command again for a new one";
 var SLOW_DOWN_STEP_MS = 5000;
 var REQUEST_TIMEOUT_MS = 15000;
 var EXPIRY_GRACE_MS = 2 * 60000;
@@ -58,18 +61,28 @@ function browserCommand(os, env) {
     return "xdg-open";
   return;
 }
-function openInBrowser(url) {
-  const command = browserCommand(process.platform, process.env);
+var OPENER_SETTLE_MS = 2000;
+function openInBrowser(url, command = browserCommand(process.platform, process.env), settleMs = OPENER_SETTLE_MS) {
   if (command === undefined)
-    return false;
-  try {
-    const child = spawn(command, [url], { detached: true, stdio: "ignore" });
-    child.on("error", () => {});
-    child.unref();
-    return true;
-  } catch {
-    return false;
-  }
+    return Promise.resolve(false);
+  return new Promise((resolve) => {
+    let timer;
+    const settle = (opened) => {
+      clearTimeout(timer);
+      resolve(opened);
+    };
+    try {
+      const child = spawn(command, [url], { detached: true, stdio: "ignore" });
+      child.once("spawn", () => {
+        child.unref();
+        timer = setTimeout(() => settle(true), settleMs);
+      });
+      child.once("error", () => settle(false));
+      child.once("exit", (code) => settle(code === 0));
+    } catch {
+      settle(false);
+    }
+  });
 }
 function hostOsLabel() {
   const os = platform();
@@ -78,6 +91,29 @@ function hostOsLabel() {
 }
 var isRecord = (value) => typeof value === "object" && value !== null;
 var errorCode = (body) => isRecord(body) && typeof body.error === "string" ? body.error : undefined;
+var escapeHtml = (text) => text.replace(/[&<>"']/g, (char) => `&#${char.charCodeAt(0)};`);
+function answerPage(response, status, text) {
+  response.writeHead(status, {
+    "content-type": "text/html; charset=utf-8",
+    "cache-control": "no-store",
+    "referrer-policy": "no-referrer",
+    "content-security-policy": "default-src 'none'",
+    connection: "close"
+  });
+  response.end(`<!doctype html><meta charset="utf-8"><title>PiNomad</title><p>${escapeHtml(text)}</p>
+`);
+}
+function pkcePair() {
+  const verifier = randomBytes(32).toString("base64url");
+  return { verifier, challenge: createHash("sha256").update(verifier).digest("base64url") };
+}
+var codeStart = (body) => isRecord(body) && typeof body.deviceCode === "string" && typeof body.userCode === "string" && typeof body.verifyUrl === "string" && typeof body.interval === "number" && typeof body.expiresAt === "number" && isSecureServerOrigin(body.verifyUrl) ? {
+  deviceCode: body.deviceCode,
+  userCode: body.userCode,
+  verifyUrl: body.verifyUrl,
+  expiresAt: body.expiresAt,
+  interval: body.interval
+} : undefined;
 async function requestJoinToken(args, deps) {
   const fetchImpl = deps?.fetch ?? fetch;
   const sleep = deps?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
@@ -103,13 +139,13 @@ async function requestJoinToken(args, deps) {
         signal: controller.signal
       });
       const text = await response.text();
-      let body2;
+      let body;
       try {
-        body2 = JSON.parse(text);
+        body = JSON.parse(text);
       } catch {
-        body2 = undefined;
+        body = undefined;
       }
-      return { status: response.status, body: body2 };
+      return { status: response.status, body };
     })().catch(() => {
       return;
     });
@@ -119,41 +155,144 @@ async function requestJoinToken(args, deps) {
       clearTimeout(timer);
     }
   };
-  const started = await post("/api/host-link/start", { hostId: args.hostId, name: args.name, os: args.os ?? hostOsLabel() });
-  if (started === undefined)
-    throw new Error(`cannot reach ${origin} — check the address and that the server is up`);
-  const { body } = started;
-  if (started.status !== 200) {
-    const code = errorCode(body);
-    if (started.status === 404) {
+  const startBody = { hostId: args.hostId, name: args.name, os: args.os ?? hostOsLabel() };
+  const openBrowser = async (url) => Promise.resolve((deps?.openBrowser ?? openInBrowser)(url)).catch(() => false);
+  const start = async (payload) => {
+    const started2 = await post("/api/host-link/start", payload);
+    if (started2 === undefined)
+      throw new Error(`cannot reach ${origin} — check the address and that the server is up`);
+    if (started2.status === 200)
+      return started2.body;
+    const code = errorCode(started2.body);
+    if (started2.status === 404) {
       throw new Error(`${origin} can't confirm hosts in the browser yet — create a join token under "Add a host" and run the join command with it`);
     }
     if (code === "rate_limited")
       throw new Error("too many join requests from this address — wait a few minutes and try again");
     if (code === "busy")
       throw new Error(`${origin} has too many hosts waiting to join right now — try again in a few minutes`);
-    throw new Error(`${origin} refused to start the join: ${code ?? `HTTP ${started.status}`}`);
-  }
-  if (!isRecord(body) || typeof body.deviceCode !== "string" || typeof body.userCode !== "string" || typeof body.verifyUrl !== "string" || typeof body.interval !== "number" || typeof body.expiresAt !== "number" || !isSecureServerOrigin(body.verifyUrl)) {
-    throw new Error(`${origin} answered the join request with something unexpected`);
+    throw new Error(`${origin} refused to start the join: ${code ?? `HTTP ${started2.status}`}`);
+  };
+  const unexpected = () => new Error(`${origin} answered the join request with something unexpected`);
+  const viaLoopback = async () => {
+    const { verifier, challenge } = pkcePair();
+    const state = randomBytes(16).toString("base64url");
+    let settle;
+    const callback = new Promise((resolve) => {
+      settle = resolve;
+    });
+    const listener = createServer((request, response) => {
+      const url = URL.parse(request.url ?? "/", "http://127.0.0.1");
+      if (url === null) {
+        answerPage(response, 400, "Bad request.");
+        return;
+      }
+      if (request.method !== "GET" || url.pathname !== "/callback" || url.searchParams.get("state") !== state) {
+        answerPage(response, 404, "Not found.");
+        return;
+      }
+      if (settle === undefined) {
+        answerPage(response, 409, "This join was already answered. You can close this page.");
+        return;
+      }
+      const deliver = settle;
+      settle = undefined;
+      const closed = new Promise((resolve) => response.once("close", () => resolve()));
+      deliver({
+        params: url.searchParams,
+        reply: async (status, text) => {
+          answerPage(response, status, text);
+          await closed;
+        }
+      });
+    });
+    await new Promise((resolve, reject) => {
+      listener.once("error", reject);
+      listener.listen(0, "127.0.0.1", () => resolve());
+    });
+    try {
+      const { port } = listener.address();
+      const body = await start({
+        ...startBody,
+        redirectUri: `http://127.0.0.1:${port}/callback`,
+        codeChallenge: challenge,
+        state
+      });
+      if (!isRecord(body) || typeof body.requestId !== "string") {
+        const fallback = codeStart(body);
+        if (fallback === undefined)
+          throw unexpected();
+        return { fallback };
+      }
+      if (typeof body.verifyUrl !== "string" || typeof body.expiresAt !== "number" || !isSecureServerOrigin(body.verifyUrl)) {
+        throw unexpected();
+      }
+      const { verifyUrl: verifyUrl2, expiresAt: expiresAt2 } = body;
+      if (!await openBrowser(verifyUrl2)) {
+        browserOpens = false;
+        return { fallback: undefined };
+      }
+      const minutes2 = Math.max(1, Math.round((expiresAt2 - now()) / 60000));
+      log(`Opened ${verifyUrl2} in your browser to add this host to your account on ${origin}.`);
+      log(`Sign in there and confirm it on this computer — only if you started this on ${args.name} (host id ${args.hostId}).`);
+      log(`To confirm from another device instead, press Ctrl-C and run the command again with --code.`);
+      log(`Waiting for confirmation (the request expires in ${minutes2} min)…`);
+      const wait = deps?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms).unref()));
+      const answer = await Promise.race([
+        callback,
+        wait(Math.max(0, expiresAt2 + EXPIRY_GRACE_MS - now())).then(() => {
+          return;
+        })
+      ]);
+      if (answer === undefined)
+        throw new Error("the request expired before anyone confirmed it — run the command again");
+      const { params, reply } = answer;
+      if (params.get("error") === "access_denied") {
+        await reply(200, `Denied: ${args.name} was not added. You can close this page.`);
+        throw new Error(`the join was denied on ${origin}`);
+      }
+      const code = params.get("code");
+      const exchanged = code === null ? undefined : await post("/api/host-link/token", { code, codeVerifier: verifier });
+      const token = exchanged?.status === 200 && isRecord(exchanged.body) ? exchanged.body.token : undefined;
+      if (typeof token !== "string") {
+        await reply(502, "The join did not finish. Go back to the terminal and run the command again.");
+        throw new Error(`${origin} did not hand over the join token: ${errorCode(exchanged?.body) ?? (exchanged === undefined ? "no answer" : `HTTP ${exchanged.status}`)} — run the command again`);
+      }
+      await reply(200, `Confirmed: ${args.name} is joining your account. You can close this page.`);
+      log("Confirmed.");
+      return { token };
+    } finally {
+      listener.close();
+      listener.closeAllConnections();
+    }
+  };
+  let browserOpens = args.code !== true;
+  let started;
+  if (args.code !== true && (deps?.loopback ?? browserCommand(process.platform, process.env) !== undefined)) {
+    const loopback = await viaLoopback();
+    if ("token" in loopback)
+      return loopback.token;
+    started = loopback.fallback;
   }
-  const { deviceCode, userCode, verifyUrl, expiresAt } = body;
-  let intervalMs = Math.max(1, body.interval) * 1000;
+  started ??= codeStart(await start(startBody));
+  if (started === undefined)
+    throw unexpected();
+  const { deviceCode, userCode, verifyUrl, expiresAt } = started;
+  let intervalMs = Math.max(1, started.interval) * 1000;
   const minutes = Math.max(1, Math.round((expiresAt - now()) / 60000));
   log(`To add this host to your account on ${origin}:`);
   log(`  1. Open ${verifyUrl} and sign in.`);
   log(`  2. Enter this code: ${userCode}`);
   log("");
   log(`Only confirm it if you started this on ${args.name} (host id ${args.hostId}).`);
-  const opened = await Promise.resolve((deps?.openBrowser ?? openInBrowser)(verifyUrl)).catch(() => false);
+  const opened = browserOpens && await openBrowser(verifyUrl);
   log(`${opened ? "Opened the page in your browser. " : ""}Waiting for confirmation (the code expires in ${minutes} min)…`);
   for (;; ) {
     await sleep(intervalMs);
     const response = await post("/api/host-link/poll", { deviceCode });
     if (response === undefined || response.status >= 500) {
-      if (now() > expiresAt + EXPIRY_GRACE_MS) {
-        throw new Error(`the code expired before anyone confirmed it — run the command again for a new one`);
-      }
+      if (now() > expiresAt + EXPIRY_GRACE_MS)
+        throw new Error(CODE_EXPIRED);
       continue;
     }
     const answer = response.body;
@@ -165,7 +304,7 @@ async function requestJoinToken(args, deps) {
     if (code === "access_denied")
       throw new Error(`the join was denied on ${origin}`);
     if (code === "expired_token")
-      throw new Error(`the code expired before anyone confirmed it — run the command again for a new one`);
+      throw new Error(CODE_EXPIRED);
     if (code === "slow_down") {
       const asked = isRecord(answer) && typeof answer.interval === "number" ? answer.interval * 1000 : 0;
       intervalMs = Math.max(intervalMs + SLOW_DOWN_STEP_MS, asked);
@@ -176,18 +315,30 @@ async function requestJoinToken(args, deps) {
 }
 
 // apps/host/src/cli/service-slot.ts
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 async function openServiceSlot(dataDir, manager) {
-  const state = await manager.state().catch(() => ({ installed: false, running: false, detail: "unknown" }));
+  const state = await manager.state().catch(() => ({ installed: false, stopped: false, running: false, detail: "unknown" }));
   const previous = state.installed ? await manager.read() : undefined;
   if (previous !== undefined && resolve(previous.dataDir) !== dataDir) {
     throw new Error(`the installed service uses a different data dir (${previous.dataDir}); ` + `run this again with --data-dir ${previous.dataDir} or uninstall the service first`);
   }
   return { dataDir, manager, state, previous };
 }
+function launcherFor(given, previous) {
+  if (given !== undefined)
+    return given;
+  const installed = previous?.launcher;
+  return installed !== undefined && existsSync(installed) ? installed : undefined;
+}
 async function writeService(slot, edit, options) {
   const { dataDir, manager, previous } = slot;
+  const launcher = launcherFor(options.launcher, previous);
+  const withLauncher = (spec2) => {
+    const { launcher: _, ...rest } = spec2;
+    return launcher === undefined ? rest : { ...rest, launcher };
+  };
   const fresh = installSpec(["--data-dir", dataDir, ...edit([])], {
     execPath: process.execPath,
     env: process.env,
@@ -197,11 +348,11 @@ async function writeService(slot, edit, options) {
     entryArgs: hostEntry.args
   });
   if (!slot.state.installed) {
-    await manager.install(fresh);
+    await manager.install(withLauncher(fresh));
     return "installed";
   }
-  const spec = previous === undefined ? fresh : { ...previous, hostArgs: edit(previous.hostArgs) };
-  const same = previous !== undefined && spec.hostArgs.join("\x00") === previous.hostArgs.join("\x00");
+  const spec = withLauncher(previous === undefined ? fresh : { ...previous, hostArgs: edit(previous.hostArgs) });
+  const same = previous !== undefined && spec.hostArgs.join("\x00") === previous.hostArgs.join("\x00") && spec.launcher === previous.launcher;
   if (same && !options.changed && slot.state.running)
     return "unchanged";
   const port = argValue(spec.hostArgs, "--port");
@@ -249,7 +400,7 @@ async function joinServer(args, deps) {
   const current = settings.value;
   const storedName = current.custom.includes("hostName") ? current.hostName : undefined;
   const name = normalizeHostName(args.name ?? storedName ?? deps?.hostname ?? hostname());
-  const joinToken = args.token ?? await requestJoinToken({ origin, hostId, name }, deps);
+  const joinToken = args.token ?? await requestJoinToken({ origin, hostId, name, code: args.code }, deps);
   const reply = await runServerOperation({
     origin,
     signingKey,
@@ -270,10 +421,13 @@ async function joinServer(args, deps) {
     if (args.name !== undefined)
       await settings.update({ hostName: args.name });
     const edit = args.editHostArgs ?? ((hostArgs) => hostArgs);
-    service = await writeService(slot, (hostArgs) => edit(withoutRelayArgs(hostArgs)), { changed: true });
+    service = await writeService(slot, (hostArgs) => edit(withoutRelayArgs(hostArgs)), {
+      changed: true,
+      launcher: args.launcher
+    });
   } catch (error) {
     throw new Error(`joined ${username} at ${origin}, but local setup failed: ${message(error)}
-` + (args.token === undefined ? `run the command again and confirm the new code (re-joining the same host is safe)` : `generate a fresh join token and run the command again (re-joining the same host is safe)`));
+` + (args.token === undefined ? `run the command again and confirm it again (re-joining the same host is safe)` : `generate a fresh join token and run the command again (re-joining the same host is safe)`));
   }
   return { hostId, username, origin, service };
 }
@@ -281,18 +435,20 @@ async function main(argv, deps) {
   const { values, positionals } = parseArgs({
     args: [...argv],
     allowPositionals: true,
-    options: { "data-dir": { type: "string" }, name: { type: "string" } }
+    options: { "data-dir": { type: "string" }, name: { type: "string" }, code: { type: "boolean" } }
   });
   const [origin, token] = positionals;
   if (origin === undefined || positionals.length > 2) {
-    console.error(`usage: ${commandHint("join")} <server-origin> [join-token] [--data-dir DIR] [--name NAME]`);
-    console.error("       without a join token, confirm the printed code in the browser where you're signed in");
+    console.error(`usage: ${commandHint("join")} <server-origin> [join-token] [--code] [--data-dir DIR] [--name NAME]`);
+    console.error("       without a join token, confirm this host in the browser where you're signed in;");
+    console.error("       --code prints a code to confirm instead, from this or another device");
     process.exit(1);
   }
   try {
     const outcome = await joinServer({
       origin,
       ...token === undefined ? {} : { token },
+      ...values.code === true ? { code: true } : {},
       dataDir: values["data-dir"] ?? DEFAULT_DATA_DIR,
       ...values.name === undefined ? {} : { name: values.name }
     }, deps);

package/dist/{chunk-y127fe1a.js → chunk-g3ahp7b9.js}

@@ -15,6 +15,7 @@ var RELAY_CLOSE = {
   handshakeTimeout: 4608,
   replaced: 4609,
   acceptTimeout: 4610,
+  hostRemoved: 4611,
   tooManyConnections: 4629,
   trafficLimit: 4630
 };
@@ -467,6 +468,14 @@ function startRelayLink(options) {
     }
     if (stopped)
       return;
+    if (code === RELAY_CLOSE.hostRemoved) {
+      stopped = true;
+      setState({
+        status: "removed",
+        reason: `relay ${origin}: the account removed this host (${hostId}); join it again with \`pinomad up\` (${code})`
+      });
+      return;
+    }
     const rejection = REJECTION_REASONS[code];
     if (rejection !== undefined) {
       const reason = `relay ${origin}: ${rejection(hostId)} (${code})`;
@@ -494,6 +503,8 @@ function startRelayLink(options) {
     origin,
     state: () => state,
     sendPush(request) {
+      if (state.status === "removed")
+        return Promise.resolve({ result: "unavailable", reason: "the account removed this host" });
       const socket = control;
       if (stopped || socket === undefined || socket.readyState !== WebSocket.OPEN || state.status !== "registered") {
         return Promise.resolve({ result: "retry", reason: "control disconnected" });