pinomad 0.13.0 → 0.14.0

package/dist/chunk-eerpgvy9.js

@@ -0,0 +1,315 @@
+import {
+  ProtocolMismatchError,
+  connectRemoteDurable
+} from "./chunk-e59k3bmz.js";
+import {
+  isParseArgsError
+} from "./chunk-kzbzacz9.js";
+import {
+  argValue,
+  installSpec,
+  serviceManager
+} from "./chunk-mxwcnnkg.js";
+import {
+  DEFAULT_DATA_DIR,
+  hostAddress
+} from "./chunk-ngf1zatm.js";
+import {
+  commandHint,
+  hostEntry,
+  packagedVersion
+} from "./chunk-1rdbnvy6.js";
+
+// apps/host/src/cli/service.ts
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs, promisify } from "node:util";
+
+// apps/host/src/service/idle.ts
+async function waitForIdle(remote, onBusy) {
+  if (remote.view.current().tasks === undefined)
+    await remote.controller.toggleTasks();
+  let announced = false;
+  await new Promise((resolve) => {
+    const check = () => {
+      const view = remote.view.current();
+      if (view.connection !== "connected") {
+        unsubscribe();
+        resolve();
+        return;
+      }
+      const tasks = view.tasks;
+      if (tasks === undefined)
+        return;
+      if (Object.keys(tasks.tasks).length === 0) {
+        unsubscribe();
+        resolve();
+        return;
+      }
+      if (!announced) {
+        announced = true;
+        onBusy(tasks);
+      }
+    };
+    const unsubscribe = remote.view.subscribe(check);
+    check();
+  });
+}
+
+// apps/host/src/cli/service.ts
+var run = promisify(execFile);
+var repoRoot = fileURLToPath(new URL("../../../../", import.meta.url));
+var message = (error) => error instanceof Error ? error.message : String(error);
+function connectToHost(url, token, timeoutMs = 3000) {
+  const connecting = connectRemoteDurable({ url, token, reconnectDelayMs: { min: 200, max: 2000 } });
+  const timedOut = Symbol("timedOut");
+  return Promise.race([
+    connecting,
+    new Promise((resolve2) => {
+      const timer = setTimeout(() => resolve2(timedOut), timeoutMs);
+      timer.unref();
+    })
+  ]).then((winner) => {
+    if (winner !== timedOut)
+      return winner;
+    connecting.then((remote) => remote.close(), () => {});
+    throw new Error("connect timed out");
+  });
+}
+async function install(argv) {
+  const spec = installSpec(argv, {
+    execPath: process.execPath,
+    env: process.env,
+    home: homedir(),
+    cwd: process.cwd(),
+    mainPath: hostEntry.script,
+    entryArgs: hostEntry.args
+  });
+  const path = await serviceManager().install(spec);
+  console.log(`installed ${path}`);
+  console.log(`data dir: ${spec.dataDir}`);
+  console.log(`browser link: ${commandHint("link")}    pairing QR: ${commandHint("pair")}`);
+}
+async function waitUntilIdle(address, connect, log) {
+  try {
+    const remote = await connect(address.url, address.token);
+    await waitForIdle(remote, (tasks) => {
+      log("waiting for running tasks to finish (Ctrl-C to cancel)");
+      for (const task of Object.values(tasks.tasks)) {
+        log(`  ${task.kind} in conversation ${task.conversationId}`);
+      }
+    });
+    remote.close();
+  } catch {}
+}
+async function stopService({
+  force,
+  argv,
+  manager = serviceManager(),
+  connect = connectToHost,
+  log = (line) => console.log(line),
+  logError = (line) => console.error(line)
+}) {
+  const state = await manager.state();
+  if (!state.installed) {
+    log(`service not installed (${commandHint("service")} install)`);
+    return 1;
+  }
+  if (state.stopped) {
+    log("already stopped");
+    return 0;
+  }
+  if (!force) {
+    const spec = argv.length === 0 ? await manager.read() : undefined;
+    const port = spec === undefined ? undefined : argValue(spec.hostArgs, "--port");
+    const flags = spec === undefined ? argv : ["--data-dir", spec.dataDir, ...port === undefined ? [] : ["--url", `ws://127.0.0.1:${port}`]];
+    const address = await hostAddress(flags).catch((error) => {
+      if (isParseArgsError(error))
+        throw error;
+      return;
+    });
+    if (address !== undefined)
+      await waitUntilIdle(address, connect, log);
+  }
+  const holdInterrupt = () => {};
+  process.on("SIGINT", holdInterrupt);
+  try {
+    await manager.stop();
+  } finally {
+    process.off("SIGINT", holdInterrupt);
+  }
+  const after = await manager.state();
+  if (!after.stopped) {
+    logError(`the host is still running (${after.detail}); run \`${commandHint("service")} stop\` again`);
+    return 1;
+  }
+  log(`stopped; it stays off, also after a restart, until \`${commandHint("service")} start\``);
+  return 0;
+}
+async function startService({
+  manager = serviceManager(),
+  log = (line) => console.log(line)
+} = {}) {
+  if (!(await manager.state()).installed) {
+    log(`service not installed (${commandHint("service")} install)`);
+    return 1;
+  }
+  await manager.start();
+  log("started");
+  return 0;
+}
+async function versionLine() {
+  if (packagedVersion !== undefined)
+    return `version: ${packagedVersion}`;
+  const head = await run("git", ["rev-parse", "--short", "HEAD"], { cwd: repoRoot }).then(({ stdout }) => stdout.trim(), () => "unknown");
+  return `checkout: ${head}`;
+}
+async function reachabilityLine(argv) {
+  try {
+    const { url, token } = await hostAddress(argv);
+    const remote = await connectToHost(url, token);
+    if (remote.view.current().tasks === undefined)
+      await remote.controller.toggleTasks();
+    const tasks = remote.view.current().tasks;
+    const count = tasks === undefined ? 0 : Object.keys(tasks.tasks).length;
+    remote.close();
+    return `host: reachable at ${url}, ${count} live task${count === 1 ? "" : "s"}`;
+  } catch (error) {
+    if (isParseArgsError(error))
+      throw error;
+    return `host: unreachable (${message(error)})`;
+  }
+}
+var serviceStatusJson = (state) => JSON.stringify({
+  installed: state.installed,
+  stopped: state.stopped,
+  running: state.running,
+  ...state.pid === undefined ? {} : { pid: state.pid },
+  detail: state.detail
+});
+async function status(argv) {
+  const state = await serviceManager().state();
+  if (argv.includes("--json")) {
+    console.log(serviceStatusJson(state));
+    return;
+  }
+  console.log(`service: ${state.installed ? state.detail : "not installed"}`);
+  console.log(await versionLine());
+  console.log(await reachabilityLine(argv));
+}
+async function restartService({
+  force,
+  argv,
+  manager = serviceManager(),
+  restart,
+  connect = connectToHost,
+  pollTimeoutMs = 30000,
+  pollDelayMs = 500
+}) {
+  const state = await manager.state();
+  if (!state.installed) {
+    console.log(`service not installed (${commandHint("service")} install)`);
+    return 1;
+  }
+  if (state.stopped && restart === undefined) {
+    console.log(`service stopped (${commandHint("service")} start)`);
+    return 1;
+  }
+  const address = await hostAddress(argv).catch((error) => {
+    if (isParseArgsError(error))
+      throw error;
+    return;
+  });
+  if (!force && address !== undefined)
+    await waitUntilIdle(address, connect, (line) => console.log(line));
+  await (restart?.() ?? manager.restart());
+  if (address === undefined) {
+    console.log("restart requested (host address unknown; not polling)");
+    return 0;
+  }
+  return awaitRestarted(address, { connect, pollTimeoutMs, pollDelayMs });
+}
+async function awaitRestarted(address, {
+  connect = connectToHost,
+  pollTimeoutMs = 30000,
+  pollDelayMs = 500
+} = {}) {
+  const deadline = Date.now() + pollTimeoutMs;
+  for (;; ) {
+    try {
+      const remote = await connect(address.url, address.token, 2000);
+      remote.close();
+      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 ${pollTimeoutMs / 1000}s after restart: ${message(error)}`);
+        return 1;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, pollDelayMs));
+    }
+  }
+}
+async function logs(argv) {
+  const { values } = parseArgs({
+    args: [...argv],
+    options: {
+      follow: { type: "boolean", default: false },
+      lines: { type: "string", short: "n", default: "100" },
+      "data-dir": { type: "string" }
+    }
+  });
+  const dataDir = resolve(values["data-dir"] ?? DEFAULT_DATA_DIR);
+  await serviceManager().logs(dataDir, Number(values.lines), values.follow);
+}
+async function main(argv) {
+  const [command, ...args] = argv;
+  try {
+    switch (command) {
+      case "install":
+        await install(args);
+        break;
+      case "uninstall":
+        await serviceManager().uninstall();
+        console.log("uninstalled");
+        break;
+      case "status":
+        await status(args);
+        break;
+      case "restart": {
+        const force = args.includes("--force");
+        process.exitCode = await restartService({ force, argv: args.filter((arg) => arg !== "--force") });
+        break;
+      }
+      case "stop": {
+        const force = args.includes("--force");
+        process.exitCode = await stopService({ force, argv: args.filter((arg) => arg !== "--force") });
+        break;
+      }
+      case "start":
+        process.exitCode = await startService();
+        break;
+      case "logs":
+        await logs(args);
+        break;
+      default:
+        console.error(`usage: ${commandHint("service")} install|uninstall|status|restart|stop|start|logs`);
+        process.exitCode = 1;
+    }
+  } catch (error) {
+    if (isParseArgsError(error))
+      throw error;
+    console.error(message(error));
+    process.exitCode = 1;
+  }
+}
+if (false) {}
+
+export { connectToHost, stopService, startService, versionLine, reachabilityLine, serviceStatusJson, restartService, awaitRestarted, main };

package/dist/chunk-eewxy4cp.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+import {
+  installCommand,
+  npmBeside,
+  packagePrefix
+} from "./chunk-0dh2k3er.js";
+import {
+  awaitRestarted,
+  connectToHost,
+  restartService
+} from "./chunk-eerpgvy9.js";
+import"./chunk-e59k3bmz.js";
+import"./chunk-kzbzacz9.js";
+import {
+  serviceManager
+} from "./chunk-mxwcnnkg.js";
+import {
+  hostSupportsCall
+} from "./chunk-1mjbt2z2.js";
+import"./chunk-6vbp1vva.js";
+import {
+  hostAddress,
+  hostAddressOptions
+} from "./chunk-ngf1zatm.js";
+import {
+  commandHint,
+  packageDir,
+  packagedVersion
+} from "./chunk-1rdbnvy6.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";
+
+// apps/host/src/cli/upgrade-via-host.ts
+var message = (error) => error instanceof Error ? error.message : String(error);
+async function hostUpgrade(remote, timeoutMs = 5000) {
+  if (!hostSupportsCall(remote.view.current().host?.protocol.minor ?? 0, "startUpgrade"))
+    return;
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => finish(undefined), timeoutMs);
+    timer.unref();
+    const finish = (value) => {
+      clearTimeout(timer);
+      unsubscribe();
+      resolve(value);
+    };
+    const check = () => {
+      const value = remote.view.current().upgrade;
+      if (value !== null)
+        finish(value);
+    };
+    const unsubscribe = remote.view.subscribe(check);
+    check();
+  });
+}
+async function upgradeWithHost(remote, when, log, onWaiting = () => {}) {
+  const initial = await hostUpgrade(remote);
+  if (initial === undefined || initial.blocked !== null)
+    return;
+  if (initial.phase !== "idle")
+    return { kind: "failed", message: `the host is already upgrading to pinomad@${initial.target ?? "?"}` };
+  try {
+    await remote.controller.checkUpgrade();
+  } catch (error) {
+    log(`the host won't check for releases (${message(error)}); upgrading here`);
+    return;
+  }
+  const checked = remote.view.current().upgrade;
+  if (checked === null || checked.available === null)
+    return { kind: "current", version: checked?.current ?? null };
+  const version = checked.available.version;
+  log(`upgrading the host to pinomad@${version}`);
+  try {
+    await remote.controller.startUpgrade(when);
+  } catch (error) {
+    return { kind: "failed", message: message(error) };
+  }
+  const attempt = remote.view.current().upgrade?.attempt;
+  return new Promise((resolve) => {
+    let phase;
+    let installed = false;
+    const finish = (outcome) => {
+      unsubscribe();
+      resolve(outcome);
+    };
+    const check = () => {
+      const view = remote.view.current();
+      if (view.connection !== "connected") {
+        finish(installed ? { kind: "restarting", version } : { kind: "failed", message: "lost the host before the install finished" });
+        return;
+      }
+      const value = view.upgrade;
+      if (value === null)
+        return;
+      if (value.failure !== null && value.failure.attempt === attempt) {
+        finish({ kind: "failed", message: value.failure.message });
+        return;
+      }
+      if (value.phase === phase)
+        return;
+      phase = value.phase;
+      if (phase === "idle") {
+        finish({ kind: "cancelled" });
+        return;
+      }
+      if (phase === "waiting") {
+        log("waiting for running tasks to finish (Ctrl-C to cancel)");
+        onWaiting(() => remote.controller.cancelUpgrade());
+      }
+      if (phase === "installing") {
+        installed = true;
+        log(`installing pinomad@${version}`);
+      }
+    };
+    const unsubscribe = remote.view.subscribe(check);
+    check();
+  });
+}
+
+// apps/host/src/cli/upgrade.ts
+var exec = promisify(execFile);
+var repoRoot = fileURLToPath(new URL("../../../../", import.meta.url));
+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 serviceState = () => Promise.resolve().then(() => serviceManager().state()).catch(() => ({ installed: false, stopped: false }));
+async function upgradeThroughHost(argv, force) {
+  const service = await serviceState();
+  if (!service.installed || service.stopped)
+    return;
+  const address = await hostAddress(argv.filter((arg) => arg !== "--force")).catch(() => {
+    return;
+  });
+  if (address === undefined)
+    return;
+  const remote = await connectToHost(address.url, address.token).catch(() => {
+    return;
+  });
+  if (remote === undefined)
+    return;
+  try {
+    let cancel;
+    const interrupt = () => {
+      if (cancel === undefined)
+        process.exit(130);
+      cancel().finally(() => {
+        console.log("upgrade cancelled");
+        process.exit(130);
+      });
+    };
+    process.on("SIGINT", interrupt);
+    const outcome = await upgradeWithHost(remote, force ? "now" : "idle", (line) => console.log(line), (c) => cancel = c).finally(() => process.off("SIGINT", interrupt));
+    if (outcome === undefined)
+      return;
+    switch (outcome.kind) {
+      case "current":
+        console.log(`already on the latest release (${outcome.version ?? "unknown"})`);
+        return 0;
+      case "failed":
+        console.error(`upgrade failed; the host keeps running the old version:
+${outcome.message}`);
+        return 1;
+      case "cancelled":
+        console.log("the upgrade was cancelled on another device");
+        return 1;
+      case "restarting":
+        return awaitRestarted(address);
+    }
+  } finally {
+    remote.close();
+  }
+}
+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 viaHost = await (deps.viaHost ?? upgradeThroughHost)(argv, values.force);
+    if (viaHost !== undefined) {
+      (deps.exit ?? process.exit)(viaHost);
+      return;
+    }
+    const prefix = packagePrefix();
+    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 npm = installCommand(npmBeside(process.execPath), prefix, "pinomad@latest");
+    const code = await runStep(npm.command, npm.args, npm.binDir);
+    if (code !== 0) {
+      process.exitCode = code;
+      return;
+    }
+  }
+  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 {
+  upgradeThroughHost,
+  npmBeside,
+  main
+};

