@peerbit/server 5.0.33-efee9d3 → 5.0.34-2bc15a6

package/src/client.ts

@@ -1,37 +1,37 @@
-import type { InstallDependency, StartProgram } from "./types.js";
+import { type PeerId } from "@libp2p/interface";
+import { multiaddr } from "@multiformats/multiaddr";
+import {
+	Ed25519Keypair,
+	type Ed25519PublicKey,
+	type Identity,
+	PublicSignKey,
+	getPublicKeyFromPeerId,
+} from "@peerbit/crypto";
+import type { Address } from "@peerbit/program";
+import { waitForResolved } from "@peerbit/time";
+import type { RemoteOrigin } from "./remotes.js";
 import {
 	ADDRESS_PATH,
 	BOOTSTRAP_PATH,
-	STOP_PATH,
 	INSTALL_PATH,
 	LOCAL_API_PORT,
 	PEER_ID_PATH,
 	PROGRAMS_PATH,
 	PROGRAM_PATH,
+	PROGRAM_VARIANTS_PATH,
+	REMOTE_API_PORT,
 	RESTART_PATH,
+	STOP_PATH,
 	TRUST_PATH,
-	REMOTE_API_PORT,
-	PROGRAM_VARIANTS_PATH
 } from "./routes.js";
-import { multiaddr } from "@multiformats/multiaddr";
 import { signRequest } from "./signed-request.js";
-import {
-	Ed25519Keypair,
-	Ed25519PublicKey,
-	type Identity,
-	PublicSignKey,
-	getPublicKeyFromPeerId
-} from "@peerbit/crypto";
-import { type PeerId } from "@libp2p/interface";
-import { waitForResolved } from "@peerbit/time";
-import type { RemoteOrigin } from "./remotes.js";
-import type { Address } from "@peerbit/program";
+import type { InstallDependency, StartProgram } from "./types.js";
 
 export const createClient = async (
 	keypair: Identity<Ed25519PublicKey>,
 	remote: { address: string; origin?: RemoteOrigin } = {
-		address: "http://localhost:" + LOCAL_API_PORT
-	}
+		address: "http://localhost:" + LOCAL_API_PORT,
+	},
 ) => {
 	// Add missing protocol
 	let endpoint = remote.address;
@@ -62,13 +62,13 @@ export const createClient = async (
 			config.method!,
 			url.pathname + url.search,
 			config.data,
-			keypair
+			keypair,
 		);
 		return config;
 	});
 
 	const validateStatus = (status: number) => {
-		return (status >= 200 && status < 300) || status == 404;
+		return (status >= 200 && status < 300) || status === 404;
 	};
 
 	const throwIfNot200 = (resp: { status: number; data: any }) => {
@@ -82,43 +82,43 @@ export const createClient = async (
 		throwIfNot200(
 			await axiosInstance.get(endpoint + PEER_ID_PATH, {
 				validateStatus,
-				timeout: 5000
-			})
+				timeout: 5000,
+			}),
 		).data;
 
 	return {
 		peer: {
 			id: {
-				get: getId
+				get: getId,
 			},
 			addresses: {
 				get: async () => {
 					return (
 						throwIfNot200(
 							await axiosInstance.get(endpoint + ADDRESS_PATH, {
-								validateStatus
-							})
+								validateStatus,
+							}),
 						).data as string[]
 					).map((x) => multiaddr(x));
-				}
-			}
+				},
+			},
 		},
 
 		access: {
 			allow: async (key: PublicSignKey | PeerId | string) => {
 				const result = await axiosInstance.put(
 					endpoint +
-					TRUST_PATH +
-					"/" +
-					encodeURIComponent(
-						typeof key === "string"
-							? key
-							: key instanceof PublicSignKey
-								? key.hashcode()
-								: getPublicKeyFromPeerId(key).hashcode()
-					),
+						TRUST_PATH +
+						"/" +
+						encodeURIComponent(
+							typeof key === "string"
+								? key
+								: key instanceof PublicSignKey
+									? key.hashcode()
+									: getPublicKeyFromPeerId(key).hashcode(),
+						),
 					undefined,
-					{ validateStatus }
+					{ validateStatus },
 				);
 				if (result.status !== 200 && result.status !== 404) {
 					throw new Error(result.data);
@@ -128,29 +128,29 @@ export const createClient = async (
 			deny: async (key: PublicSignKey | PeerId) => {
 				const result = await axiosInstance.delete(
 					endpoint +
-					TRUST_PATH +
-					"/" +
-					encodeURIComponent(
-						key instanceof PublicSignKey
-							? key.hashcode()
-							: getPublicKeyFromPeerId(key).hashcode()
-					),
-					{ validateStatus }
+						TRUST_PATH +
+						"/" +
+						encodeURIComponent(
+							key instanceof PublicSignKey
+								? key.hashcode()
+								: getPublicKeyFromPeerId(key).hashcode(),
+						),
+					{ validateStatus },
 				);
 				if (result.status !== 200 && result.status !== 404) {
 					throw new Error(result.data);
 				}
 				return result.status === 200 ? true : false;
-			}
+			},
 		},
 		program: {
 			has: async (address: Address | string): Promise<boolean> => {
 				const result = await axiosInstance.head(
 					endpoint +
-					PROGRAM_PATH +
-					"/" +
-					encodeURIComponent(address.toString()),
-					{ validateStatus }
+						PROGRAM_PATH +
+						"/" +
+						encodeURIComponent(address.toString()),
+					{ validateStatus },
 				);
 				if (result.status !== 200 && result.status !== 404) {
 					throw new Error(result.data);
@@ -164,9 +164,9 @@ export const createClient = async (
 						endpoint + PROGRAM_PATH,
 						JSON.stringify(program),
 						{
-							validateStatus
-						}
-					)
+							validateStatus,
+						},
+					),
 				);
 				return resp.data as string;
 			},
@@ -175,13 +175,13 @@ export const createClient = async (
 				throwIfNot200(
 					await axiosInstance.delete(
 						endpoint +
-						PROGRAM_PATH +
-						"/" +
-						encodeURIComponent(address.toString()),
+							PROGRAM_PATH +
+							"/" +
+							encodeURIComponent(address.toString()),
 						{
-							validateStatus
-						}
-					)
+							validateStatus,
+						},
+					),
 				);
 			},
 
