@peerbit/server 1.0.3

package/src/aws.ts

@@ -0,0 +1,48 @@
+import { getMyIp } from "./domain.js";
+
+export const createRecord = async (options: {
+	domain: string;
+	region?: string;
+	hostedZoneId: string;
+	credentials?: { accessKeyId: string; secretAccessKey: string };
+}): Promise<void> => {
+	const { Route53Client, ChangeResourceRecordSetsCommand } = await import(
+		"@aws-sdk/client-route-53"
+	);
+	const { isIPv4, isIPv6 } = await import("net");
+
+	const myIp = await getMyIp();
+	const v4 = isIPv4(myIp);
+	const v6 = isIPv6(myIp);
+
+	if (!v6 && !v4) {
+		throw new Error("Unknown ip type");
+	}
+	// TODO, make sure it works for ipv6 addresses with leading and trailing colon
+	const client = new Route53Client({
+		region: options.region,
+		credentials: options.credentials
+			? {
+					accessKeyId: options.credentials.accessKeyId,
+					secretAccessKey: options.credentials.secretAccessKey,
+			  }
+			: undefined,
+	});
+	const cmd = new ChangeResourceRecordSetsCommand({
+		ChangeBatch: {
+			Changes: [
+				{
+					Action: "CREATE",
+					ResourceRecordSet: {
+						Name: options.domain,
+						Type: v4 ? "A" : "AAAA",
+						TTL: 60,
+						ResourceRecords: [{ Value: myIp }],
+					},
+				},
+			],
+		},
+		HostedZoneId: options.hostedZoneId,
+	});
+	await client.send(cmd);
+};

package/src/bin.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { cli } from "./cli.js";
+try {
+	await cli();
+} catch (error: any) {
+	throw new Error("Unexpected error: " + error?.message);
+}

package/src/cli.ts

