pinomad 0.10.0 → 0.12.0

package/dist/chunk-5qf1grkk.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import {
+  joinServer,
+  openServiceSlot,
+  writeService
+} from "./chunk-gg2dcqbg.js";
+import"./chunk-7mn38n4f.js";
+import"./chunk-nppgxh6c.js";
+import"./chunk-t91zt5f0.js";
+import {
+  normalizeOrigin,
+  readRemovalNotice,
+  readServerConfig
+} from "./chunk-nq57fdnq.js";
+import"./chunk-g3ahp7b9.js";
+import {
+  argValue,
+  serviceManager,
+  withoutArg,
+  withoutRelayArgs
+} from "./chunk-t5abqsva.js";
+import"./chunk-np4jd070.js";
+import"./chunk-kzbzacz9.js";
+import"./chunk-47ff1d1t.js";
+import"./chunk-pqe7q1s7.js";
+import {
+  DEFAULT_DATA_DIR
+} from "./chunk-ngf1zatm.js";
+import {
+  commandHint
+} from "./chunk-7wj0jh3t.js";
+import"./chunk-df32avw6.js";
+
+// apps/host/src/cli/up.ts
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parseArgs } from "node:util";
+var OFFICIAL_SERVER_ORIGIN = "https://app.pinomad.si";
+var DEFAULT_REMOTE_PORT = "7422";
+var message = (error) => error instanceof Error ? error.message : String(error);
+function resolveReach(flags, current) {
+  if (flags.server === undefined && flags.lan === undefined)
+    return;
+  if (current !== undefined)
+    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);
+  if (config === undefined && !slot.state.installed)
+    return;
+  return {
+    server: config !== undefined,
+    lan: argValue(slot.previous?.hostArgs ?? [], "--remote-port") !== undefined
+  };
+}
+function withLan(hostArgs, port) {
+  if (port === undefined)
+    return withoutArg(withoutArg(hostArgs, "--remote-port"), "--public-url");
+  if (argValue(hostArgs, "--remote-port") === port)
+    return hostArgs;
+  return [...withoutArg(hostArgs, "--remote-port"), "--remote-port", port];
+}
+async function upHost(args, deps) {
+  const dataDir = resolve(args.dataDir);
+  const { reach } = args;
+  if (!reach.server && !reach.lan)
+    throw new Error("nothing to set up: choose the server, the LAN, or both");
+  const port = args.remotePort;
+  if (port !== undefined && !(/^\d+$/.test(port) && Number(port) >= 1 && Number(port) <= 65535)) {
+    throw new Error(`--remote-port must be a port number from 1 to 65535, got ${port}`);
+  }
+  const manager = deps?.manager ?? serviceManager();
+  const slot = await openServiceSlot(dataDir, manager);
+  const config = await readServerConfig(dataDir);
+  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`);
+  }
+  const lanPort = reach.lan ? args.remotePort ?? argValue(slot.previous?.hostArgs ?? [], "--remote-port") ?? DEFAULT_REMOTE_PORT : undefined;
+  const lan = (hostArgs) => withLan(hostArgs, lanPort);
+  const notes = [];
+  if (reach.server && config === undefined) {
+    const joined = await joinServer({ origin, dataDir, code: args.code, editHostArgs: lan }, { ...deps, manager });
+    return {
+      joined: { origin: joined.origin, username: joined.username, fresh: true },
+      ...lanPort === undefined ? {} : { lanPort },
+      service: joined.service,
+      notes
+    };
+  }
+  const edit = reach.server ? (hostArgs) => lan(withoutRelayArgs(hostArgs)) : lan;
+  const service = await writeService(slot, edit, { changed: reach.server });
+  if (!reach.server && config !== undefined) {
+    notes.push(`still joined to ${config.origin} — run \`${commandHint("leave")}\` to leave it`);
+  }
+  return {
+    ...reach.server && config !== undefined ? { joined: { origin: config.origin, ...config.username === undefined ? {} : { username: config.username }, fresh: false } } : {},
+    ...lanPort === undefined ? {} : { lanPort },
+    service,
+    notes
+  };
+}
+async function askOnTerminal(question) {
+  const terminal = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await terminal.question(question);
+  } finally {
+    terminal.close();
+  }
+}
+var CHOICES = [
+  { server: true, lan: false },
+  { server: false, lan: true },
+  { server: true, lan: true }
+];
+async function askReach(origin, fallback, ask) {
+  const preset = CHOICES.findIndex((choice) => choice.server === fallback.server && choice.lan === fallback.lan) + 1;
+  let question = `How should your other devices reach this host?
+` + `  1) Through ${origin}: from anywhere, with push notifications
+` + `  2) Only on your local network and tailnet
+` + `  3) Both
+` + `Choose 1, 2 or 3 [${preset}]: `;
+  for (;; ) {
+    const answer = (await ask(question)).trim();
+    if (answer === "")
+      return CHOICES[preset - 1];
+    const picked = CHOICES[Number(answer) - 1];
+    if (/^[123]$/.test(answer) && picked !== undefined)
+      return picked;
+    question = "Choose 1, 2 or 3: ";
+  }
+}
+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`;
+async function main(argv, deps) {
+  const { values } = parseArgs({
+    args: [...argv],
+    allowNegative: true,
+    options: {
+      server: { type: "boolean" },
+      lan: { type: "boolean" },
+      yes: { type: "boolean", short: "y" },
+      origin: { type: "string" },
+      code: { type: "boolean" },
+      "remote-port": { type: "string" },
+      "data-dir": { type: "string" }
+    }
+  });
+  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 ?? 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) {
+      const fallback = current !== undefined && (current.server || current.lan) ? current : { server: true, lan: false };
+      if (values.yes === true) {
+        reach = fallback;
+      } else if (!(deps?.interactive ?? (process.stdin.isTTY && process.stdout.isTTY))) {
+        console.error(`${commandHint("up")}: no terminal to ask how other devices reach this host — ${FLAGS}`);
+        process.exitCode = 2;
+        return;
+      } else {
+        reach = await askReach(origin, fallback, deps?.ask ?? askOnTerminal);
+      }
+    }
+    if (!reach.server && !reach.lan) {
+      console.error(`${commandHint("up")}: neither the server nor the LAN would be on — ` + `\`${commandHint("service")} install\` runs a host only this machine can reach`);
+      process.exitCode = 2;
+      return;
+    }
+    const outcome = await upHost({
+      dataDir,
+      origin,
+      reach,
+      ...values["remote-port"] === undefined ? {} : { remotePort: values["remote-port"] },
+      ...values.code === true ? { code: true } : {}
+    }, deps);
+    if (outcome.joined !== undefined) {
+      const who = outcome.joined.username ?? "an account";
+      log(outcome.joined.fresh ? `joined ${who} at ${outcome.joined.origin}` : `already joined ${who} at ${outcome.joined.origin}`);
+      log(`Sign in at ${outcome.joined.origin} on your other devices; they pair with this host on their own.`);
+    }
+    if (outcome.lanPort !== undefined) {
+      log(`LAN and tailnet: port ${outcome.lanPort}. Pair a device with \`${commandHint("pair")}\`.`);
+    }
+    for (const note of outcome.notes)
+      log(`note: ${note}`);
+    if (outcome.service === "installed")
+      log("service installed and started");
+    else if (outcome.service === "updated")
+      log("service updated; host restarted when idle");
+    else if (outcome.service === "unchanged")
+      log("service already running with these settings");
+    else {
+      console.error(`the service restart did not finish — check \`${commandHint("status")}\``);
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    console.error(message(error));
+    process.exitCode = 1;
+  }
+}
+if (false)
+  ;
+export {
+  upHost,
+  resolveReach,
+  main,
+  OFFICIAL_SERVER_ORIGIN,
+  DEFAULT_REMOTE_PORT
+};

