@peerbit/server 1.0.20 → 1.1.0

package/lib/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-40169014.js"></script>
+  <script type="module" crossorigin src="/assets/index-a8188422.js"></script>
   <link rel="stylesheet" href="/assets/index-5265c558.css">
 </head>
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@peerbit/server",
-	"version": "1.0.20",
+	"version": "1.1.0",
 	"author": "dao.xyz",
 	"repository": {
 		"type": "git",
@@ -17,6 +17,12 @@
 	"exports": {
 		"import": "./lib/esm/index.js"
 	},
+	"browser": {
+		"./lib/esm/server.js": "./lib/esm/server.browser.js",
+		"./server.js": "./lib/esm/server.browser.js",
+		"./lib/esm/config.js": "./lib/esm/config.browser.js",
+		"./config.js": "./lib/esm/config.browser.js"
+	},
 	"files": [
 		"lib",
 		"src",
@@ -30,21 +36,21 @@
 		"access": "public"
 	},
 	"engines": {
-		"node": ">=16.15.1"
+		"node": ">=18"
 	},
 	"scripts": {
 		"clean": "shx rm -rf lib/*",
 		"build": "yarn clean && yarn build-lib && yarn build-ui",
 		"build-lib": "tsc -p tsconfig.json",
 		"build-ui": "cd ../frontend && yarn build && cd ../node",
-		"postbuild": "cp src/nginx-template.conf lib/esm/ && echo '{\"type\":\"module\"} ' | node ../../../../node_modules/.bin/json > lib/esm/package.json && cp -r ../frontend/dist lib/ui",
+		"postbuild": "cp src/nginx-template.conf lib/esm/ && cp -r ../frontend/dist lib/ui",
 		"test": "node ../../../node_modules/.bin/jest test  -c  ../../../jest.config.ts --runInBand --forceExit",
 		"test:unit": "node ../../../node_modules/.bin/jest test  -c  ../../../jest.config.unit.ts --runInBand --forceExit",
 		"test:integration": "node ../node_modules/.bin/jest test -c  ../../../jest.config.integration.ts --runInBand --forceExit"
 	},
 	"devDependencies": {
 		"@peerbit/test-lib": "^0.0.1",
-		"@peerbit/test-utils": "1.0.14",
+		"@peerbit/test-utils": "1.0.15",
 		"@types/yargs": "^17.0.24",
 		"aws-sdk": "^2.1259.0",
 		"dotenv": "^16.1.4"
@@ -53,8 +59,11 @@
 		"@aws-sdk/client-route-53": "^3.345.0",
 		"@dao-xyz/libp2p-noise": "^12.0.1",
 		"axios": "^1.4.0",
-		"peerbit": "1.1.7",
-		"yargs": "^17.7.2"
+		"chalk": "^5.3.0",
+		"peerbit": "1.2.0",
+		"tar-stream": "^3.1.6",
+		"yargs": "^17.7.2",
+		"zlib": "^1.0.5"
 	},
-	"gitHead": "7983b5ca2b1c8b25e2f210de5cf67dcb866a9b7d"
+	"gitHead": "4752c301fb49b2f937b4039533ff5bc3537da3e0"
 }

package/src/cli.ts

@@ -4,11 +4,12 @@ import {
 	loadConfig,
 	startCertbot,
 } from "./domain.js";
-import { serialize } from "@dao-xyz/borsh";
-import { client, startServerWithNode } from "./api.js";
+import { startServerWithNode } from "./server.js";
 import { createRecord } from "./aws.js";
-import { toBase64 } from "@peerbit/crypto";
 import { getConfigDir } from "./config.js";
