@kvbox/cli 0.5.8 → 0.5.9

package/dist/kvbox.js

@@ -162,13 +162,13 @@ function versionOf(srcFileUrl, injected) {
 }
 
 // src/version.ts
-var VERSION = versionOf(import.meta.url, true ? "0.5.8" : void 0);
+var VERSION = versionOf(import.meta.url, true ? "0.5.9" : void 0);
 
 // src/commands/vm/index.ts
 import { Command as Command15 } from "commander";
 
 // src/commands/vm/connect.ts
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 import { Command as Command2 } from "commander";
 
 // src/cert.ts
@@ -466,6 +466,12 @@ var CapacitySchema = z2.object({
   reservedVcpu: z2.number().int(),
   running: z2.number().int()
 });
+var RecoveryReportSchema = z2.object({
+  at: z2.string(),
+  booted: z2.array(z2.string()),
+  leftStopped: z2.array(z2.string()),
+  failed: z2.array(z2.object({ box: z2.string(), error: z2.string() }))
+});
 var HealthSchema = z2.object({
   ok: z2.literal(true),
   version: z2.string(),
@@ -489,7 +495,9 @@ var HealthSchema = z2.object({
     publicIp: z2.string(),
     /** The relay's WireGuard endpoint the tunnel dials. */
     endpoint: z2.string()
-  }).nullable().optional()
+  }).nullable().optional(),
+  /** Boxes brought back at the server's last start; null when there were none or it is still at it. Older servers omit it. */
+  recovery: RecoveryReportSchema.nullable().optional()
 });
 var MachineUsageSchema = z2.object({
   name: z2.string(),
@@ -739,6 +747,34 @@ function groupWithMember(gid, user, groupFile) {
   return void 0;
 }
 
+// src/systemd.ts
+import { spawnSync } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve } from "path";
+var UNIT = "kvbox-server";
+var UNIT_FILE = `/etc/systemd/system/${UNIT}.service`;
+function hasUnitFor(p, file = UNIT_FILE) {
+  let text;
+  try {
+    text = readFileSync2(file, "utf8");
+  } catch {
+    return false;
+  }
+  const home = /^Environment="?KVBOX_HOME=([^"\n]+)"?$/m.exec(text)?.[1];
+  return home !== void 0 && resolve(home) === resolve(p.home);
+}
+function startUnitProcess() {
+  const res = spawnSync("sudo", ["-n", "systemctl", "start", UNIT], { encoding: "utf8" });
+  return { ok: res.status === 0, out: `${res.stdout ?? ""}${res.stderr ?? ""}`.trim() };
+}
+function unitActive() {
+  const res = spawnSync("systemctl", ["is-active", UNIT], { encoding: "utf8" });
+  return (res.stdout ?? "").trim() === "active";
+}
+function startsAtBoot(p) {
+  return hasUnitFor(p) && spawnSync("systemctl", ["is-enabled", "--quiet", UNIT]).status === 0;
+}
+
 // src/client.ts
 var ORG_SLUG_RE = /^[a-z0-9][a-z0-9._-]{0,31}$/;
 function orgOption(opts) {
@@ -987,17 +1023,17 @@ function sshArgs(ep, p = paths()) {
 async function waitForSsh(ep, timeoutMs = 3e4) {
   const { connect } = await import("net");
   const deadline = Date.now() + timeoutMs;
-  const attempt = () => new Promise((resolve) => {
+  const attempt = () => new Promise((resolve2) => {
     const sock = connect({ host: ep.host, port: ep.port, timeout: 1e3 });
     sock.once("connect", () => {
       sock.destroy();
-      resolve(true);
+      resolve2(true);
     });
     sock.once("timeout", () => {
       sock.destroy();
-      resolve(false);
+      resolve2(false);
     });
-    sock.once("error", () => resolve(false));
+    sock.once("error", () => resolve2(false));
   });
   while (Date.now() < deadline) {
     if (await attempt()) return;
@@ -1006,14 +1042,15 @@ async function waitForSsh(ep, timeoutMs = 3e4) {
   throw new KvboxError(`box at ${ep.host}:${ep.port} did not answer within ${Math.round(timeoutMs / 1e3)}s`);
 }
 var NOT_A_HOST_HINT = "kvbox-server is not installed, so this machine is not a kvbox host. Set it up with install-server.sh, or log in to the cloud with: kvbox login";
-async function lastErrorLine(logPath) {
+async function lastErrorLine(logPath, from = 0) {
   const { readFile: readFile6 } = await import("fs/promises");
-  const text = await readFile6(logPath, "utf8").catch(() => "");
+  const text = (await readFile6(logPath).catch(() => Buffer.alloc(0))).subarray(from).toString("utf8");
   const lines = text.trimEnd().split("\n").slice(-20).reverse();
   return lines.find((l) => l.startsWith("error: "))?.slice("error: ".length);
 }
 async function startLocalServer(p = paths(), timeoutMs = 5e3) {
   await mkdir2(p.home, { recursive: true });
+  if (hasUnitFor(p)) return startUnit(p, timeoutMs);
   const log = openSync(p.serverLog, "a");
   const launcher = serverLauncher();
   const child = spawn(launcher.cmd, launcher.args, { detached: true, stdio: ["ignore", log, log] });
@@ -1027,29 +1064,45 @@ async function startLocalServer(p = paths(), timeoutMs = 5e3) {
       });
     });
   });
-  const ready = (async () => {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      if (await stat(p.serverSock).then(() => true, () => false)) {
-        const probe = new ServerClient({ kind: "local", socketPath: p.serverSock }, { autoStart: false });
-        try {
-          await probe.health();
-          return;
-        } catch {
-        } finally {
-          await probe.close();
-        }
-      }
-      await sleep(100);
-    }
-    throw new KvboxError(`kvbox-server did not start within ${timeoutMs / 1e3}s; see ${p.serverLog}`);
-  })();
-  await Promise.race([ready, failed]);
+  await Promise.race([serving(p, timeoutMs), failed]);
   child.removeAllListeners("exit");
   child.unref();
   const pid = Number.parseInt(await readFile3(p.serverPid, "utf8").catch(() => ""), 10);
   return { pid: Number.isNaN(pid) ? child.pid ?? -1 : pid, socketPath: p.serverSock, viaGroup: launcher.viaGroup };
 }
+async function startUnit(p, timeoutMs) {
+  const logFrom = await stat(p.serverLog).then((s) => s.size, () => 0);
+  const res = startUnitProcess();
+  if (!res.ok) {
+    const why = res.out || await lastErrorLine(p.serverLog, logFrom) || "systemctl start failed";
+    throw new KvboxError(`kvbox-server could not start: ${why} (journalctl -u ${UNIT}; rerun install-server.sh if sudo asked for a password)`);
+  }
+  await serving(p, timeoutMs, async () => {
+    if (unitActive()) return;
+    const why = await lastErrorLine(p.serverLog, logFrom) ?? "it exited right after starting";
+    throw new KvboxError(`kvbox-server could not start: ${why} (journalctl -u ${UNIT})`);
+  });
+  const pid = Number.parseInt(await readFile3(p.serverPid, "utf8").catch(() => ""), 10);
+  return { pid: Number.isNaN(pid) ? -1 : pid, socketPath: p.serverSock, viaGroup: void 0 };
+}
+async function serving(p, timeoutMs, check) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await check?.();
+    if (await stat(p.serverSock).then(() => true, () => false)) {
+      const probe = new ServerClient({ kind: "local", socketPath: p.serverSock }, { autoStart: false });
+      try {
+        await probe.health();
+        return;
+      } catch {
+      } finally {
+        await probe.close();
+      }
+    }
+    await sleep(100);
+  }
+  throw new KvboxError(`kvbox-server did not start within ${timeoutMs / 1e3}s; see ${p.serverLog}`);
+}
 
 // src/commands/vm/new.ts
 import { Command, Option } from "commander";
