@peerbit/server 1.1.2 → 3.0.0

package/src/client.ts

@@ -1,20 +1,45 @@
-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,
+	TRUST_PATH,
 } from "./routes.js";
 import { Address } from "@peerbit/program";
 import { multiaddr } from "@multiformats/multiaddr";
+import { signRequest } from "./signes-request.js";
+import {
+	Ed25519PublicKey,
+	Identity,
+	PublicSignKey,
+	getPublicKeyFromPeerId,
+} from "@peerbit/crypto";
+import { PeerId } from "@libp2p/interface-peer-id";
 
 export const client = async (
+	keypair: Identity<Ed25519PublicKey>,
 	endpoint: string = "http://localhost:" + LOCAL_PORT
 ) => {
+	const isLocalHost = endpoint.startsWith("http://localhost");
 	const { default: axios } = await import("axios");
+	const axiosInstance = axios.create();
+	axiosInstance.interceptors.request.use(async (config) => {
+		const url = new URL(config.url!);
+		await signRequest(
+			config.headers,
+			config.method!,
+			url.pathname + url.search,
+			config.data,
+			keypair
+		);
+		return config;
+	});
 
 	const validateStatus = (status: number) => {
 		return (status >= 200 && status < 300) || status == 404;
@@ -43,16 +68,13 @@ export const client = async (
 		);
 	};
 	const getId = async () =>
-		throwIfNot200(await axios.get(endpoint + PEER_ID_PATH, { validateStatus }))
-			.data;
+		throwIfNot200(
+			await axiosInstance.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()),
-		};
-		return headers;
-	};
 	return {
 		peer: {
 			id: {
@@ -62,7 +84,7 @@ export const client = async (
 				get: async () => {
 					return (
 						throwIfNot200(
-							await axios.get(endpoint + ADDRESS_PATH, {
+							await axiosInstance.get(endpoint + ADDRESS_PATH, {
 								validateStatus,
 							})
 						).data as string[]
@@ -70,14 +92,51 @@ export const client = async (
 				},
 			},
 		},
+		trust: {
+			add: async (key: PublicSignKey | PeerId) => {
+				const result = await axiosInstance.put(
+					endpoint +
+						TRUST_PATH +
+						"/" +
+						encodeURIComponent(
+							key instanceof PublicSignKey
+								? key.hashcode()
+								: getPublicKeyFromPeerId(key).hashcode()
+						),
+					undefined,
+					{ validateStatus }
+				);
+				if (result.status !== 200 && result.status !== 404) {
+					throw new Error(result.data);
+				}
+				return result.status === 200 ? true : false;
+			},
+			remove: async (key: PublicSignKey | PeerId) => {
+				const result = await axiosInstance.delete(
+					endpoint +
+						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 axios.head(
+				const result = await axiosInstance.head(
 					endpoint +
 						PROGRAM_PATH +
 						"/" +
 						encodeURIComponent(address.toString()),
-					{ validateStatus, headers: await getHeaders() }
+					{ validateStatus }
 				);
 				if (result.status !== 200 && result.status !== 404) {
 					throw new Error(result.data);
@@ -87,24 +146,26 @@ export const client = async (
 
 			open: async (program: StartProgram): Promise<Address> => {
 				const resp = throwIfNot200(
-					await axios.put(endpoint + PROGRAM_PATH, JSON.stringify(program), {
-						validateStatus,
-						headers: await getHeaders(),
-					})
+					await axiosInstance.put(
+						endpoint + PROGRAM_PATH,
+						JSON.stringify(program),
+						{
+							validateStatus,
+						}
+					)
 				);
 				return resp.data as string;
 			},
 
 			close: async (address: string): Promise<void> => {
 				throwIfNot200(
-					await axios.delete(
+					await axiosInstance.delete(
 						endpoint +
 							PROGRAM_PATH +
 							"/" +
 							encodeURIComponent(address.toString()),
 						{
 							validateStatus,
-							headers: await getHeaders(),
 						}
 					)
 				);
@@ -112,7 +173,7 @@ export const client = async (
 
 			drop: async (address: string): Promise<void> => {
 				throwIfNot200(
-					await axios.delete(
+					await axiosInstance.delete(
 						endpoint +
 							PROGRAM_PATH +
 							"/" +
@@ -120,7 +181,6 @@ export const client = async (
 							"?delete=true",
 						{
 							validateStatus,
-							headers: await getHeaders(),
 						}
 					)
 				);
@@ -128,20 +188,22 @@ export const client = async (
 
 			list: async (): Promise<string[]> => {
 				const resp = throwIfNot200(
-					await axios.get(endpoint + PROGRAMS_PATH, {
+					await axiosInstance.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(),
-				});
+			install: async (instruction: InstallDependency): Promise<string[]> => {
+				const resp = await axiosInstance.put(
+					endpoint + INSTALL_PATH,
+					JSON.stringify(instruction),
+					{
+						validateStatus,
+					}
+				);
 				if (resp.status !== 200) {
 					throw new Error(
 						typeof resp.data === "string" ? resp.data : resp.data.toString()
@@ -153,12 +215,25 @@ export const client = async (
 		network: {
 			bootstrap: async (): Promise<void> => {
 				throwIfNot200(
-					await axios.post(endpoint + BOOTSTRAP_PATH, undefined, {
+					await axiosInstance.post(endpoint + BOOTSTRAP_PATH, undefined, {
 						validateStatus,
-						headers: await getHeaders(),
 					})
 				);
 			},
 		},
+		restart: async (): Promise<void> => {
+			throwIfNot200(
+				await axiosInstance.post(endpoint + RESTART_PATH, undefined, {
+					validateStatus,
+				})
+			);
+		},
+		terminate: async (): Promise<void> => {
+			throwIfNot200(
+				await axiosInstance.post(endpoint + TERMINATE_PATH, undefined, {
+					validateStatus,
+				})
+			);
+		},
 	};
 };

package/src/config.ts

@@ -1,22 +1,56 @@
 import path from "path";
 import os from "os";
 import fs from "fs";
+import { deserialize, serialize } from "@dao-xyz/borsh";
+import { Duplex } from "stream"; // Native Node Module
+import { Ed25519Keypair, Keypair, fromBase64 } from "@peerbit/crypto";
 
-export const getHomeConfigDir = async (): Promise<string> => {
+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 getServerConfigPath = (configDir: string): string => {
+	return path.join(configDir, "server");
+};
+
+export const getRemotesPath = (configDir: string): string => {
+	return path.join(configDir, "remotes.json");
 };
 
-export const getKeysPath = async (configDir: string): Promise<string> => {
+export const getNodePath = (directory: string): string => {
+	return path.join(directory, "node");
+};
+
+export const getTrustPath = (directory: string): string => {
+	return path.join(directory, "trust.json");
+};
+
+const getKeysPath = (configDir: string): string => {
 	return path.join(configDir, "keys");
 };
 
+export const getKeypair = async (
+	configDir: string
+): Promise<Ed25519Keypair> => {
+	const keypath = getKeysPath(configDir);
+	if (!fs.existsSync(keypath)) {
+		const keypair = await Ed25519Keypair.create();
+		fs.writeFileSync(keypath, serialize(keypair));
+		return keypair;
+	} else {
+		const keypair = deserialize(fs.readFileSync(keypath), Ed25519Keypair);
+		return keypair;
+	}
+};
+
 export const checkExistPath = async (path: string) => {
 	try {
 		if (!fs.existsSync(path)) {
@@ -32,27 +66,16 @@ export const checkExistPath = async (path: string) => {
 	}
 };
 
-export const loadPassword = async (): Promise<string> => {
-	const configDir = await getHomeConfigDir();
-	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> => {
+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 +107,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,10 +1,25 @@
 import { DirectBlock } from "@peerbit/blocks";
 import { DirectSub } from "@peerbit/pubsub";
 import { Peerbit } from "peerbit";
+import path from "path";
+import { PeerId } from "@libp2p/interface-peer-id";
+
+export const LIBP2P_LISTEN_PORT = 8001;
+export const create = (properties: {
+	directory?: string;
+	domain?: string;
+	listenPort?: number;
+	peerId: PeerId;
+}) => {
+	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: {
+			peerId: properties.peerId,
 			addresses: {
 				announce: properties.domain
 					? [
@@ -12,14 +27,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,63 @@
+import fs from "fs";
+
+interface RemoteObject {
+	address: string;
+	name: 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) {
+		const obj: RemoteObject = {
+			address,
+			name,
+		};
+		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

@@ -11,10 +11,12 @@ export const getPort = (protocol: string) => {
 };
 export const SSL_PORT = 9002;
 export const LOCAL_PORT = 8082;
-
+export const TRUST_PATH = "/trust";
 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";
+export const RESTART_PATH = "/restart";
+export const TERMINATE_PATH = "/terminate";