@@ -0,0 +1,266 @@
+import { createTestDomain, startCertbot } from "./domain.js";
+import { serialize } from "@dao-xyz/borsh";
+import { client, startServerWithNode } from "./api.js";
+import { createRecord } from "./aws.js";
+import { toBase64 } from "@peerbit/crypto";
+import { getConfigDir } from "./config.js";
+
+export const cli = async (args?: string[]) => {
+	const yargs = await import("yargs");
+
+	if (!args) {
+		const { hideBin } = await import("yargs/helpers");
+		args = hideBin(process.argv);
+	}
+
+	return yargs
+		.default(args)
+		.command({
+			command: "start",
+			describe: "Start node",
+			builder: {
+				directory: {
+					describe: "Directory for all data created by the node",
+					defaultDescription: "~.peerbit",
+					type: "string",
+					default: await getConfigDir(),
+				},
+			},
+			handler: async (args) => {
+				await startServerWithNode(args.directory);
+			},
+		})
+		.command("domain", "Setup a domain and certificate", (yargs) => {
+			yargs
+				.command({
+					command: "test",
+					describe:
+						"Setup a testing domain with SSL (no guarantess on how long the domain will be available)",
+					builder: {
+						email: {
+							describe: "Email for Lets encrypt autorenewal messages",
+							type: "string",
+							demandOption: true,
+						},
+						outdir: {
+							describe: "Output path for Nginx config",
+							type: "string",
+							alias: "o",
+						},
+						wait: {
+							alias: "w",
+							describe: "Wait for setup to succeed (or fail)",
+							type: "boolean",
+							default: false,
+						},
+					},
+					handler: async (args) => {
+						const domain = await createTestDomain();
+						await startCertbot(domain, args.email, args.outdir, args.wait);
+						const { exit } = await import("process");
+						exit();
+					},
+				})
+				.command({
+					command: "aws",
+					describe:
+						"Setup a domain with an AWS account. You either have to setup you AWS credentials in the .aws folder, or pass the credentials in the cli",
+					builder: {
+						domain: {
+							describe: "domain, e.g. abc.example.com, example.com",
+							alias: "d",
+							type: "string",
+							demandOption: true,
+						},
+						hostedZoneId: {
+							describe: 'The id of the hosted zone "HostedZoneId"',
+							alias: "hz",
+							type: "string",
+							require: true,
+						},
+						accessKeyId: {
+							describe: "Access key id of the AWS user",
+							alias: "ak",
+							type: "string",
+						},
+						region: {
+							describe: "AWS region",
+							alias: "r",
+							type: "string",
+						},
+						secretAccessKey: {
+							describe: "Secret key id of the AWS user",
+							alias: "sk",
+							type: "string",
+						},
+						email: {
+							describe: "Email for Lets encrypt autorenewal messages",
+							type: "string",
+							demandOption: true,
+						},
+						outdir: {
+							describe: "Output path for Nginx config",
+							type: "string",
+							alias: "o",
+						},
+						wait: {
+							alias: "w",
+							describe: "Wait for setup to succeed (or fail)",
+							type: "boolean",
+							default: false,
+						},
+					},
+					handler: async (args) => {
+						if (
+							!!args.accessKeyId !== !!args.secretAccessKey ||
+							!!args.region !== !!args.secretAccessKey
+						) {
+							throw new Error(
+								"Expecting either all 'accessKeyId', 'region' and 'secretAccessKey' to be provided or none"
+							);
+						}
+						await createRecord({
+							domain: args.domain,
+							hostedZoneId: args.hostedZoneId,
+							region: args.region,
+							credentials: args.accessKeyId
+								? {
+										accessKeyId: args.accessKeyId,
+										secretAccessKey: args.secretAccessKey,
+								  }
+								: undefined,
+						});
+						await startCertbot(args.domain, args.email, args.outdir, args.wait);
+						const { exit } = await import("process");
+						exit();
+					},
+				})
+				.strict()
+				.demandCommand();
+		})
+		.command("topic", "Manage topics the node is listening to", (yargs) => {
+			yargs
+				.command({
+					command: "list",
+					aliases: "ls",
+					describe: "List all topics",
+					builder: (yargs: any) => {
+						yargs.option("replicate", {
+							type: "boolean",
+							describe: "Replicate data on this topic",
+							alias: "r",
+							default: false,
+						});
+						return yargs;
+					},
+					handler: async (args) => {
+						/* const c = await client();
+						const topics = await c.topics.get(args.replicate);
+						if (topics?.length > 0) {
+							console.log("Topic (" + topics.length + "):");
+							for (const t of topics) {
+								console.log(t);
+							}
+						} else {
+							console.log("Not subscribed to any topics");
+						} */
+						console.error("Not implemented");
+					},
+				})
+				.strict()
+				.demandCommand();
+			return yargs;
+		})
+		.command("program", "Manage programs", (yargs) => {
+			yargs
+				.command({
+					command: "get <address>",
+					describe: "Get program manifest/serialized in base64",
+					builder: (yargs: any) => {
+						yargs.positional("address", {
+							type: "string",
+							describe: "Program address",
+							demandOption: true,
+						});
+						return yargs;
+					},
+
+					handler: async (args) => {
+						const c = await client();
+						const program = await c.program.get(args.address);
+						if (!program) {
+							console.log("Program does not exist");
+						} else {
+							console.log(toBase64(serialize(program)));
+						}
+					},
+				})
+				.command({
+					command: "add <program>",
+					describe: "Add program",
+					builder: (yargs: any) => {
+						yargs.positional("program", {
+							type: "string",
+							describe: "base64 serialized",
+							demandOption: true,
+						});
+						return yargs;
+					},
+					handler: async (args) => {
+						const c = await client();
+						const address = await c.program.put(args.program);
+						console.log(address.toString());
+					},
+				})
+				.command({
+					command: "import <library>",
+					describe: "import a library that contains programs",
+					builder: (yargs: any) => {
+						yargs.positional("library", {
+							type: "array",
+							describe:
+								"Library name (will be loaded with js import(...)). Onlu libraries that are globally installed and can be imported",
+							demandOption: true,
+						});
+						return yargs;
+					},
+					handler: async (args) => {
+						for (const lib of args.library) {
+							const importedLib = await import(
+								/* webpackIgnore: true */ /* @vite-ignore */ lib
+							);
+							console.log("imported lib:", importedLib);
+						}
+					},
+				})
+				.strict()
+				.demandCommand();
+			return yargs;
+		})
+		.command("library", "Manage libraries", (yargs) => {
+			yargs
+				.command({
+					command: "add <library>",
+					describe: "add a library that contains programs",
+					builder: (yargs: any) => {
+						yargs.positional("library", {
+							type: "string",
+							describe:
+								"Library name (will be loaded with js import(...)). Onlu libraries that are globally installed and can be imported",
+							demandOption: true,
+						});
+						return yargs;
+					},
+					handler: async (args) => {
+						const c = await client();
+						await c.library.put(args.library);
+					},
+				})
+				.strict()
+				.demandCommand();
+			return yargs;
+		})
+		.help()
+		.strict()
+		.demandCommand().argv;
+};

package/src/client.ts

