@peerbit/server 5.9.6 → 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.6",
+  "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",

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

package/src/hetzner.ts

@@ -0,0 +1,242 @@
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/naming-convention */
+import { type PeerId } from "@libp2p/interface";
+import { delay } from "@peerbit/time";
+
+export const HETZNER_LOCATIONS = [
+	"fsn1",
+	"nbg1",
+	"hel1",
+	"ash",
+	"hil",
+] as const;
+export type HetznerLocation = (typeof HETZNER_LOCATIONS)[number];
+
+export const HETZNER_SERVER_TYPES = [
+	"cx11",
+	"cx21",
+	"cx31",
+	"cx41",
+	"cx51",
+	"cax11",
+	"cax21",
+	"cax31",
+	"cax41",
+] as const;
+export type HetznerServerType = (typeof HETZNER_SERVER_TYPES)[number];
+
+const HCLOUD_API_BASE = "https://api.hetzner.cloud/v1";
+
+const getToken = (token?: string): string => {
+	const resolved =
+		token ||
+		process.env.HCLOUD_TOKEN ||
+		process.env.HETZNER_TOKEN ||
+		process.env.HETZNER_CLOUD_TOKEN;
+	if (!resolved) {
+		throw new Error(
+			"Missing Hetzner Cloud API token. Provide --token or set HCLOUD_TOKEN.",
+		);
+	}
+	return resolved;
+};
+
+const setupUserData = (
+	email: string,
+	grantAccess: PeerId[] = [],
+	serverVersion?: string,
+) => {
+	const peerIdStrings = grantAccess.map((x) => x.toString());
+	const grantArgs = peerIdStrings.map((key) => `--ga ${key}`).join(" ");
+	const versionSpec = serverVersion ? `@${serverVersion}` : "";
+
+	// better-sqlite3 forces users to install build-essentials for `make` command
+	return `#!/bin/bash
+set -e
+cd /root
+curl -fsSL https://deb.nodesource.com/setup_22.x | bash - &&\
+apt-get install -y nodejs
+apt-get install -y build-essential
+npm install -g @peerbit/server${versionSpec}
+peerbit domain test --email ${email}
+peerbit start ${grantArgs} > log.txt 2>&1 &
+`;
+};
+
+type HcloudServer = {
+	id: number;
+	name: string;
+	public_net?: { ipv4?: { ip?: string } };
+};
+
+const createHcloudClient = async (token: string) => {
+	const { default: axios } = await import("axios");
+	return axios.create({
+		baseURL: HCLOUD_API_BASE,
+		headers: { Authorization: `Bearer ${token}` },
+		timeout: 60_000,
+	});
+};
+
+const parseAxiosError = (error: any): string => {
+	const status = error?.response?.status;
+	const data = error?.response?.data;
+	const message = error?.message || String(error);
+	if (!status) {
+		return message;
+	}
+	const details =
+		typeof data === "string"
+			? data
+			: data?.error?.message || JSON.stringify(data);
+	return `${message} (HTTP ${status})${details ? `: ${details}` : ""}`;
+};
+
+const escapeRegExp = (value: string): string =>
+	value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+const getHighestNameCounter = (
+	servers: HcloudServer[],
+	prefix: string,
+): number => {
+	const pattern = new RegExp(`^${escapeRegExp(prefix)}-(\\d+)$`);
+	let max = 0;
+	for (const server of servers) {
+		const match = server.name.match(pattern);
+		if (!match) continue;
+		const n = Number(match[1]);
+		if (Number.isFinite(n)) {
+			max = Math.max(max, n);
+		}
+	}
+	return max;
+};
+
+const waitForServerPublicIp = async (
+	client: Awaited<ReturnType<typeof createHcloudClient>>,
+	serverId: number,
+	timeoutMs = 3 * 60 * 1000,
+	pollIntervalMs = 5000,
+): Promise<string> => {
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) {
+		try {
+			const info = await client.get(`/servers/${serverId}`);
+			const server: HcloudServer | undefined = info.data?.server;
+			const ip = server?.public_net?.ipv4?.ip;
+			if (ip) {
+				return ip;
+			}
+		} catch (error: any) {
+			if (error?.response?.status !== 404 && error?.response?.status !== 429) {
+				throw new Error(
+					`Failed while waiting for Hetzner server ${serverId} IP: ${parseAxiosError(
+						error,
+					)}`,
+				);
+			}
+		}
+		await delay(pollIntervalMs);
+	}
+	throw new Error(
+		`Timed out waiting for Hetzner server ${serverId} to get a public IPv4`,
+	);
+};
+
+export const launchNodes = async (properties: {
+	token?: string;
+	location?: string;
+	email: string;
+	count?: number;
+	serverType?: string;
+	namePrefix?: string;
+	grantAccess?: PeerId[];
+	serverVersion?: string;
+	image?: string;
+}): Promise<
+	{ serverId: number; publicIp: string; name: string; location: string }[]
+> => {
+	if (properties.count && properties.count > 10) {
+		throw new Error(
+			"Unexpected node launch count: " +
+				properties.count +
+				". To prevent unwanted behaviour you can also launch 10 nodes at once",
+		);
+	}
+	const count = properties.count || 1;
+
+	const token = getToken(properties.token);
+	const client = await createHcloudClient(token);
+
+	const location = properties.location || "fsn1";
+	const serverType = properties.serverType || "cx11";
+	const image = properties.image || "ubuntu-22.04";
+	const namePrefix = properties.namePrefix || "peerbit-node";
+
+	const existingServers = (await client.get("/servers")).data?.servers as
+		| HcloudServer[]
+		| undefined;
+	const existingCounter = getHighestNameCounter(
+		existingServers || [],
+		namePrefix,
+	);
+
+	const created: Array<{ serverId: number; name: string }> = [];
+	for (let ix = 1; ix <= count; ix++) {
+		const name = `${namePrefix}-${existingCounter + ix}`;
+		try {
+			const resp = await client.post("/servers", {
+				name,
+				server_type: serverType,
+				image,
+				location,
+				user_data: setupUserData(
+					properties.email,
+					properties.grantAccess,
+					properties.serverVersion,
+				),
+			});
+			const serverId: number | undefined = resp.data?.server?.id;
+			if (!serverId) {
+				throw new Error("Missing server id in Hetzner response");
+			}
+			created.push({ serverId, name });
+		} catch (error: any) {
+			throw new Error(
+				`Failed to create Hetzner server '${name}': ${parseAxiosError(error)}`,
+			);
+		}
+	}
+
+	const nodes: Array<{
+		serverId: number;
+		publicIp: string;
+		name: string;
+		location: string;
+	}> = [];
+	for (const { serverId, name } of created) {
+		const publicIp = await waitForServerPublicIp(client, serverId);
+		nodes.push({ serverId, publicIp, name, location });
+	}
+	return nodes;
+};
+
+export const terminateNode = async (properties: {
+	token?: string;
+	serverId: number | string;
+}) => {
+	const token = getToken(properties.token);
+	const client = await createHcloudClient(token);
+	try {
+		await client.delete(`/servers/${properties.serverId}`);
+	} catch (error: any) {
+		if (error?.response?.status === 404) {
+			return;
+		}
+		throw new Error(
+			`Failed to terminate Hetzner server ${properties.serverId}: ${parseAxiosError(
+				error,
+			)}`,
+		);
+	}
+};