pinomad 0.10.0 → 0.12.0

package/dist/chunk-gg2dcqbg.js

@@ -0,0 +1,458 @@
+import {
+  assertSecureServerOrigin,
+  isSecureServerOrigin,
+  probeServerAccounts,
+  runServerOperation
+} from "./chunk-7mn38n4f.js";
+import {
+  constantValue,
+  openHostSettings
+} from "./chunk-nppgxh6c.js";
+import {
+  loadHostKey,
+  loadRelayKey
+} from "./chunk-t91zt5f0.js";
+import {
+  writeServerConfig
+} from "./chunk-nq57fdnq.js";
+import {
+  relayHostId
+} from "./chunk-g3ahp7b9.js";
+import {
+  argValue,
+  installSpec,
+  restartService,
+  serviceManager,
+  withoutRelayArgs
+} from "./chunk-t5abqsva.js";
+import {
+  cleanHostName,
+  normalizeHostName
+} from "./chunk-pqe7q1s7.js";
+import {
+  DEFAULT_DATA_DIR
+} from "./chunk-ngf1zatm.js";
+import {
+  commandHint,
+  hostEntry
+} from "./chunk-7wj0jh3t.js";
+
+// apps/host/src/cli/join.ts
+import { mkdir } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join, resolve as resolve2 } from "node:path";
+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;
+function browserCommand(os, env) {
+  if (env.SSH_CONNECTION !== undefined || env.SSH_TTY !== undefined)
+    return;
+  if (os === "darwin")
+    return "open";
+  if (os === "linux" && (env.DISPLAY !== undefined || env.WAYLAND_DISPLAY !== undefined))
+    return "xdg-open";
+  return;
+}
+var OPENER_SETTLE_MS = 2000;
+function openInBrowser(url, command = browserCommand(process.platform, process.env), settleMs = OPENER_SETTLE_MS) {
+  if (command === undefined)
+    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();
+  const name = os === "darwin" ? "macOS" : os === "linux" ? "Linux" : os === "win32" ? "Windows" : os;
+  return `${name} (${arch()})`;
+}
+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)));
+  const log = deps?.log ?? ((line) => console.log(line));
+  const now = deps?.now ?? Date.now;
+  const { origin } = args;
+  const timeoutMs = deps?.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
+  const post = async (path, payload) => {
+    const controller = new AbortController;
+    let timer;
+    const expired = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        controller.abort();
+        resolve(undefined);
+      }, timeoutMs);
+    });
+    const attempt = (async () => {
+      const response = await fetchImpl(`${origin}${path}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload),
+        redirect: "manual",
+        signal: controller.signal
+      });
+      const text = await response.text();
+      let body;
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = undefined;
+      }
+      return { status: response.status, body };
+    })().catch(() => {
+      return;
+    });
+    try {
+      return await Promise.race([attempt, expired]);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  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 ${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;
+  }
+  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 = 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(CODE_EXPIRED);
+      continue;
+    }
+    const answer = response.body;
+    if (response.status === 200 && isRecord(answer) && typeof answer.token === "string") {
+      log("Confirmed.");
+      return answer.token;
+    }
+    const code = response.status === 400 ? errorCode(answer) : undefined;
+    if (code === "access_denied")
+      throw new Error(`the join was denied on ${origin}`);
+    if (code === "expired_token")
+      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);
+    } else if (code !== "authorization_pending") {
+      throw new Error(`${origin} refused the join: ${code ?? `HTTP ${response.status}`}`);
+    }
+  }
+}
+
+// apps/host/src/cli/service-slot.ts
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+async function openServiceSlot(dataDir, manager) {
+  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 };
+}
+async function writeService(slot, edit, options) {
+  const { dataDir, manager, previous } = slot;
+  const fresh = installSpec(["--data-dir", dataDir, ...edit([])], {
+    execPath: process.execPath,
+    env: process.env,
+    home: homedir(),
+    cwd: process.cwd(),
+    mainPath: hostEntry.script,
+    entryArgs: hostEntry.args
+  });
+  if (!slot.state.installed) {
+    await manager.install(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");
+  if (same && !options.changed && slot.state.running)
+    return "unchanged";
+  const port = argValue(spec.hostArgs, "--port");
+  const code = await restartService({
+    force: false,
+    argv: ["--data-dir", dataDir, ...port === undefined ? [] : ["--url", `ws://127.0.0.1:${port}`]],
+    manager,
+    restart: async () => {
+      await manager.install(spec);
+    }
+  });
+  return code === 0 ? "updated" : "failed";
+}
+
+// apps/host/src/cli/join.ts
+var message = (error) => error instanceof Error ? error.message : String(error);
+async function joinServer(args, deps) {
+  const origin = args.origin.replace(/\/+$/, "");
+  const dataDir = resolve2(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);
+  const hostId = relayHostId(signingKey.publicKey);
+  const slot = await openServiceSlot(dataDir, deps?.manager ?? serviceManager());
+  const probe = await probeServerAccounts(origin, deps?.fetch);
+  if (probe === "unreachable")
+    throw new Error(`cannot reach ${origin} — check the address and that the server is up`);
+  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 name = normalizeHostName(args.name ?? storedName ?? deps?.hostname ?? hostname());
+  const joinToken = args.token ?? await requestJoinToken({ origin, hostId, name, code: args.code }, deps);
+  const reply = await runServerOperation({
+    origin,
+    signingKey,
+    noisePublicKey: hostKey.publicKey,
+    op: "join",
+    joinToken,
+    name
+  });
+  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}`);
+  }
+  if (reply.t !== "joined")
+    throw new Error(`unexpected answer to join: ${reply.t}`);
+  const username = reply.username;
+  let service;
+  try {
+    await writeServerConfig(dataDir, { origin, username });
+    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 });
+  } catch (error) {
+    throw new Error(`joined ${username} at ${origin}, but local setup failed: ${message(error)}
+` + (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 };
+}
+async function main(argv, deps) {
+  const { values, positionals } = parseArgs({
+    args: [...argv],
+    allowPositionals: true,
+    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] [--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);
+    console.log(`host id: ${outcome.hostId}`);
+    console.log(`joined ${outcome.username} at ${outcome.origin}`);
+    if (outcome.service === "installed")
+      console.log("service installed and started");
+    else if (outcome.service === "updated")
+      console.log("service definition updated; host restarted when idle");
+    else {
+      console.error("joined, but the service restart did not finish — check `service status`");
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    console.error(message(error));
+    process.exitCode = 1;
+  }
+}
+if (false)
+  ;
+
+export { openServiceSlot, writeService, joinServer, main };

package/dist/{chunk-73efzaf1.js → chunk-jeqsdcj1.js}

@@ -2,31 +2,40 @@
 import {
   restartService,
   serviceManager
-} from "./chunk-w2m9xkks.js";
+} from "./chunk-t5abqsva.js";
+import"./chunk-np4jd070.js";
 import"./chunk-kzbzacz9.js";
+import"./chunk-47ff1d1t.js";
+import"./chunk-pqe7q1s7.js";
 import {
+  hostAddressOptions
+} from "./chunk-ngf1zatm.js";
+import {
+  commandHint,
   globalPrefixOf,
   packageDir,
   packagedVersion
-} from "./chunk-zehwx009.js";
-import"./chunk-4sepcfpy.js";
-import"./chunk-jgd38rna.js";
-import"./chunk-sygeb9qb.js";
-import {
-  hostAddressOptions
-} from "./chunk-ngf1zatm.js";
+} from "./chunk-7wj0jh3t.js";
 import"./chunk-df32avw6.js";
 
 // apps/host/src/cli/upgrade.ts
 import { execFile, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
 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 step = (command, args, binDir) => new Promise((resolve) => {
+  const env = binDir === undefined ? process.env : { ...process.env, PATH: `${binDir}:${process.env.PATH ?? ""}` };
+  spawn(command, [...args], { cwd: repoRoot, env, stdio: "inherit" }).once("exit", (code) => resolve(code ?? 1));
 });
-var serviceInstalled = () => Promise.resolve().then(() => serviceManager().state()).then((state) => state.installed, () => false);
+function npmBeside(execPath) {
+  const binDir = dirname(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 serviceState = () => Promise.resolve().then(() => serviceManager().state()).catch(() => ({ installed: false, stopped: false }));
 async function main(argv, deps = {}) {
   const { values } = parseArgs({
     args: [...argv],
@@ -60,20 +69,28 @@ async function main(argv, deps = {}) {
       process.exitCode = 1;
       return;
     }
-    const code = await runStep("npm", ["install", "-g", "--prefix", prefix, "pinomad@latest"]);
+    const npm = npmBeside(process.execPath);
+    const code = await runStep(npm.command, [...npm.args, "install", "-g", "--prefix", prefix, "pinomad@latest"], npm.binDir);
     if (code !== 0) {
       process.exitCode = code;
       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) {}
 export {
+  npmBeside,
   main
 };