package/dist/{chunk-maqv34cs.js → chunk-evbv1fkn.js}

@@ -1,10 +1,10 @@
 import {
   connectRemoteDurable
-} from "./chunk-4fferbxw.js";
-import"./chunk-kmzzjv53.js";
+} from "./chunk-e59k3bmz.js";
+import"./chunk-1mjbt2z2.js";
 import {
   isLoopbackUrl
-} from "./chunk-pqe7q1s7.js";
+} from "./chunk-6vbp1vva.js";
 import {
   hostAddress
 } from "./chunk-ngf1zatm.js";

package/dist/{chunk-ra86wjp5.js → chunk-ex5yr09h.js}

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 import {
+  awaitRestarted,
+  connectToHost,
   main,
   reachabilityLine,
   restartService,
@@ -7,13 +9,14 @@ import {
   startService,
   stopService,
   versionLine
-} from "./chunk-wd7aracm.js";
-import"./chunk-4fferbxw.js";
+} from "./chunk-eerpgvy9.js";
+import"./chunk-e59k3bmz.js";
 import"./chunk-kzbzacz9.js";
-import"./chunk-kmzzjv53.js";
-import"./chunk-pqe7q1s7.js";
+import"./chunk-mxwcnnkg.js";
+import"./chunk-1mjbt2z2.js";
+import"./chunk-6vbp1vva.js";
 import"./chunk-ngf1zatm.js";
-import"./chunk-s0h7c7da.js";
+import"./chunk-1rdbnvy6.js";
 import"./chunk-df32avw6.js";
 export {
   versionLine,
@@ -22,5 +25,7 @@ export {
   serviceStatusJson,
   restartService,
   reachabilityLine,
-  main
+  main,
+  connectToHost,
+  awaitRestarted
 };

package/dist/{chunk-t91zt5f0.js → chunk-hg9gs396.js}

@@ -3,7 +3,7 @@ import {
   generateKeyPair,
   keyPairFromPrivate,
   toBase64Url
-} from "./chunk-pqe7q1s7.js";
+} from "./chunk-6vbp1vva.js";
 
 // apps/host/src/devices.ts
 import { link, readFile, unlink, writeFile } from "node:fs/promises";

package/dist/{chunk-90g1cg9n.js → chunk-mtkvft88.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-ngf1zatm.js";
 import {
   packagedVersion
-} from "./chunk-s0h7c7da.js";
+} from "./chunk-1rdbnvy6.js";
 import"./chunk-df32avw6.js";
 
 // apps/host/src/cli/web-link.ts