pinomad 0.11.0 → 0.12.0

package/dist/{chunk-gtdpjqa3.js → chunk-gg2dcqbg.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-nppgxh6c.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-t5abqsva.js";
 import {
   cleanHostName,
   normalizeHostName
@@ -35,7 +35,7 @@ import {
 import {
   commandHint,
   hostEntry
-} from "./chunk-sd5fkxjj.js";
+} from "./chunk-7wj0jh3t.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);
@@ -179,7 +318,7 @@ async function requestJoinToken(args, deps) {
 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`);
@@ -249,7 +388,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,
@@ -273,7 +412,7 @@ async function joinServer(args, deps) {
     service = await writeService(slot, (hostArgs) => edit(withoutRelayArgs(hostArgs)), { changed: true });
   } 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 +420,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-6d16c2fv.js → chunk-jeqsdcj1.js}

@@ -2,19 +2,20 @@
 import {
   restartService,
   serviceManager
-} from "./chunk-vvj9b1gc.js";
-import"./chunk-jt34g8st.js";
+} from "./chunk-t5abqsva.js";
+import"./chunk-np4jd070.js";
 import"./chunk-kzbzacz9.js";
-import"./chunk-xqycs43g.js";
+import"./chunk-47ff1d1t.js";
 import"./chunk-pqe7q1s7.js";
 import {
   hostAddressOptions
 } from "./chunk-ngf1zatm.js";
 import {
+  commandHint,
   globalPrefixOf,
   packageDir,
   packagedVersion
-} from "./chunk-sd5fkxjj.js";
+} from "./chunk-7wj0jh3t.js";
 import"./chunk-df32avw6.js";
 
 // apps/host/src/cli/upgrade.ts
@@ -34,7 +35,7 @@ function npmBeside(execPath) {
   const cli = join(binDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js");
   return existsSync(cli) ? { command: execPath, args: [cli], binDir } : { command: "npm", args: [] };
 }
-var serviceInstalled = () => Promise.resolve().then(() => serviceManager().state()).then((state) => state.installed, () => false);
+var serviceState = () => Promise.resolve().then(() => serviceManager().state()).catch(() => ({ installed: false, stopped: false }));
 async function main(argv, deps = {}) {
   const { values } = parseArgs({
     args: [...argv],
@@ -75,11 +76,17 @@ async function main(argv, deps = {}) {
       return;
     }
   }
-  if (!await (deps.serviceInstalled ?? serviceInstalled)()) {
+  const service = await (deps.serviceState ?? serviceState)();
+  if (!service.installed) {
     console.log("service not installed; upgrade done, nothing restarted");
     process.exitCode = 0;
     return;
   }
+  if (service.stopped) {
+    console.log(`service stopped; upgrade done, it stays off until \`${commandHint("service")} start\``);
+    process.exitCode = 0;
+    return;
+  }
   (deps.exit ?? process.exit)(await restart({ force: values.force, argv: argv.filter((arg) => arg !== "--force") }));
 }
 if (false) {}