@@ -1104,14 +1157,14 @@ var connectCommand = new Command2("connect").alias("cn").description("open a she
   } finally {
     await client.close();
   }
-  let res = spawnSync("ssh", [...sshArgs(ep), ...cmdArgs], { stdio: "inherit" });
+  let res = spawnSync2("ssh", [...sshArgs(ep), ...cmdArgs], { stdio: "inherit" });
   if (res.error) throw new KvboxError(`could not run ssh: ${res.error.message}`);
   if (res.status === SSH_FAILED) {
     const again = await clientFor(cmd.optsWithGlobals());
     const retry = await renewAfterRefusal(again, cert, owner).finally(() => again.close());
     if (retry) {
       info("renewed your SSH certificate, trying again\u2026");
-      res = spawnSync("ssh", [...sshArgs(ep), ...cmdArgs], { stdio: "inherit" });
+      res = spawnSync2("ssh", [...sshArgs(ep), ...cmdArgs], { stdio: "inherit" });
       if (res.error) throw new KvboxError(`could not run ssh: ${res.error.message}`);
     }
   }
@@ -1155,12 +1208,12 @@ async function runSsh(ssh, opts) {
     timedOut = true;
     child.kill("SIGTERM");
   }, opts.timeout * 1e3);
-  const status2 = await new Promise((resolve, reject) => {
+  const status2 = await new Promise((resolve2, reject) => {
     child.once("error", (err) => reject(new KvboxError(`could not run ssh: ${err.message}`)));
     child.once("close", (code, signal) => {
-      if (timedOut) resolve(TIMEOUT_EXIT);
-      else if (code !== null) resolve(code);
-      else resolve(signal === "SIGINT" ? 130 : 1);
+      if (timedOut) resolve2(TIMEOUT_EXIT);
+      else if (code !== null) resolve2(code);
+      else resolve2(signal === "SIGINT" ? 130 : 1);
     });
   }).finally(() => clearTimeout(timer));
   return { status: status2, chunks, timedOut };
@@ -1515,7 +1568,7 @@ async function restartLocalServer(p = paths()) {
   return (await startLocalServer(p)).pid;
 }
 function runKvboxServer(args) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const child = spawn3("kvbox-server", args, { stdio: ["ignore", "pipe", "pipe"] });
     let out = "";
     let err = "";
@@ -1525,7 +1578,7 @@ function runKvboxServer(args) {
       reject(new KvboxError(e.code === "ENOENT" ? NOT_A_HOST_HINT : `could not run kvbox-server: ${e.message}`));
     });
     child.once("close", (code) => {
-      if (code === 0) resolve(out.trimEnd());
+      if (code === 0) resolve2(out.trimEnd());
       else reject(new KvboxError(err.trim().replace(/^error: /, "") || `kvbox-server ${args[0] ?? ""} exited with code ${String(code)}`, code === 2 ? 2 : 1));
     });
   });