+import chalk from "chalk";
+import { client } from "./client.js";
+import { StartProgram } from "./types.js";
 
 export const cli = async (args?: string[]) => {
 	const yargs = await import("yargs");
@@ -30,14 +31,21 @@ export const cli = async (args?: string[]) => {
 					type: "string",
 					default: await getConfigDir(),
 				},
+
+				bootstrap: {
+					describe: "Whether to connect to bootstap nodes on startup",
+					type: "boolean",
+					default: false,
+				},
 			},
 			handler: async (args) => {
-				await startServerWithNode(
-					args.directory,
-					await loadConfig().then((config) =>
+				await startServerWithNode({
+					directory: args.directory,
+					domain: await loadConfig().then((config) =>
 						config ? getDomainFromConfig(config) : undefined
-					)
-				);
+					),
+					bootstrap: args.bootstrap,
+				});
 			},
 		})
 		.command("domain", "Setup a domain and certificate", (yargs) => {
@@ -148,6 +156,20 @@ export const cli = async (args?: string[]) => {
 				.strict()
 				.demandCommand();
 		})
+		.command("network", "Manage network", (yargs) => {
+			yargs
+				.command({
+					command: "bootstrap",
+					describe: "Connect to bootstrap nodes",
+					handler: async () => {
+						const c = await client();
+						await c.network.bootstrap();
+					},
+				})
+				.strict()
+				.demandCommand();
+		})
+
 		.command("topic", "Manage topics the node is listening to", (yargs) => {
 			yargs
 				.command({
@@ -184,8 +206,8 @@ export const cli = async (args?: string[]) => {
 		.command("program", "Manage programs", (yargs) => {
 			yargs
 				.command({
-					command: "get <address>",
-					describe: "Get program manifest/serialized in base64",
+					command: "status <address>",
+					describe: "Is a program open",
 					builder: (yargs: any) => {
 						yargs.positional("address", {
 							type: "string",
@@ -197,79 +219,132 @@ export const cli = async (args?: string[]) => {
 
 					handler: async (args) => {
 						const c = await client();
-						const program = await c.program.get(args.address);
+						const program = await c.program.has(args.address);
 						if (!program) {
-							console.log("Program does not exist");
+							console.log(chalk.red("Closed"));
 						} else {
-							console.log(toBase64(serialize(program)));
+							console.log(chalk.green("Open"));
 						}
 					},
 				})
 				.command({
-					command: "add <program>",
-					describe: "Add program",
+					command: "drop <address>",
+					describe: "Drop a program",
 					builder: (yargs: any) => {
-						yargs.positional("program", {
+						yargs.positional("address", {
 							type: "string",
-							describe: "base64 serialized",
+							describe: "Program address",
 							demandOption: true,
 						});
 						return yargs;
 					},
+
 					handler: async (args) => {
 						const c = await client();
-						const address = await c.program.put(args.program);
-						console.log(address.toString());
+						await c.program.drop(args.address);
 					},
 				})
 				.command({
-					command: "import <library>",
-					describe: "import a library that contains programs",
+					command: "close <address>",
+					describe: "Close a program",
 					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",
+						yargs.positional("address", {
+							type: "string",
+							describe: "Program address",
 							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);
-						}
+						const c = await client();
+						await c.program.close(args.address);
 					},
 				})
-				.strict()
-				.demandCommand();
-			return yargs;
-		})
-		.command("library", "Manage libraries", (yargs) => {
-			yargs
 				.command({
-					command: "add <library>",
-					describe: "add a library that contains programs",
+					command: "list",
+					describe: "List all runniing programs",
+					aliases: "ls",
+					handler: async (args) => {
+						const c = await client();
+						const list = await c.program.list();
+
+						console.log(`Running programs (${list.length}):`);
+						list.forEach((p) => {
+							console.log(chalk.green(p));
+						});
+					},
+				})
+
+				.command({
+					command: "open [program]",
+					describe: "Open program",
 					builder: (yargs: any) => {
-						yargs.positional("library", {
+						yargs.positional("program", {
 							type: "string",
-							describe:
-								"Library name (will be loaded with js import(...)). Onlu libraries that are globally installed and can be imported",
+							describe: "Identifier",
 							demandOption: true,
 						});
+						yargs.option("base64", {
+							type: "string",
+							describe: "Base64 encoded serialized",
+							alias: "b",
+						});
+						yargs.option("variant", {
+							type: "string",
+							describe: "Variant name",
+							alias: "v",
+						});
 						return yargs;
 					},
 					handler: async (args) => {
 						const c = await client();
-						await c.library.put(args.library);
+						if (!args.base64 && !args.variant) {
+							throw new Error(
+								"Either base64 or variant argument needs to be provided"
+							);
+						}
+						let startArg: StartProgram;
+						if (args.base64) {
+							startArg = {
+								base64: args.base64,
+							};
+						} else {
+							startArg = {
+								variant: args.variant,
+							};
+						}
+						const address = await c.program.open(startArg);
+						console.log("Started program with address: ");
+						console.log(chalk.green(address.toString()));
 					},
 				})
 				.strict()
 				.demandCommand();
 			return yargs;
 		})
+		.command({
+			command: "install <package-spec>",
+			describe: "install and import a dependency",
+			builder: (yargs: any) => {
+				yargs.positional("package-spec", {
+					type: "string",
+					describe: "Installed dependency will be loaded with js import(...)",
+					demandOption: true,
+				});
+
+				return yargs;
+			},
+			handler: async (args) => {
+				const c = await client();
+				const newPrograms = await c.dependency.install(args["package-spec"]);
+
+				console.log(`New programs available (${newPrograms.length}):`);
+				newPrograms.forEach((p) => {
+					console.log(chalk.green(p));
+				});
+			},
+		})
 		.help()
 		.strict()
 		.demandCommand().argv;

package/src/client.ts

@@ -1,23 +1,164 @@
-import { DirectSub } from "@peerbit/pubsub";
-import { Peerbit } from "peerbit";
+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 { Address } from "@peerbit/program";
+import { multiaddr } from "@multiformats/multiaddr";
 
-export const create = (directory: string, domain?: string) => {
-	return Peerbit.create({
-		libp2p: {
+export const client = async (
+	endpoint: string = "http://localhost:" + LOCAL_PORT
+) => {
+	const { default: axios } = await import("axios");
+
+	const validateStatus = (status: number) => {
+		return (status >= 200 && status < 300) || status == 404;
+	};
+
+	const throwIfNot200 = (resp: { status: number; data: any }) => {
+		if (resp.status !== 200) {
+			throw new Error(resp.data);
+		}
+		return resp;
+	};
+	const getBodyByStatus = <
+		D extends { toString(): string },
+		T extends { status: number; data: D }
+	>(
+		resp: T
+	): D | undefined => {
+		if (resp.status === 404) {
+			return;
+		}
+		if (resp.status == 200) {
+			return resp.data;
+		}
+		throw new Error(
+			typeof resp.data === "string" ? resp.data : resp.data.toString()
+		);
+	};
+	const getId = async () =>
+		throwIfNot200(await axios.get(endpoint + PEER_ID_PATH, { validateStatus }))
+			.data;
+
+	const getHeaders = async () => {
+		const config = await import("./config.js");
+		const headers = {
+			authorization: "Basic admin:" + (await config.loadPassword()),
+		};
+		return headers;
+	};
+	return {
+		peer: {
+			id: {
+				get: getId,
+			},
 			addresses: {
-				announce: domain
-					? [`/dns4/${domain}/tcp/8001`, `/dns4/${domain}/tcp/8002/ws`]
-					: undefined,
-				listen: ["/ip4/127.0.0.1/tcp/8001", "/ip4/127.0.0.1/tcp/8002/ws"],
+				get: async () => {
+					return (
+						throwIfNot200(
+							await axios.get(endpoint + ADDRESS_PATH, {
+								validateStatus,
+							})
+						).data as string[]
+					).map((x) => multiaddr(x));
+				},
+			},
+		},
+		program: {
+			has: async (address: Address | string): Promise<boolean> => {
+				const result = await axios.head(
+					endpoint +
+						PROGRAM_PATH +
+						"/" +
+						encodeURIComponent(address.toString()),
+					{ validateStatus, headers: await getHeaders() }
+				);
+				if (result.status !== 200 && result.status !== 404) {
+					throw new Error(result.data);
+				}
+				return result.status === 200 ? true : false;
+			},
+
+			open: async (program: StartProgram): Promise<Address> => {
+				const resp = throwIfNot200(
+					await axios.put(endpoint + PROGRAM_PATH, JSON.stringify(program), {
+						validateStatus,
+						headers: await getHeaders(),
+					})
+				);
+				return resp.data as string;
 			},
-			connectionManager: {
-				maxConnections: Infinity,
-				minConnections: 0,
+
+			close: async (address: string): Promise<void> => {
+				throwIfNot200(
+					await axios.delete(
+						endpoint +
+							PROGRAM_PATH +
+							"/" +
+							encodeURIComponent(address.toString()),
+						{
+							validateStatus,
+							headers: await getHeaders(),
+						}
+					)
+				);
+			},
+
+			drop: async (address: string): Promise<void> => {
+				throwIfNot200(
+					await axios.delete(
+						endpoint +
+							PROGRAM_PATH +
+							"/" +
+							encodeURIComponent(address.toString()) +
+							"?delete=true",
+						{
+							validateStatus,
+							headers: await getHeaders(),
+						}
+					)
+				);
+			},
+
+			list: async (): Promise<string[]> => {
+				const resp = throwIfNot200(
+					await axios.get(endpoint + PROGRAMS_PATH, {
+						validateStatus,
+						headers: await getHeaders(),
+					})
+				);
+				return resp.data as string[];
+			},
+		},
+		dependency: {
+			install: async (name: string): Promise<string[]> => {
+				const resp = await axios.put(endpoint + INSTALL_PATH, name, {
+					validateStatus,
+					headers: await getHeaders(),
+				});
+				if (resp.status !== 200) {
+					throw new Error(
+						typeof resp.data === "string" ? resp.data : resp.data.toString()
+					);
+				}
+				return resp.data;
 			},
-			services: {
-				pubsub: (c) => new DirectSub(c, { canRelayMessage: true }),
+		},
+		network: {
+			bootstrap: async (): Promise<void> => {
+				throwIfNot200(
+					await axios.post(endpoint + BOOTSTRAP_PATH, undefined, {
+						validateStatus,
+						headers: await getHeaders(),
+					})
+				);
 			},
 		},
-		directory,
-	});
+	};
 };

package/src/config.browser.ts

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

package/src/config.ts

@@ -17,4 +17,84 @@ export const getKeysPath = async (configDir: string): Promise<string> => {
 	return path.join(configDir, "keys");
 };
 
+export const checkExistPath = async (path: string) => {
+	const fs = await import("fs");
+
+	try {
+		if (!fs.existsSync(path)) {
+			fs.accessSync(path, fs.constants.W_OK); // will throw if fails
+			return false;
+		}
+		return true;
+	} catch (err: any) {
+		if (err.message.indexOf("no such file")) {
+			return false;
+		}
+		throw new Error("Can not access path");
+	}
+};
+
+export const loadPassword = async (): Promise<string> => {
+	const fs = await import("fs");
+	const configDir = await getConfigDir();
+	const credentialsPath = await getCredentialsPath(configDir);
+	if (!(await checkExistPath(credentialsPath))) {
+		throw new NotFoundError("Credentials file does not exist");
+	}
+	const password = JSON.parse(
+		fs.readFileSync(credentialsPath, "utf-8")
+	).password;
+	if (!password || password.length === 0) {
+		throw new NotFoundError("Password not found");
+	}
+	return password;
+};
+
+export const getPackageName = async (path: string): Promise<string> => {
+	const pathLib = await import("path");
+	const tar = await import("tar-stream");
+	const zlib = await import("zlib");
+	const urlLib = await import("url");
+	const fs = await import("fs");
+
+	if (!fs.existsSync(path)) {
+		throw new Error("File does not exist");
+	}
+	return new Promise((resolve, reject) => {
+		try {
+			const extract = tar.extract();
+			let data = "";
+
+			extract.on("entry", function (header, stream, cb) {
+				stream.on("data", function (chunk) {
+					if (header.name == "package/package.json") data += chunk;
+				});
+
+				stream.on("end", function () {
+					cb();
+				});
+
+				stream.resume();
+			});
+
+			extract.on("finish", function () {
+				const name = JSON.parse(data)?.name;
+				if (!name) {
+					reject(new Error("Could not find name from package.json file"));
+				} else {
+					resolve(name);
+				}
+			});
+
+			extract.on("error", (e) => {
+				reject(e);
+			});
+
+			fs.createReadStream(path).pipe(zlib.createGunzip()).pipe(extract);
+		} catch (error) {
+			reject(error);
+		}
+	});
+};
+
 export class NotFoundError extends Error {}

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/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