@@ -0,0 +1,20 @@
+import { DirectSub } from "@peerbit/pubsub";
+import { Peerbit } from "peerbit";
+
+export const create = (directory: string) => {
+	return Peerbit.create({
+		libp2p: {
+			addresses: {
+				listen: ["/ip4/127.0.0.1/tcp/8001", "/ip4/127.0.0.1/tcp/8002/ws"],
+			},
+			connectionManager: {
+				maxConnections: Infinity,
+				minConnections: 0,
+			},
+			services: {
+				pubsub: (c) => new DirectSub(c, { canRelayMessage: true }),
+			},
+		},
+		directory,
+	});
+};

package/src/config.ts

@@ -0,0 +1,20 @@
+export const getConfigDir = async (): Promise<string> => {
+	const path = await import("path");
+	const os = await import("os");
+	const configDir = path.join(os.homedir(), ".peerbit");
+	return configDir;
+};
+
+export const getCredentialsPath = async (
+	configDir: string
+): Promise<string> => {
+	const path = await import("path");
+	return path.join(configDir, "credentials");
+};
+
+export const getKeysPath = async (configDir: string): Promise<string> => {
+	const path = await import("path");
+	return path.join(configDir, "keys");
+};
+
+export class NotFoundError extends Error {}

package/src/docker.ts

@@ -0,0 +1,67 @@
+import { delay, waitForAsync } from "@peerbit/time";
+
+export const installDocker = async () => {
+	const { exec } = await import("child_process");
+
+	// check if docker is installed
+	const dockerExist = async () => {
+		try {
+			const out = await new Promise((resolve, reject) => {
+				exec("docker --version", (error, stdout, stderr) => {
+					if (error || stderr) {
+						reject();
+					}
+					resolve(stdout);
+				});
+			});
+			return true;
+		} catch (error) {
+			return false;
+		}
+	};
+
+	if (!(await dockerExist())) {
+		await new Promise((resolve, reject) => {
+			exec("sudo snap install docker", (error, stdout, stderr) => {
+				if (error || stderr) {
+					reject();
+				}
+				resolve(stdout);
+			});
+		});
+
+		try {
+			await waitForAsync(() => dockerExist(), {
+				timeout: 30 * 1000,
+				delayInterval: 1000,
+			});
+		} catch (error) {
+			throw new Error("Failed to install docker");
+		}
+	}
+};
+
+export const startContainer = async (cmd: string, errorMessage?: string) => {
+	const { exec } = await import("child_process");
+	const startContainer = () =>
+		new Promise((resolve, reject) => {
+			exec(cmd, (error, stdout, stderr) => {
+				if (error) {
+					reject(
+						(errorMessage || "Failed to start docker container: ") +
+							error.message
+					);
+				}
+				resolve(stdout);
+			});
+		});
+	try {
+		await startContainer();
+	} catch (error) {
+		// try again no matter what?
+		// or
+		//  typeof error === "string" && error.indexOf("Cannot connect to the Docker daemon") != -1
+		await delay(10000);
+		await startContainer();
+	}
+};

package/src/domain.ts