@@ -1580,9 +1633,17 @@ var statusCommand = new Command20("status").description("show whether this machi
   const client = await clientFor({ ...cmd.optsWithGlobals(), local: true });
   try {
     const health = await client.health();
-    if (opts.json) json(health);
+    const atBoot = startsAtBoot(paths());
+    if (opts.json) json({ ...health, startsAtBoot: atBoot });
     else {
       info(`kvbox-server ${health.version} running, pid ${health.pid}`);
+      info(atBoot ? "starts at boot: yes, and brings back the boxes that were running" : "starts at boot: no (install-server.sh sets that up)");
+      const r = health.recovery;
+      if (r) {
+        if (r.booted.length > 0) info(`after the last restart it booted again: ${r.booted.join(", ")}`);
+        if (r.leftStopped.length > 0) info(`left stopped (were in standby, their memory was lost): ${r.leftStopped.join(", ")}`);
+        for (const f of r.failed) info(`did not come back: ${f.box} (${f.error})`);
+      }
       if (health.controlPlane) info(`control plane: ${health.controlPlane.name} at ${health.controlPlane.url}, this host answers it on ${health.controlPlane.hostUrl}`);
       else info("control plane: none (kvbox server join <url> --token <token> puts this machine behind one)");
       if (health.relay) info(`relay: ${health.relay.name} lends this machine ${health.relay.publicIp} (tunnel to ${health.relay.endpoint})`);
@@ -1646,7 +1707,7 @@ function describeReport(report) {
 var serverCommand = new Command23("server").description("run or manage the kvbox server").addCommand(startCommand2).addCommand(statusCommand).addCommand(stopCommand2).addCommand(joinCommand).addCommand(leaveCommand).addCommand(relayCommand).addCommand(trustCaCommand);
 
 // src/commands/login.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
 import { hostname as osHostname } from "os";
 import { createInterface } from "readline/promises";
@@ -1698,7 +1759,7 @@ async function ensureSshKey(p = paths(), hostname = osHostname()) {
   await mkdir3(p.ssh, { recursive: true, mode: 448 });
   const havePrivate = await readFile5(p.sshKey).then(() => true, () => false);
   const args = havePrivate ? ["-y", "-f", p.sshKey] : ["-q", "-t", "ed25519", "-N", "", "-C", `kvbox@${hostname}`, "-f", p.sshKey];
-  const res = spawnSync2("ssh-keygen", args, { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" });
+  const res = spawnSync3("ssh-keygen", args, { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" });
   if (res.error) {
     if (res.error.code === "ENOENT") throw new KvboxError("ssh-keygen not found; install OpenSSH");
     throw new KvboxError(`could not run ssh-keygen: ${res.error.message}`);