@peerbit/server 1.0.19 → 1.1.0

package/src/domain.ts

@@ -1,5 +1,4 @@
 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";
@@ -12,6 +11,39 @@ const validateEmail = (email) => {
 		);
 };
 
+const getConfigFileTemplate = async (): Promise<string> => {
+	const url = await import("url");
+	const __filename = url.fileURLToPath(import.meta.url);
+	const fs = await import("fs");
+	const path = await import("path");
+	const file = fs.readFileSync(
+		path.join(__filename, "../nginx-template.conf"),
+		"utf-8"
+	);
+	return file;
+};
+
+const getNginxFolderPath = async () => {
+	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");
+	const nginxConfigPath = path.join(pwd, "nginx");
+	return nginxConfigPath;
+};
+
+const getNginxConfigPath = async (folder: string) => {
+	const path = await import("path");
+	return path.join(folder, "default.conf");
+};
+
 const createConfig = async (
 	outputPath: string,
 	domain: string
@@ -19,29 +51,12 @@ const createConfig = async (
 	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);
+	let file = await getConfigFileTemplate();
+	file = file.replaceAll("%DOMAIN%", domain);
+
 	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;
@@ -49,9 +64,26 @@ const createConfig = async (
 
 	await waitFor(() => fs.existsSync(outputPath));
 
-	fs.writeFileSync(path.join(outputPath, "default.conf"), file);
+	fs.writeFileSync(await getNginxConfigPath(outputPath), file);
 	return { domain };
 };
+
+export const loadConfig = async () => {
+	const configFilePath = await getNginxConfigPath(await getNginxFolderPath());
+	const fs = await import("fs");
+	if (!fs.existsSync(configFilePath)) {
+		return undefined;
+	}
+	const file = fs.readFileSync(configFilePath, "utf-8");
+	return file;
+};
+
+export const getDomainFromConfig = async (config: string) => {
+	const pattern = "/etc/letsencrypt/live/(.*)/fullchain.pem";
+	const match = config.match(pattern);
+	const domain = match?.[1];
+	return domain === "%DOMAIN%" ? undefined : domain;
+};
 const getUIPath = async (): Promise<string> => {
 	const url = await import("url");
 	const path = await import("path");
@@ -108,7 +140,6 @@ export const createTestDomain = async () => {
 export const startCertbot = async (
 	domain: string,
 	email: string,
-	nginxConfigPath?: string,
 	waitForUp = false,
 	dockerProcessName = "nginx-certbot"
 ): Promise<void> => {
@@ -116,18 +147,7 @@ export const startCertbot = async (
 		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");
-
+	const nginxConfigPath = await getNginxFolderPath();
 	await createConfig(nginxConfigPath, domain);
 
 	await installDocker();

package/src/index.ts

@@ -1 +1,3 @@
-export * from "./api.js";
+export * from "./server.js";
+export * from "./routes.js";
+export * from "./client.js";

package/src/nginx-template.conf

@@ -87,16 +87,6 @@ server {
 
 server {
     server_name %DOMAIN%; # managed by Certbot
-    #location / {
-    #    proxy_pass http://127.0.0.1:8080;
-    #    proxy_set_header Host $host;
-    #    proxy_cache_bypass $http_upgrade;
-    #}
-
-    #location / {
-    #    add_header Content-Type text/html;
-    #    return 200 '<html><body>This peer has the address <b>/dns4/%DOMAIN%/tcp/4002/wss/p2p/%IPFS_ID%</b></body></html>';
-    #}
     
     root /usr/share/nginx/html;
     index index.html index.htm;

package/src/peerbit.ts

@@ -0,0 +1,26 @@
+import { DirectSub } from "@peerbit/pubsub";
+import { Peerbit } from "peerbit";
+
+export const create = (properties: { directory?: string; domain?: string }) => {
+	return Peerbit.create({
+		libp2p: {
+			addresses: {
+				announce: properties.domain
+					? [
+							`/dns4/${properties.domain}/tcp/8001`,
+							`/dns4/${properties.domain}/tcp/8002/ws`,
+					  ]
+					: undefined,
+				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: properties.directory,
+	});
+};

package/src/routes.ts

@@ -0,0 +1,20 @@
+export const getPort = (protocol: string) => {
+	if (protocol === "https:") {
+		return SSL_PORT;
+	}
+
+	if (protocol === "http:") {
+		return LOCAL_PORT;
+	}
+
+	throw new Error("Unsupported protocol: " + protocol);
+};
+export const SSL_PORT = 9002;
+export const LOCAL_PORT = 8082;
+
+export const PEER_ID_PATH = "/peer/id";
+export const ADDRESS_PATH = "/peer/address";
+export const PROGRAM_PATH = "/program";
+export const PROGRAMS_PATH = "/programs";
+export const INSTALL_PATH = "/install";
+export const BOOTSTRAP_PATH = "/network/bootstrap";

package/src/server.browser.ts

@@ -0,0 +1 @@
+// Not supported

package/src/server.ts

@@ -0,0 +1,430 @@
+import http from "http";
+import { fromBase64 } from "@peerbit/crypto";
+import { deserialize } from "@dao-xyz/borsh";
+import {
+	Program,
+	ProgramClient,
+	getProgramFromVariant,
+	getProgramFromVariants,
+} from "@peerbit/program";
+import { waitFor } from "@peerbit/time";
+import { v4 as uuid } from "uuid";
+import {
+	checkExistPath,
+	getConfigDir,
+	getCredentialsPath,
+	getPackageName,
+	loadPassword,
+	NotFoundError,
+} from "./config.js";
+import { setMaxListeners } from "events";
+import { create } from "./peerbit.js";
+import { Peerbit } from "peerbit";
+import { getSchema } from "@dao-xyz/borsh";
+import { StartByBase64, StartByVariant, StartProgram } from "./types.js";
+import {
+	ADDRESS_PATH,
+	BOOTSTRAP_PATH,
+	INSTALL_PATH,
+	LOCAL_PORT,
+	PEER_ID_PATH,
+	PROGRAMS_PATH,
+	PROGRAM_PATH,
+} from "./routes.js";
+import { client } from "./client.js";
+
+export const createPassword = async (): Promise<string> => {
+	const fs = await import("fs");
+	const configDir = await getConfigDir();
+	const credentialsPath = await getCredentialsPath(configDir);
+	if (await checkExistPath(credentialsPath)) {
+		throw new Error(
+			"Config path for credentials: " + credentialsPath + ", already exist"
+		);
+	}
+	console.log(`Creating config folder ${configDir}`);
+
+	fs.mkdirSync(configDir, { recursive: true });
+	await waitFor(() => fs.existsSync(configDir));
+
+	console.log(`Created config folder ${configDir}`);
+
+	const password = uuid();
+	fs.writeFileSync(
+		credentialsPath,
+		JSON.stringify({ username: "admin", password })
+	);
+	console.log(`Created credentials at ${credentialsPath}`);
+	return password;
+};
+
+export const loadOrCreatePassword = async (): Promise<string> => {
+	try {
+		return await loadPassword();
+	} catch (error) {
+		if (error instanceof NotFoundError) {
+			return createPassword();
+		}
+		throw error;
+	}
+};
+export const startServerWithNode = async (properties: {
+	directory?: string;
+	domain?: string;
+	bootstrap?: boolean;
+}) => {
+	const peer = await create({
+		directory: properties.directory,
+		domain: properties.domain,
+	});
+
+	if (properties.bootstrap) {
+		await peer.bootstrap();
+	}
+
+	const server = await startServer(peer);
+	const printNodeInfo = async () => {
+		console.log("Starting node with address(es): ");
+		const id = await (await client()).peer.id.get();
+		console.log("id: " + id);
+		console.log("Addresses: ");
+		for (const a of await (await client()).peer.addresses.get()) {
+			console.log(a.toString());
+		}
+	};
+
+	await printNodeInfo();
+	const shutDownHook = async (
+		controller: { stop: () => any },
+		server: {
+			close: () => void;
+		}
+	) => {
+		const { exit } = await import("process");
+		process.on("SIGINT", async () => {
+			console.log("Shutting down node");
+			await server.close();
+			await controller.stop();
+			exit();
+		});
+	};
+	await shutDownHook(peer, server);
+	return { server, node: peer };
+};
+
+const getProgramFromPath = (
+	client: Peerbit,
+	req: http.IncomingMessage,
+	pathIndex: number
+): Program | undefined => {
+	if (!req.url) {
+		throw new Error("Missing url");
+	}
+	const url = new URL(req.url, "http://localhost:" + 1234);
+	const path = url.pathname
+		.substring(Math.min(1, url.pathname.length), url.pathname.length)
+		.split("/");
+	if (path.length <= pathIndex) {
+		throw new Error("Invalid path");
+	}
+	const address = decodeURIComponent(path[pathIndex]);
+	return client.handler.items.get(address);
+};
+
+export const startServer = async (
+	client: ProgramClient,
+	port: number = LOCAL_PORT
+): Promise<http.Server> => {
+	const password = await loadOrCreatePassword();
+
+	const adminACL = (req: http.IncomingMessage): boolean => {
+		const auth = req.headers["authorization"];
+		if (!auth?.startsWith("Basic ")) {
+			return false;
+		}
+		const credentials = auth?.substring("Basic ".length);
+		const username = credentials.split(":")[0];
+		if (username !== "admin") {
+			return false;
+		}
+		if (password !== credentials.substring(username.length + 1)) {
+			return false;
+		}
+		return true;
+	};
+
+	const getBody = (
+		req: http.IncomingMessage,
+		callback: (body: string) => Promise<void> | void
+	) => {
+		let body = "";
+		req.on("data", function (d) {
+			body += d;
+		});
+		req.on("end", function () {
+			callback(body);
+		});
+	};
+
+	const e404 = "404";
+
+	const endpoints = (client: ProgramClient): http.RequestListener => {
+		return async (req, res) => {
+			res.setHeader("Access-Control-Allow-Origin", "*");
+			res.setHeader("Access-Control-Request-Method", "*");
+			res.setHeader("Access-Control-Allow-Headers", "*");
+			res.setHeader("Access-Control-Allow-Methods", "*");
+			const r404 = () => {
+				res.writeHead(404);
+				res.end(e404);
+			};
+
+			try {
+				if (req.url) {
+					if (
+						!req.url.startsWith(PEER_ID_PATH) &&
+						!req.url.startsWith(ADDRESS_PATH) &&
+						!(await adminACL(req))
+					) {
+						res.writeHead(401);
+						res.end("Not authorized");
+						return;
+					} else if (req.url.startsWith(PROGRAMS_PATH)) {
+						if (client instanceof Peerbit === false) {
+							res.writeHead(400);
+							res.end("Server node is not running a native client");
+							return;
+						}
+						switch (req.method) {
+							case "GET":
+								try {
+									const keys = JSON.stringify([
+										...(client as Peerbit).handler.items.keys(),
+									]);
+									res.setHeader("Content-Type", "application/json");
+									res.writeHead(200);
+									res.end(keys);
+								} catch (error: any) {
+									res.writeHead(404);
+									res.end(error.message);
+								}
+								break;
+
+							default:
+								r404();
+								break;
+						}
+					} else if (req.url.startsWith(PROGRAM_PATH)) {
+						if (client instanceof Peerbit === false) {
+							res.writeHead(400);
+							res.end("Server node is not running a native client");
+							return;
+						}
+						switch (req.method) {
+							case "HEAD":
+								try {
+									const program = getProgramFromPath(client as Peerbit, req, 1);
+									if (program) {
+										res.writeHead(200);
+										res.end();
+									} else {
+										res.writeHead(404);
+										res.end();
+									}
+								} catch (error: any) {
+									res.writeHead(404);
+									res.end(error.message);
+								}
+								break;
+
+							case "DELETE":
+								try {
+									const url = new URL(req.url, "http://localhost:" + 1234);
+									const queryData = url.searchParams.get("delete");
+
+									const program = getProgramFromPath(client as Peerbit, req, 1);
+									if (program) {
+										if (queryData === "true") {
+											await program.drop();
+										} else {
+											await program.close();
+										}
+										res.writeHead(200);
+										res.end();
+									} else {
+										res.writeHead(404);
+										res.end();
+									}
+								} catch (error: any) {
+									res.writeHead(404);
+									res.end(error.message);
+								}
+								break;
+							case "PUT":
+								getBody(req, (body) => {
+									try {
+										const startArguments: StartProgram = JSON.parse(body);
+
+										let program: Program;
+										if ((startArguments as StartByVariant).variant) {
+											const P = getProgramFromVariant(
+												(startArguments as StartByVariant).variant
+											);
+											if (!P) {
+												res.writeHead(400);
+												res.end(
+													"Missing program with variant: " +
+														(startArguments as StartByVariant).variant
+												);
+												return;
+											}
+											program = new P();
+										} else {
+											program = deserialize(
+												fromBase64((startArguments as StartByBase64).base64),
+												Program
+											);
+										}
+										client
+											.open(program) // TODO all users to pass args
+											.then((program) => {
+												res.writeHead(200);
+												res.end(program.address.toString());
+											})
+											.catch((error) => {
+												res.writeHead(400);
+												res.end("Failed to open program: " + error.toString());
+											});
+									} catch (error: any) {
+										res.writeHead(400);
+										res.end(error.toString());
+									}
+								});
+								break;
+
+							default:
+								r404();
+								break;
+						}
+					} else if (req.url.startsWith(INSTALL_PATH)) {
+						switch (req.method) {
+							case "PUT":
+								getBody(req, async (body) => {
+									const name = body;
+
+									let packageName = name;
+									if (name.endsWith(".tgz")) {
+										packageName = await getPackageName(name);
+									}
+
+									if (!name || name.length === 0) {
+										res.writeHead(400);
+										res.end("Invalid package: " + name);
+									} else {
+										const child_process = await import("child_process");
+										try {
+											child_process.execSync(
+												`npm install ${name} --no-save --no-package-lock`
+											); // TODO omit=dev ? but this makes breaks the tests after running once?
+										} catch (error: any) {
+											res.writeHead(400);
+											res.end(
+												"Failed ot install library: " +
+													name +
+													". " +
+													error.toString()
+											);
+											return;
+										}
+
+										try {
+											const programsPre = new Set(
+												getProgramFromVariants().map(
+													(x) => getSchema(x).variant
+												)
+											);
+
+											await import(
+												/* webpackIgnore: true */ /* @vite-ignore */ packageName
+											);
+											const programsPost = getProgramFromVariants()?.map((x) =>
+												getSchema(x)
+											);
+											const newPrograms: { variant: string }[] = [];
+											for (const p of programsPost) {
+												if (!programsPre.has(p.variant)) {
+													newPrograms.push(p as { variant: string });
+												}
+											}
+
+											res.writeHead(200);
+											res.end(
+												JSON.stringify(newPrograms.map((x) => x.variant))
+											);
+										} catch (e: any) {
+											res.writeHead(400);
+											res.end(e.message.toString?.());
+										}
+									}
+								});
+								break;
+
+							default:
+								r404();
+								break;
+						}
+					} else if (req.url.startsWith(BOOTSTRAP_PATH)) {
+						switch (req.method) {
+							case "POST":
+								if (client instanceof Peerbit === false) {
+									res.writeHead(400);
+									res.end("Server node is not running a native client");
+									return;
+								}
+								await (client as Peerbit).bootstrap();
+								res.writeHead(200);
+								res.end();
+								break;
+
+							default:
+								r404();
+								break;
+						}
+					} else if (req.url.startsWith(PEER_ID_PATH)) {
+						res.writeHead(200);
+						res.end(client.peerId.toString());
+					} else if (req.url.startsWith(ADDRESS_PATH)) {
+						res.setHeader("Content-Type", "application/json");
+						res.writeHead(200);
+						const addresses = client.getMultiaddrs().map((x) => x.toString());
+						res.end(JSON.stringify(addresses));
+					} else {
+						r404();
+					}
+				} else {
+					r404();
+				}
+			} catch (error: any) {
+				res.writeHead(500);
+				console.error(error?.message);
+				res.end("Unexpected error");
+			}
+		};
+	};
+
+	setMaxListeners(Infinity); // TODO make this better (lower and large enough)
+	process.setMaxListeners(Infinity); // TODO make this better (lower and large enough)
+
+	const server = http.createServer(endpoints(client));
+	server.listen(port);
+	server.on("error", (e) => {
+		console.error("Server error: " + e?.message);
+		import("fs").then((fs) => {
+			fs.writeFile("error.log", JSON.stringify(e.message), function () {
+				/* void */ 0;
+			});
+		});
+	});
+	console.log("API available at port", port);
+	return server;
+};

package/src/types.ts

@@ -0,0 +1,7 @@
+export interface StartByVariant {
+	variant: string;
+}
+export interface StartByBase64 {
+	base64: string;
+}
+export type StartProgram = StartByVariant | StartByBase64;

package/lib/esm/api.d.ts

@@ -1,33 +0,0 @@
-import http from "http";
-import { Program, Address, ProgramClient } from "@peerbit/program";
-export declare const SSL_PORT = 9002;
-export declare const LOCAL_PORT = 8082;
-export declare const getPort: (protocol: string) => 8082 | 9002;
-export declare const checkExistPath: (path: string) => Promise<boolean>;
-export declare const createPassword: () => Promise<string>;
-export declare const loadPassword: () => Promise<string>;
-export declare const loadOrCreatePassword: () => Promise<string>;
-export declare const startServerWithNode: (directory: string, domain?: string) => Promise<void>;
-export declare const startServer: (client: ProgramClient, port?: number) => Promise<http.Server>;
-export declare const client: (endpoint?: string) => Promise<{
-    peer: {
-        id: {
-            get: () => Promise<any>;
-        };
-        addresses: {
-            get: () => Promise<import("@multiformats/multiaddr").Multiaddr[]>;
-        };
-    };
-    program: {
-        get: (address: Address | string) => Promise<Program | undefined>;
-        /**
-         * @param program Program, or base64 string representation
-         * @param topic, topic
-         * @returns
-         */
-        put: (program: Program | string) => Promise<Address>;
-    };
-    library: {
-        put: (name: string) => Promise<void>;
-    };
-}>;