package/dist/{chunk-4h7pkkzr.js → chunk-7mn38n4f.js}

@@ -6,10 +6,10 @@ import {
   relayWsBase,
   signRelayChallenge,
   signRelayChallengeV2
-} from "./chunk-cx8k63by.js";
+} from "./chunk-g3ahp7b9.js";
 import {
   toBase64Url
-} from "./chunk-sygeb9qb.js";
+} from "./chunk-pqe7q1s7.js";
 
 // apps/host/src/cli/server-ops.ts
 import { WebSocket } from "ws";
@@ -130,4 +130,4 @@ async function runServerOperation(options) {
   });
 }
 
-export { assertSecureServerOrigin, probeServerAccounts, runServerOperation };
+export { isSecureServerOrigin, assertSecureServerOrigin, probeServerAccounts, runServerOperation };

package/dist/{chunk-zehwx009.js → chunk-7wj0jh3t.js}

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

@@ -3,30 +3,35 @@ import {
   assertSecureServerOrigin,
   probeServerAccounts,
   runServerOperation
-} from "./chunk-4h7pkkzr.js";
+} from "./chunk-7mn38n4f.js";
 import {
   loadHostKey,
-  loadRelayKey,
+  loadRelayKey
+} from "./chunk-t91zt5f0.js";
+import {
+  readRemovalNotice,
   readServerConfig,
   removeServerConfig
-} from "./chunk-8gywfw5n.js";
+} from "./chunk-nq57fdnq.js";
 import {
   relayHostId
-} from "./chunk-cx8k63by.js";
+} from "./chunk-g3ahp7b9.js";
 import {
   argValue,
   restartService,
   serviceManager,
   withoutRelayArgs
-} from "./chunk-w2m9xkks.js";
+} from "./chunk-t5abqsva.js";
+import"./chunk-np4jd070.js";
 import"./chunk-kzbzacz9.js";