@@ -189,33 +189,33 @@ export const createClient = async (
 				throwIfNot200(
 					await axiosInstance.delete(
 						endpoint +
-						PROGRAM_PATH +
-						"/" +
-						encodeURIComponent(address.toString()) +
-						"?delete=true",
+							PROGRAM_PATH +
+							"/" +
+							encodeURIComponent(address.toString()) +
+							"?delete=true",
 						{
-							validateStatus
-						}
-					)
+							validateStatus,
+						},
+					),
 				);
 			},
 
 			list: async (): Promise<string[]> => {
 				const resp = throwIfNot200(
 					await axiosInstance.get(endpoint + PROGRAMS_PATH, {
-						validateStatus
-					})
+						validateStatus,
+					}),
 				);
 				return resp.data as string[];
 			},
 			variants: async (): Promise<string[]> => {
 				const resp = throwIfNot200(
 					await axiosInstance.get(endpoint + PROGRAM_VARIANTS_PATH, {
-						validateStatus
-					})
+						validateStatus,
+					}),
 				);
 				return resp.data as string[];
-			}
+			},
 		},
 		dependency: {
 			install: async (instruction: InstallDependency): Promise<string[]> => {
@@ -223,39 +223,39 @@ export const createClient = async (
 					endpoint + INSTALL_PATH,
 					JSON.stringify(instruction),
 					{
-						validateStatus
-					}
+						validateStatus,
+					},
 				);
 				if (resp.status !== 200) {
 					throw new Error(
-						typeof resp.data === "string" ? resp.data : resp.data.toString()
+						typeof resp.data === "string" ? resp.data : resp.data.toString(),
 					);
 				}
 				return resp.data;
-			}
+			},
 		},
 		network: {
 			bootstrap: async (): Promise<void> => {
 				throwIfNot200(
 					await axiosInstance.post(endpoint + BOOTSTRAP_PATH, undefined, {
-						validateStatus
-					})
+						validateStatus,
+					}),
 				);
