@peerbit/server 1.1.2 → 2.0.0

package/src/client.ts

@@ -1,19 +1,28 @@
-import { StartByBase64, StartByVariant, StartProgram } from "./types.js";
+import { InstallDependency, StartProgram } from "./types.js";
 import {
 	ADDRESS_PATH,
 	BOOTSTRAP_PATH,
+	TERMINATE_PATH,
 	INSTALL_PATH,
 	LOCAL_PORT,
 	PEER_ID_PATH,
 	PROGRAMS_PATH,
 	PROGRAM_PATH,
+	RESTART_PATH,
 } from "./routes.js";
 import { Address } from "@peerbit/program";
 import { multiaddr } from "@multiformats/multiaddr";
 
 export const client = async (
+	password: string,
 	endpoint: string = "http://localhost:" + LOCAL_PORT
 ) => {
+	const isLocalHost = endpoint.startsWith("http://localhost");
+
+	if (!isLocalHost && password == null) {
+		throw new Error("Expecting password when starting the client");
+	}
+
 	const { default: axios } = await import("axios");
 
 	const validateStatus = (status: number) => {
@@ -43,16 +52,20 @@ export const client = async (
 		);
 	};
 	const getId = async () =>
-		throwIfNot200(await axios.get(endpoint + PEER_ID_PATH, { validateStatus }))
-			.data;
+		throwIfNot200(
+			await axios.get(endpoint + PEER_ID_PATH, {
+				validateStatus,
+				timeout: 5000,
+			})
+		).data;
 
 	const getHeaders = async () => {
-		const config = await import("./config.js");
 		const headers = {
-			authorization: "Basic admin:" + (await config.loadPassword()),
+			authorization: "Basic admin:" + password,
 		};
 		return headers;
 	};
+
 	return {
 		peer: {
 			id: {
@@ -137,11 +150,15 @@ export const client = async (
 			},
 		},
 		dependency: {
-			install: async (name: string): Promise<string[]> => {
-				const resp = await axios.put(endpoint + INSTALL_PATH, name, {
-					validateStatus,
-					headers: await getHeaders(),
-				});
+			install: async (instruction: InstallDependency): Promise<string[]> => {
+				const resp = await axios.put(
+					endpoint + INSTALL_PATH,
+					JSON.stringify(instruction),
+					{
+						validateStatus,
+						headers: await getHeaders(),
+					}
+				);
 				if (resp.status !== 200) {
 					throw new Error(
 						typeof resp.data === "string" ? resp.data : resp.data.toString()
@@ -160,5 +177,21 @@ export const client = async (
 				);
 			},
 		},
+		restart: async (): Promise<void> => {
+			throwIfNot200(
+				await axios.post(endpoint + RESTART_PATH, undefined, {
+					validateStatus,
+					headers: await getHeaders(),
+				})
+			);
+		},
+		terminate: async (): Promise<void> => {
+			throwIfNot200(
+				await axios.post(endpoint + TERMINATE_PATH, undefined, {
+					validateStatus,
+					headers: await getHeaders(),
+				})
+			);
+		},
 	};
 };

package/src/config.ts

@@ -2,15 +2,34 @@ import path from "path";
 import os from "os";
 import fs from "fs";
 
-export const getHomeConfigDir = async (): Promise<string> => {
+import { Duplex } from "stream"; // Native Node Module
+
+const bufferToStream = (myBuffer) => {
+	const tmp = new Duplex();
+	tmp.push(myBuffer);
+	tmp.push(null);
+	return tmp;
+};
+
+export const getHomeConfigDir = (): string => {
 	const configDir = path.join(os.homedir(), ".peerbit");
 	return configDir;
 };
 
-export const getCredentialsPath = async (
-	configDir: string
-): Promise<string> => {
-	return path.join(configDir, "credentials");
+export const getCredentialsPath = (configDir: string): string => {
+	return path.join(configDir, "credentials.json");
+};
+
+export const getServerConfigPath = (configDir: string): string => {
+	return path.join(configDir, "server");
+};
+
+export const getRemotesPath = (configDir: string): string => {
+	return path.join(configDir, "remotes.json");
+};
+
+export const getNodePath = (directory: string): string => {
+	return path.join(directory, "node");
 };
 
 export const getKeysPath = async (configDir: string): Promise<string> => {
@@ -32,8 +51,10 @@ export const checkExistPath = async (path: string) => {
 	}
 };
 
-export const loadPassword = async (): Promise<string> => {
-	const configDir = await getHomeConfigDir();
+export const loadPassword = async (
+	configDirectory: string
+): Promise<string> => {
+	const configDir = configDirectory || (await getHomeConfigDir());
 	const credentialsPath = await getCredentialsPath(configDir);
 	if (!(await checkExistPath(credentialsPath))) {
 		throw new NotFoundError("Credentials file does not exist");
@@ -47,12 +68,16 @@ export const loadPassword = async (): Promise<string> => {
 	return password;
 };
 
-export const getPackageName = async (path: string): Promise<string> => {
+export const getPackageName = async (
+	path: string | Uint8Array
+): Promise<string> => {
 	const tar = await import("tar-stream");
 	const zlib = await import("zlib");
 
-	if (!fs.existsSync(path)) {
-		throw new Error("File does not exist");
+	if (typeof path === "string") {
+		if (!fs.existsSync(path)) {
+			throw new Error("File does not exist");
+		}
 	}
 	return new Promise((resolve, reject) => {
 		try {
@@ -84,7 +109,11 @@ export const getPackageName = async (path: string): Promise<string> => {
 				reject(e);
 			});
 
-			fs.createReadStream(path).pipe(zlib.createGunzip()).pipe(extract);
+			if (typeof path === "string") {
+				fs.createReadStream(path).pipe(zlib.createGunzip()).pipe(extract);
+			} else {
+				bufferToStream(path).pipe(zlib.createGunzip()).pipe(extract);
+			}
 		} catch (error) {
 			reject(error);
 		}

package/src/peerbit.ts

@@ -1,8 +1,20 @@
 import { DirectBlock } from "@peerbit/blocks";
 import { DirectSub } from "@peerbit/pubsub";
 import { Peerbit } from "peerbit";
+import path from "path";
+
+export const LIBP2P_LISTEN_PORT = 8001;
+export const create = (properties: {
+	directory?: string;
+	domain?: string;
+	listenPort?: number;
+}) => {
+	const listenPort = properties.listenPort ?? LIBP2P_LISTEN_PORT;
+	const blocksDirectory =
+		properties.directory != null
+			? path.join(properties.directory, "/blocks").toString()
+			: undefined;
 
-export const create = (properties: { directory?: string; domain?: string }) => {
 	return Peerbit.create({
 		libp2p: {
 			addresses: {
@@ -12,14 +24,23 @@ export const create = (properties: { directory?: string; domain?: string }) => {
 							`/dns4/${properties.domain}/tcp/4003/wss`,
 					  ]
 					: undefined,
-				listen: ["/ip4/127.0.0.1/tcp/8001", "/ip4/127.0.0.1/tcp/8002/ws"],
+				listen: [
+					`/ip4/127.0.0.1/tcp/${listenPort}`,
+					`/ip4/127.0.0.1/tcp/${
+						listenPort !== 0 ? listenPort + 1 : listenPort
+					}/ws`,
+				],
 			},
 			connectionManager: {
 				maxConnections: Infinity,
 				minConnections: 0,
 			},
 			services: {
-				blocks: (c) => new DirectBlock(c, { canRelayMessage: true }),
+				blocks: (c) =>
+					new DirectBlock(c, {
+						directory: blocksDirectory,
+						canRelayMessage: true,
+					}),
 				pubsub: (c) => new DirectSub(c, { canRelayMessage: true }),
 			},
 		},

package/src/remotes.browser.ts

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

package/src/remotes.ts

@@ -0,0 +1,65 @@
+import fs from "fs";
+
+interface RemoteObject {
+	address: string;
+	name: string;
+	password: string;
+}
+
+interface RemotesObject {
+	remotes: RemoteObject[];
+}
+
+export class Remotes {
+	private data: RemotesObject;
+
+	constructor(readonly path: string) {
+		if (fs.existsSync(path)) {
+			this.data = JSON.parse(
+				fs.readFileSync(path).toString("utf-8")
+			) as RemotesObject;
+		} else {
+			this.data = {
+				remotes: [],
+			};
+		}
+	}
+
+	save() {
+		fs.writeFileSync(this.path, JSON.stringify(this.data));
+	}
+
+	getByName(name: string) {
+		return this.data.remotes.find((x) => x.name === name);
+	}
+	getByAddress(address: string) {
+		return this.data.remotes.find((x) => x.address === address);
+	}
+	add(name: string, address: string, password: string) {
+		const obj: RemoteObject = {
+			address,
+			name,
+			password,
+		};
+		const existing = this.data.remotes.findIndex((x) => x.name === name);
+		if (existing >= 0) {
+			this.data.remotes[existing] = obj;
+		} else {
+			this.data.remotes.push(obj);
+		}
+		this.save();
+	}
+
+	remove(name: string) {
+		const existing = this.data.remotes.findIndex((x) => x.name === name);
+		if (existing >= 0) {
+			this.data.remotes.splice(existing, 1);
+			return true;
+		}
+		return false;
+	}
+
+	async all(): Promise<RemoteObject[]> {
+		return this.data.remotes;
+	}
+}

package/src/routes.ts

@@ -18,3 +18,5 @@ export const PROGRAM_PATH = "/program";
 export const PROGRAMS_PATH = "/programs";
 export const INSTALL_PATH = "/install";
 export const BOOTSTRAP_PATH = "/network/bootstrap";
+export const RESTART_PATH = "/restart";
+export const TERMINATE_PATH = "/terminate";