@@ -0,0 +1,179 @@
+import { waitFor, waitForAsync } from "@peerbit/time";
+import { client } from "./api.js";
+import { installDocker, startContainer } from "./docker.js";
+
+const isNode = typeof window === undefined || typeof window === "undefined";
+
+const validateEmail = (email) => {
+	return String(email)
+		.toLowerCase()
+		.match(
+			/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
+		);
+};
+
+const createConfig = async (
+	outputPath: string,
+	domain: string
+): Promise<{ domain: string }> => {
+	if (!isNode) {
+		throw new Error("Config can only be created with node");
+	}
+	const { AxiosError } = await import("axios");
+
+	const url = await import("url");
+	const __filename = url.fileURLToPath(import.meta.url);
+	const fs = await import("fs");
+	const path = await import("path");
+	let file = fs.readFileSync(
+		path.join(__filename, "../nginx-template.conf"),
+		"utf-8"
+	);
+	let ipfsId: string;
+	try {
+		ipfsId = await (await client()).peer.id.get();
+	} catch (error) {
+		if (error instanceof AxiosError) {
+			throw new Error(
+				"Failed to connect to Peerbit, have you started the node? e.g. 'peerbit start'"
+			);
+		}
+		throw error;
+	}
+	file = file.replaceAll("%IPFS_ID%", ipfsId);
+	file = file.replaceAll("%DOMAIN%", domain);
+
+	fs.mkdir(outputPath, { recursive: true }, (err) => {
+		if (err) throw err;
+	});
+
+	await waitFor(() => fs.existsSync(outputPath));
+
+	fs.writeFileSync(path.join(outputPath, "default.conf"), file);
+	return { domain };
+};
+const getUIPath = async (): Promise<string> => {
+	const url = await import("url");
+	const path = await import("path");
+	const __filename = url.fileURLToPath(import.meta.url);
+	const p1 = path.join(__filename, "../../", "ui");
+
+	const fs = await import("fs");
+
+	if (fs.existsSync(p1) && fs.lstatSync(p1).isDirectory()) {
+		return p1; // build
+	} else {
+		const p2 = path.join(__filename, "../../", "lib/ui");
+		if (fs.existsSync(p2) && fs.lstatSync(p2).isDirectory()) {
+			return p2;
+		}
+		throw new Error("Failed to find UI path");
+	}
+};
+export const getMyIp = async (): Promise<string> => {
+	const { exec } = await import("child_process");
+	const ipv4: string = await new Promise((resolve, reject) => {
+		exec(
+			"dig @resolver4.opendns.com myip.opendns.com +short",
+			(error, stdout, stderr) => {
+				if (error || stderr) {
+					reject("DNS lookup failed");
+				}
+				resolve(stdout.trimEnd());
+			}
+		);
+	});
+	return ipv4;
+};
+
+export const createTestDomain = async () => {
+	const { default: axios } = await import("axios");
+	const domain: string = (
+		await axios.post(
+			"https://bfbbnhwpfj2ptcmurz6lit4xlu0vjajw.lambda-url.us-east-1.on.aws",
+			await getMyIp(),
+			{ headers: { "Content-Type": "application/json" } }
+		)
+	).data.domain;
+	return domain;
+};
+
+/**
+ *
+ * @param email
+ * @param nginxConfigPath
+ * @param dockerProcessName
+ * @returns domain
+ */
+export const startCertbot = async (
+	domain: string,
+	email: string,
+	nginxConfigPath?: string,
+	waitForUp = false,
+	dockerProcessName = "nginx-certbot"
+): Promise<void> => {
+	if (!validateEmail(email)) {
+		throw new Error("Email for SSL renenewal is invalid");
+	}
+
+	const { exec } = await import("child_process");
+	const pwd: string = await new Promise((resolve, reject) => {
+		exec("pwd", (error, stdout, stderr) => {
+			if (error || stderr) {
+				reject("Failed to get current directory");
+			}
+			resolve(stdout.trimEnd());
+		});
+	});
+	const path = await import("path");
+	nginxConfigPath = path.join(nginxConfigPath || pwd, "nginx");
+
+	await createConfig(nginxConfigPath, domain);
+
+	await installDocker();
+
+	// run
+	const isTest = process.env.JEST_WORKER_ID !== undefined;
+
+	const uiPath = await getUIPath();
+
+	// copy ui from node_modules to home for permission reasons (volume will not work otherwise)
+	const certbotDockerCommand = `cp -r ${uiPath} $(pwd)/ui && docker pull jonasal/nginx-certbot:latest && docker run -d --net=host \
+    --env CERTBOT_EMAIL=${email} ${isTest ? "--env STAGING=1" : ""}\
+    -v $(pwd)/nginx_secrets:/etc/letsencrypt \
+    -v ${nginxConfigPath}:/etc/nginx/user_conf.d:ro \
+    -v $(pwd)/ui:/usr/share/nginx/html:ro \
+    --name ${dockerProcessName} jonasal/nginx-certbot:latest`;
+
+	console.log("Starting Certbot");
+	// try two times with some delay, because sometimes the docker daemon is not available immidatel
+	await startContainer(
+		certbotDockerCommand,
+		"Failed to start certbot container"
+	);
+
+	console.log("Certbot started succesfully!");
+	console.log("You domain is: ");
+	console.log(domain);
+	if (waitForUp) {
+		const { default: axios } = await import("axios");
+
+		console.log("Waiting for domain to be ready ...");
+		await waitForAsync(
+			async () => {
+				try {
+					const status = (await axios.get("https://" + domain)).status;
+					return status >= 200 && status < 400;
+				} catch (error) {
+					return false;
+				}
+			},
+			{ timeout: 5 * 60 * 10000, delayInterval: 5000 }
+		);
+		console.log("Domain is ready");
+	} else {
+		console.log(
+			"The domain is not available immediately as it takes some time to request SSL certificate."
+		);
+	}
+};

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./api.js";