-import"./chunk-zehwx009.js";
-import"./chunk-4sepcfpy.js";
-import"./chunk-jgd38rna.js";
-import"./chunk-sygeb9qb.js";
+import"./chunk-47ff1d1t.js";
+import"./chunk-pqe7q1s7.js";
 import {
   DEFAULT_DATA_DIR
 } from "./chunk-ngf1zatm.js";
+import {
+  commandHint
+} from "./chunk-7wj0jh3t.js";
 import"./chunk-df32avw6.js";
 
 // apps/host/src/cli/leave.ts
@@ -37,8 +42,13 @@ var message = (error) => error instanceof Error ? error.message : String(error);
 async function leaveServer(args, deps) {
   const dataDir = resolve(args.dataDir);
   const config = await readServerConfig(dataDir);
-  if (config === undefined)
-    throw new Error(`not joined — no server.json in ${dataDir}`);
+  if (config === undefined) {
+    const removed = await readRemovalNotice(dataDir);
+    if (removed === undefined)
+      throw new Error(`not joined — no server.json in ${dataDir}`);
+    await removeServerConfig(dataDir);
+    return { origin: removed.origin, warnings: [], notes: ["the account had already removed this host"] };
+  }
   const origin = config.origin;
   const warnings = [];
   const notes = [];
@@ -76,7 +86,10 @@ async function leaveServer(args, deps) {
   await removeServerConfig(dataDir);
   const manager = deps?.manager ?? serviceManager();
   try {
-    const installed = await manager.state().then((state) => state.installed, () => false);
+    const state = await manager.state().catch(() => {
+      return;
+    });
+    const installed = state?.installed === true;
     const previous = installed ? await manager.read() : undefined;
     if (!installed) {
       notes.push("no service installed — restart any running host so it stops dialing the server");
@@ -85,19 +98,30 @@ async function leaveServer(args, deps) {
     } else {
       const stripped = previous === undefined ? undefined : { ...previous, hostArgs: withoutRelayArgs(previous.hostArgs) };
       const rewriting = stripped !== undefined && stripped.hostArgs.length !== previous.hostArgs.length;
-      const port = argValue(previous?.hostArgs ?? [], "--port");
-      const code = await restartService({
-        force: false,
-        argv: ["--data-dir", dataDir, ...port === undefined ? [] : ["--url", `ws://127.0.0.1:${port}`]],
-        manager,
-        ...rewriting ? {
-          restart: async () => {
+      if (state.stopped) {
+        if (rewriting) {
+          try {
             await manager.install(stripped);
+          } finally {
+            await manager.stop();
           }
-        } : {}
-      });
-      if (code !== 0)
-        warnings.push("the service restart did not finish — check `service status`");
+        }
+        notes.push(`the service is stopped and stays off until \`${commandHint("service")} start\``);
+      } else {
+        const port = argValue(previous?.hostArgs ?? [], "--port");
+        const code = await restartService({
+          force: false,
+          argv: ["--data-dir", dataDir, ...port === undefined ? [] : ["--url", `ws://127.0.0.1:${port}`]],
+          manager,
+          ...rewriting ? {
+            restart: async () => {
+              await manager.install(stripped);
+            }
+          } : {}
+        });
+        if (code !== 0)
+          warnings.push("the service restart did not finish — check `service status`");
+      }
     }
   } catch (error) {
     warnings.push(`could not update the service definition: ${message(error)} — remove --relay from it and restart manually`);

package/dist/{chunk-c5p9xkd8.js → chunk-aqj9wfmb.js}

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

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

@@ -3,7 +3,7 @@ import {
   fromBase64Url,
   parseEndpointSet,
   toBase64Url
-} from "./chunk-sygeb9qb.js";
+} from "./chunk-pqe7q1s7.js";
 
 // packages/protocol/src/relay.ts
 import { ed25519 } from "@noble/curves/ed25519.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" });