@peerbit/server 5.9.5 → 5.10.0

package/dist/ui/index.html

@@ -23,7 +23,7 @@
       Learn how to configure a non-root public URL by running `npm run build`.
     -->
 	<title>Peerbit</title>
-  <script type="module" crossorigin src="/assets/index-BEgs1gyX.js"></script>
+  <script type="module" crossorigin src="/assets/index-Dst3R_bZ.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-CIfVvUo9.css">
 </head>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peerbit/server",
-  "version": "5.9.5",
+  "version": "5.10.0",
   "author": "dao.xyz",
   "repository": {
     "type": "git",
@@ -26,7 +26,8 @@
     "./remotes.js": "./dist/src/remotes.browser.js",
     "./dist/src/docker.js": "./dist/src/docker.browser.js",
     "./docker.js": "./dist/src/docker.browser.js",
-    "./dist/src/aws.js": "./dist/src/aws.browser.js"
+    "./dist/src/aws.js": "./dist/src/aws.browser.js",
+    "./dist/src/hetzner.js": "./dist/src/hetzner.browser.js"
   },
   "files": [
     "dist",
@@ -66,7 +67,7 @@
     "@types/libsodium-wrappers": "^0.7.14",
     "uuid": "^10.0.0",
     "@peerbit/test-lib": "0.0.1",
-    "@peerbit/test-utils": "2.3.5"
+    "@peerbit/test-utils": "2.3.6"
   },
   "dependencies": {
     "axios": "^1.4.0",
@@ -88,10 +89,10 @@
     "memory-level": "^3.1.0",
     "multiformats": "^13.4.1",
     "abstract-level": "^3.1.0",
-    "peerbit": "4.4.5",
+    "peerbit": "4.4.6",
     "@peerbit/blocks": "3.1.3",
     "@peerbit/crypto": "2.4.0",
-    "@peerbit/program": "5.4.3",
+    "@peerbit/program": "5.4.4",
     "@peerbit/pubsub": "4.1.1",
     "@peerbit/time": "2.3.0"
   },

package/src/aws.ts