-			}
+			},
 		},
 
 		restart: async (): Promise<void> => {
 			throwIfNot200(
 				await axiosInstance.post(endpoint + RESTART_PATH, undefined, {
-					validateStatus
-				})
+					validateStatus,
+				}),
 			);
 		},
 		stop: async (): Promise<void> => {
 			throwIfNot200(
 				await axiosInstance.post(endpoint + STOP_PATH, undefined, {
-					validateStatus
-				})
+					validateStatus,
+				}),
 			);
 		},
 		terminate: async () => {
@@ -263,19 +263,19 @@ export const createClient = async (
 			if (remote.origin?.type === "aws") {
 				await terminateNode({
 					instanceId: remote.origin.instanceId,
-					region: remote.origin.region
+					region: remote.origin.region,
 				});
 			}
-		}
+		},
 	};
 };
 
 export const waitForDomain = async (
 	ip: string,
-	timeout: number = 5 * 60 * 1000
+	timeout: number = 5 * 60 * 1000,
 ): Promise<string> => {
 	const c = await createClient(await Ed25519Keypair.create(), {
-		address: "http://" + ip + ":" + LOCAL_API_PORT
+		address: "http://" + ip + ":" + LOCAL_API_PORT,
 	});
 	const result = await waitForResolved(
 		async () => {
@@ -288,8 +288,8 @@ export const waitForDomain = async (
 		},
 		{
 			delayInterval: 5000,
-			timeout
-		}
+			timeout,
+		},
 	);
 	if (!result) {
 		throw new Error("Failed to resolve domain");

package/src/config.ts

@@ -1,10 +1,10 @@
-import path from "path";
-import os from "os";
-import fs from "fs";
+// Native Node Module
 import { deserialize, serialize } from "@dao-xyz/borsh";
-import { Duplex } from "stream"; // Native Node Module
 import { Ed25519Keypair } from "@peerbit/crypto";
-import { dirname } from "path";
+import fs from "fs";
+import os from "os";
+import path, { dirname } from "path";
+import { Duplex } from "stream";
 
 const bufferToStream = (myBuffer: any) => {
 	const tmp = new Duplex();
@@ -39,7 +39,7 @@ const getKeysPath = (configDir: string): string => {
 };
 
 export const getKeypair = async (
-	configDir: string
+	configDir: string,
 ): Promise<Ed25519Keypair> => {
 	const keypath = getKeysPath(configDir);
 	if (!fs.existsSync(keypath)) {
@@ -69,7 +69,7 @@ export const checkExistPath = async (path: string) => {
 };
 
 export const getPackageName = async (
-	path: string | Uint8Array
+	path: string | Uint8Array,
 ): Promise<string> => {
 	const tar = await import("tar-stream");
 	const zlib = await import("zlib");
@@ -86,7 +86,7 @@ export const getPackageName = async (
 
 			extract.on("entry", function (header: any, stream: any, cb: any) {
 				stream.on("data", function (chunk: any) {
-					if (header.name == "package/package.json") data += chunk;
+					if (header.name === "package/package.json") data += chunk;
 				});
 
 				stream.on("end", function () {
@@ -120,4 +120,4 @@ export const getPackageName = async (
 	});
 };
 
-export class NotFoundError extends Error { }
+export class NotFoundError extends Error {}

package/src/docker.ts

@@ -33,7 +33,7 @@ export const installDocker = async () => {
 		try {
 			await waitFor(() => dockerExist(), {
 				timeout: 30 * 1000,
-				delayInterval: 1000
+				delayInterval: 1000,
 			});
 		} catch (error) {
 			throw new Error("Failed to install docker");
@@ -49,7 +49,7 @@ export const startContainer = async (cmd: string, errorMessage?: string) => {
 				if (error) {
 					reject(
 						(errorMessage || "Failed to start docker container: ") +
-						error.message
+							error.message,
 					);
 				}
 				resolve(stdout);

package/src/domain.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import { waitFor } from "@peerbit/time";
 
 const isNode = typeof window === "undefined";
@@ -6,18 +7,18 @@ const validateEmail = (email: any) => {
 	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,}))$/
+			/^(([^<>()[\]\\.,;:\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 getConfigFileTemplate = async (): Promise<string> => {
 	const url = await import("url");
-	const __filename = url.fileURLToPath(import.meta.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"
+		path.join(filename, "../nginx-template.conf"),
+		"utf-8",
 	);
 	return file;
 };
@@ -45,7 +46,7 @@ const getNginxConfigPath = async (folder: string) => {
 
 const createConfig = async (
 	outputPath: string,
-	domain: string
+	domain: string,
 ): Promise<{ domain: string }> => {
 	if (!isNode) {
 		throw new Error("Config can only be created with node");
@@ -85,15 +86,15 @@ export const getDomainFromConfig = async (config: string) => {
 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 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");
+		const p2 = path.join(filename, "../../", "dist/ui");
 		if (fs.existsSync(p2) && fs.lstatSync(p2).isDirectory()) {
 			return p2;
 		}
@@ -110,7 +111,7 @@ export const getMyIp = async (): Promise<string> => {
 					reject("DNS lookup failed");
 				}
 				resolve(stdout.trimEnd());
-			}
+			},
 		);
 	});
 	return ipv4;
@@ -122,24 +123,17 @@ export const createTestDomain = async () => {
 		await axios.post(
 			"https://bfbbnhwpfj2ptcmurz6lit4xlu0vjajw.lambda-url.us-east-1.on.aws",
 			await getMyIp(),
-			{ headers: { "Content-Type": "application/json" } }
+			{ 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,
 	waitForUp = false,
-	dockerProcessName = "nginx-certbot"
+	dockerProcessName = "nginx-certbot",
 ): Promise<void> => {
 	if (!validateEmail(email)) {
 		throw new Error("Email for SSL renenewal is invalid");
@@ -168,7 +162,7 @@ export const startCertbot = async (
 	// try two times with some delay, because sometimes the docker daemon is not available immidatel
 	await startContainer(
 		certbotDockerCommand,
-		"Failed to start certbot container"
+		"Failed to start certbot container",
 	);
 
 	console.log("Certbot started succesfully!");
@@ -187,12 +181,12 @@ export const startCertbot = async (
 					return false;
 				}
 			},
-			{ timeout: 5 * 60 * 10000, delayInterval: 5000 }
+			{ 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."
+			"The domain is not available immediately as it takes some time to request SSL certificate.",
 		);
 	}
 };

package/src/peerbit.ts

@@ -1,8 +1,8 @@
+import { type PeerId } from "@libp2p/interface";
 import { DirectBlock } from "@peerbit/blocks";
 import { DirectSub } from "@peerbit/pubsub";
-import { Peerbit } from "peerbit";
 import path from "path";
-import { type PeerId } from "@libp2p/interface";
+import { Peerbit } from "peerbit";
 
 export const LIBP2P_LISTEN_PORT = 8001;
 export const create = (properties: {
@@ -23,29 +23,30 @@ export const create = (properties: {
 			addresses: {
 				announce: properties.domain
 					? [
-						`/dns4/${properties.domain}/tcp/4002`,
-						`/dns4/${properties.domain}/tcp/4003/wss`
-					]
+							`/dns4/${properties.domain}/tcp/4002`,
+							`/dns4/${properties.domain}/tcp/4003/wss`,
+						]
 					: undefined,
 				listen: [
 					`/ip4/127.0.0.1/tcp/${listenPort}`,
-					`/ip4/127.0.0.1/tcp/${listenPort !== 0 ? listenPort + 1 : listenPort
-					}/ws`
-				]
+					`/ip4/127.0.0.1/tcp/${
+						listenPort !== 0 ? listenPort + 1 : listenPort
+					}/ws`,
+				],
 			},
 			connectionManager: {
 				maxConnections: Infinity,
-				minConnections: 0
+				minConnections: 0,
 			},
 			services: {
 				blocks: (c) =>
 					new DirectBlock(c, {
 						directory: blocksDirectory,
-						canRelayMessage: true
+						canRelayMessage: true,
 					}),
-				pubsub: (c) => new DirectSub(c, { canRelayMessage: true })
-			}
+				pubsub: (c) => new DirectSub(c, { canRelayMessage: true }),
+			},
 		},
-		directory: properties.directory
+		directory: properties.directory,
 	});
 };

package/src/remotes.ts

@@ -27,11 +27,11 @@ export class Remotes {
 	constructor(readonly path: string) {
 		if (fs.existsSync(path)) {
 			this.data = JSON.parse(
-				fs.readFileSync(path).toString("utf-8")
+				fs.readFileSync(path).toString("utf-8"),
 			) as RemotesObject;
 		} else {
 			this.data = {
-				remotes: []
+				remotes: [],
 			};
 		}
 	}