@@ -57,6 +57,7 @@ const setupUserData = (
 	serverVersion?: string,
 ) => {
 	const peerIdStrings = grantAccess.map((x) => x.toString());
+	const grantArgs = peerIdStrings.map((key) => `--ga ${key}`).join(" ");
 
 	// better-sqlite3 force use to install build-essentials for `make` command, TOOD dont bundle better-sqlite3 by default?
 	const versionSpec = serverVersion ? `@${serverVersion}` : "";
@@ -67,7 +68,7 @@ sudo apt-get install -y nodejs
 sudo apt-get install -y build-essential
 npm install -g @peerbit/server${versionSpec}
 sudo peerbit domain test --email ${email}
-peerbit start ${peerIdStrings.map((key) => `--ga ${key}`)} > log.txt 2>&1 &
+peerbit start ${grantArgs} > log.txt 2>&1 &
 `;
 };
 const PURPOSE_TAG_NAME = "Purpose";

package/src/cli.ts

@@ -30,6 +30,11 @@ import {
 	loadConfig,
 	startCertbot,
 } from "./domain.js";
+import {
+	HETZNER_SERVER_TYPES,
+	launchNodes as launchHetznerNodes,
+	terminateNode as terminateHetznerNode,
+} from "./hetzner.js";
 import { DEFAULT_REMOTE_GROUP, type RemoteObject, Remotes } from "./remotes.js";
 import { LOCAL_API_PORT } from "./routes.js";
 import { startServerWithNode } from "./server.js";
@@ -457,6 +462,152 @@ export const cli = async (args?: string[]) => {
 								}
 							},
 						})
+						.command({
+							command: "hetzner",
+							describe: "Spawn remote nodes on Hetzner Cloud",
+							builder: (hetznerArgs: Argv) => {
+								hetznerArgs.option("count", {
+									describe: "Amount of nodes to spawn",
+									defaultDescription: "One node",
+									type: "number",
+									alias: "c",
+									default: 1,
+								});
+								hetznerArgs.option("location", {
+									describe: "Location (e.g. fsn1, nbg1, hel1, ash, hil)",
+									type: "string",
+									alias: "l",
+									default: "fsn1",
+								});
+								hetznerArgs.option("group", {
+									describe: "Remote group to launch nodes in",
+									type: "string",
+									alias: "g",
+									default: DEFAULT_REMOTE_GROUP,
+								});
+								hetznerArgs.option("server-type", {
+									describe: "Server type",
+									type: "string",
+									alias: "t",
+									choices: [...HETZNER_SERVER_TYPES],
+									default: "cx11",
+								});
+
+								hetznerArgs.option("name", {
+									describe: "Name prefix for spawned nodes",
+									type: "string",
+									alias: "n",
+									default: "peerbit-node",
+								});
+								hetznerArgs.option("grant-access", {
+									describe: "Grant access to public keys on start",
+									defaultDescription:
+										"The publickey of this device located in 'directory'",
+									type: "string",
+									array: true,
+									alias: "ga",
+								});
+								hetznerArgs.option("directory", {
+									describe: "Peerbit directory",
+									defaultDescription: "~.peerbit",
+									type: "string",
+									alias: "d",
+									default: getHomeConfigDir(),
+								});
+								hetznerArgs.option("email", {
+									describe: "Email for Let's security messages",
+									type: "string",
+									alias: "e",
+									demandOption: true,
+								});
+								hetznerArgs.option("token", {
+									describe: "Hetzner Cloud API token (or set HCLOUD_TOKEN)",
+									type: "string",
+									alias: ["tok"],
+								});
+								hetznerArgs.option("image", {
+									describe: "Image to use (e.g. ubuntu-22.04)",
+									type: "string",
+									default: "ubuntu-22.04",
+								});
+								hetznerArgs.option("server-version", {
+									describe:
+										"@peerbit/server version or tag to install on the instance (e.g. 5.7.0-58d3d09)",
+									type: "string",
+									alias: ["sv"],
+								});
+								return hetznerArgs;
+							},
+							handler: async (args) => {
+								const self = (
+									await getKeypair(args.directory)
+								).publicKey.toPeerId();
+								const accessGrant: PeerId[] =
+									args["grant-access"]?.length > 0
+										? (args["grant-access"] as string[]).map((x) =>
+												peerIdFromString(x),
+											)
+										: [];
+								accessGrant.push(self);
+								const nodes = await launchHetznerNodes({
+									token: (args.token as string) || undefined,
+									email: args.email as string,
+									count: args.count,
+									namePrefix: args.name,
+									location: args.location,
+									serverType: args["server-type"],
+									grantAccess: accessGrant,
+									image: args.image,
+									serverVersion:
+										(args["server-version"] as string) || undefined,
+								});
+
+								console.log(
+									`Waiting for ${args.count} ${
+										args.count > 1 ? "nodes" : "node"
+									} to spawn. This might take a few minutes. You can watch the progress in your Hetzner Cloud console.`,
+								);
+								const twirlTimer = (function () {
+									const P = ["\\", "|", "/", "-"];
+									let x = 0;
+									return setInterval(function () {
+										process.stdout.write(
+											"\r" + "Loading: " + chalk.hex(colors[x])(P[x++]),
+										);
+										x &= 3;
+									}, 250);
+								})();
+								for (const node of nodes) {
+									try {
+										const domain = await waitForDomain(node.publicIp);
+										const remotes = new Remotes(getRemotesPath(args.directory));
+										remotes.add({
+											name: node.name,
+											address: domain,
+											group: args.group,
+											origin: {
+												type: "hetzner",
+												serverId: node.serverId,
+												location: node.location,
+											},
+										});
+									} catch (error: any) {
+										process.stdout.write("\r");
+										console.error(
+											`Error waiting for domain for ip: ${
+												node.publicIp
+											} to be available: ${error?.toString()}`,
+										);
+									}
+								}
+								process.stdout.write("\r");
+								clearInterval(twirlTimer);
+								console.log(`New nodes available (${nodes.length}):`);
+								for (const node of nodes) {
+									console.log(chalk.green(node.name));
+								}
+							},
+						})
 						.strict()
 						.demandCommand();
 				})
@@ -469,6 +620,11 @@ export const cli = async (args?: string[]) => {
 							type: "boolean",
 							default: false,
 						});
+						killArgs.option("token", {
+							describe: "Used for Hetzner Cloud API (or set HCLOUD_TOKEN)",
+							type: "string",
+							alias: ["tok"],
+						});
 						killArgs.positional("name", {
 							type: "string",
 							describe: "Remote name",
@@ -495,6 +651,11 @@ export const cli = async (args?: string[]) => {
 										instanceId: remote.origin.instanceId,
 										region: remote.origin.region,
 									});
+								} else if (remote.origin?.type === "hetzner") {
+									await terminateHetznerNode({
+										serverId: remote.origin.serverId,
+										token: (args.token as string) || undefined,
+									});
 								}
 							}
 						}
@@ -537,7 +698,9 @@ export const cli = async (args?: string[]) => {
 									remote.group || "",
 									remote.origin?.type === "aws"
 										? `aws\n${remote.origin.region}\n${remote.origin.instanceId}`
-										: "",
+										: remote.origin?.type === "hetzner"
+											? `hetzner\n${remote.origin.location}\n${remote.origin.serverId}`
+											: "",
 									resolvedOrRejected[ix].status === "fulfilled"
 										? chalk.green("Y")
 										: chalk.red("N"),

package/src/client.ts

@@ -358,12 +358,17 @@ export const createClient = async (
 		},
 
 		terminate: async () => {
-			const { terminateNode } = await import("./aws.js");
 			if (remote.origin?.type === "aws") {
+				const { terminateNode } = await import("./aws.js");
 				await terminateNode({
 					instanceId: remote.origin.instanceId,
 					region: remote.origin.region,
 				});
+			} else if (remote.origin?.type === "hetzner") {
+				const { terminateNode } = await import("./hetzner.js");
+				await terminateNode({
+					serverId: remote.origin.serverId,
+				});
 			}
 		},
 	};

package/src/docker.ts

@@ -1,44 +1,152 @@
 import { delay, waitFor } from "@peerbit/time";
 
-export const installDocker = async () => {
+type ExecResult = { stdout: string; stderr: string };
+
+const execCommand = async (cmd: string): Promise<ExecResult> => {
 	const { exec } = await import("child_process");
+	return new Promise((resolve, reject) => {
+		exec(cmd, (error, stdout, stderr) => {
+			if (error) {
+				(error as any).stdout = stdout;
+				(error as any).stderr = stderr;
+				reject(error);
+				return;
+			}
+			resolve({ stdout, stderr });
+		});
+	});
+};
 
-	// check if docker is installed
-	const dockerExist = async () => {
-		try {
-			await new Promise((resolve, reject) => {
-				exec("docker --version", (error, stdout, stderr) => {
-					if (error || stderr) {
-						reject();
-					}
-					resolve(stdout);
-				});
-			});
-			return true;
-		} catch (error) {
-			return false;
+const commandExists = async (command: string): Promise<boolean> => {
+	try {
+		await execCommand(`command -v ${command}`);
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+const getSudoPrefix = async (): Promise<string> => {
+	const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
+	if (isRoot) {
+		return "";
+	}
+	if (await commandExists("sudo")) {
+		return "sudo ";
+	}
+	throw new Error("Docker installation requires elevated privileges (sudo not found)");
+};
+
+const dockerCliExists = async (): Promise<boolean> => {
+	try {
+		await execCommand("docker --version");
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+const dockerDaemonAccessible = async (): Promise<boolean> => {
+	try {
+		await execCommand("docker info");
+		return true;
+	} catch (error: any) {
+		const stderr: string = error?.stderr || "";
+		if (
+			stderr.includes("Got permission denied") ||
+			stderr.toLowerCase().includes("permission denied")
+		) {
+			throw new Error(
+				"Docker is installed but the current user cannot access the Docker daemon. Add the user to the 'docker' group or run with elevated privileges.",
+			);
 		}
-	};
+		return false;
+	}
+};
 
-	if (!(await dockerExist())) {
-		await new Promise((resolve, reject) => {
-			exec("sudo snap install docker", (error, stdout, stderr) => {
-				if (error || stderr) {
-					reject();
-				}
-				resolve(stdout);
-			});
-		});
+const startDockerDaemon = async (sudoPrefix: string) => {
+	if (await commandExists("snap")) {
+		try {
+			await execCommand(`${sudoPrefix}snap start docker`);
+		} catch {}
+	}
 
+	if (await commandExists("systemctl")) {
 		try {
-			await waitFor(() => dockerExist(), {
-				timeout: 30 * 1000,
-				delayInterval: 1000,
-			});
-		} catch (error) {
-			throw new Error("Failed to install docker");
+			await execCommand(`${sudoPrefix}systemctl enable --now docker`);
+			return;
+		} catch {}
+		try {
+			await execCommand(`${sudoPrefix}systemctl start docker`);
+			return;
+		} catch {}
+	}
+
+	if (await commandExists("service")) {
+		try {
+			await execCommand(`${sudoPrefix}service docker start`);
+		} catch {}
+	}
+};
+
+const installDockerWithSnap = async (sudoPrefix: string) => {
+	await execCommand(`${sudoPrefix}snap install docker`);
+};
+
+const installDockerWithApt = async (sudoPrefix: string) => {
+	await execCommand(`${sudoPrefix}apt-get update`);
+	await execCommand(
+		`${sudoPrefix}DEBIAN_FRONTEND=noninteractive apt-get install -y docker.io`,
+	);
+};
+
+export const installDocker = async () => {
+	const sudoPrefix = await getSudoPrefix();
+
+	if (!(await dockerCliExists())) {
+		let lastError: unknown;
+
+		if (await commandExists("snap")) {
+			try {
+				await installDockerWithSnap(sudoPrefix);
+			} catch (error) {
+				lastError = error;
+			}
+		}
+
+		if (!(await dockerCliExists()) && (await commandExists("apt-get"))) {
+			try {
+				await installDockerWithApt(sudoPrefix);
+			} catch (error) {
+				lastError = error;
+			}
+		}
+
+		if (!(await dockerCliExists())) {
+			const suffix =
+				lastError instanceof Error
+					? `: ${lastError.message}`
+					: lastError
+						? `: ${String(lastError)}`
+						: "";
+			throw new Error(
+				`Failed to install docker (no supported installer succeeded)${suffix}`,
+			);
 		}
 	}
+
+	await startDockerDaemon(sudoPrefix);
+
+	try {
+		await waitFor(async () => dockerDaemonAccessible(), {
+			timeout: 2 * 60 * 1000,
+			delayInterval: 2000,
+		});
+	} catch (error: any) {
+		throw new Error(
+			`Docker is installed but not available: ${error?.message || "unknown error"}`,
+		);
+	}
 };
 
 export const startContainer = async (cmd: string, errorMessage?: string) => {

package/src/hetzner.browser.ts

@@ -0,0 +1 @@
+// Unsupported