@peerbit/server 2.0.0 → 4.0.0

package/src/client.ts

@@ -2,28 +2,69 @@ import { InstallDependency, StartProgram } from "./types.js";
 import {
 	ADDRESS_PATH,
 	BOOTSTRAP_PATH,
-	TERMINATE_PATH,
+	STOP_PATH,
 	INSTALL_PATH,
-	LOCAL_PORT,
+	LOCAL_API_PORT,
 	PEER_ID_PATH,
 	PROGRAMS_PATH,
 	PROGRAM_PATH,
 	RESTART_PATH,
+	TRUST_PATH,
+	REMOTE_API_PORT,
 } from "./routes.js";
 import { Address } from "@peerbit/program";
 import { multiaddr } from "@multiformats/multiaddr";
+import { signRequest } from "./signes-request.js";
+import {
+	Ed25519Keypair,
+	Ed25519PublicKey,
+	Identity,
+	PublicSignKey,
+	getPublicKeyFromPeerId,
+} from "@peerbit/crypto";
+import { PeerId } from "@libp2p/interface/peer-id";
+import { waitForResolved } from "@peerbit/time";
+import { RemoteOrigin } from "./remotes.js";
 
-export const client = async (
-	password: string,
-	endpoint: string = "http://localhost:" + LOCAL_PORT
+export const createClient = async (
+	keypair: Identity<Ed25519PublicKey>,
+	remote: { address: string; origin?: RemoteOrigin } = {
+		address: "http://localhost:" + LOCAL_API_PORT,
+	}
 ) => {
-	const isLocalHost = endpoint.startsWith("http://localhost");
+	// Add missing protocol
+	let endpoint = remote.address;
+	if (!endpoint.startsWith("http://") && !endpoint.startsWith("https://")) {
+		if (endpoint.endsWith("localhost:") || endpoint.endsWith("localhost")) {
+			endpoint = "http://" + endpoint;
+		} else {
+			endpoint = "https://" + endpoint;
+		}
+	}
 
-	if (!isLocalHost && password == null) {
-		throw new Error("Expecting password when starting the client");
+	// Add missing port
+	const isLocalHost = endpoint.startsWith("http://localhost");
+	if (new URL(endpoint).port === "" && !endpoint.endsWith(":80")) {
+		if (isLocalHost) {
+			endpoint = endpoint + ":" + LOCAL_API_PORT;
+		} else {
+			endpoint = endpoint + ":" + REMOTE_API_PORT;
+		}
 	}
 
 	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;
@@ -53,19 +94,12 @@ export const client = async (
 	};
 	const getId = async () =>
 		throwIfNot200(
-			await axios.get(endpoint + PEER_ID_PATH, {
+			await axiosInstance.get(endpoint + PEER_ID_PATH, {
 				validateStatus,
 				timeout: 5000,
 			})
 		).data;
 
-	const getHeaders = async () => {
-		const headers = {
-			authorization: "Basic admin:" + password,
-		};
-		return headers;
-	};
-
 	return {
 		peer: {
 			id: {
@@ -75,7 +109,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[]
@@ -83,14 +117,54 @@ export const client = async (
 				},
 			},
 		},
+
+		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()
+						),
+					undefined,
+					{ validateStatus }
+				);
+				if (result.status !== 200 && result.status !== 404) {
+					throw new Error(result.data);
+				}
+				return result.status === 200 ? true : false;
+			},
+			deny: 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);
@@ -100,24 +174,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(),
 						}
 					)
 				);
@@ -125,7 +201,7 @@ export const client = async (
 
 			drop: async (address: string): Promise<void> => {
 				throwIfNot200(
-					await axios.delete(
+					await axiosInstance.delete(
 						endpoint +
 							PROGRAM_PATH +
 							"/" +
@@ -133,7 +209,6 @@ export const client = async (
 							"?delete=true",
 						{
 							validateStatus,
-							headers: await getHeaders(),
 						}
 					)
 				);
@@ -141,9 +216,8 @@ 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[];
@@ -151,12 +225,11 @@ export const client = async (
 		},
 		dependency: {
 			install: async (instruction: InstallDependency): Promise<string[]> => {
-				const resp = await axios.put(
+				const resp = await axiosInstance.put(
 					endpoint + INSTALL_PATH,
 					JSON.stringify(instruction),
 					{
 						validateStatus,
-						headers: await getHeaders(),
 					}
 				);
 				if (resp.status !== 200) {
@@ -170,28 +243,62 @@ 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 axios.post(endpoint + RESTART_PATH, undefined, {
+				await axiosInstance.post(endpoint + RESTART_PATH, undefined, {
 					validateStatus,
-					headers: await getHeaders(),
 				})
 			);
 		},
-		terminate: async (): Promise<void> => {
+		stop: async (): Promise<void> => {
 			throwIfNot200(
-				await axios.post(endpoint + TERMINATE_PATH, undefined, {
+				await axiosInstance.post(endpoint + STOP_PATH, undefined, {
 					validateStatus,
-					headers: await getHeaders(),
 				})
 			);
 		},
+		terminate: async () => {
+			const { terminateNode } = await import("./aws.js");
+			if (remote.origin?.type === "aws") {
+				await terminateNode({
+					instanceId: remote.origin.instanceId,
+					region: remote.origin.region,
+				});
+			}
+		},
 	};
 };
+
+export const waitForDomain = async (
+	ip: string,
+	timeout: number = 5 * 60 * 1000
+): Promise<string> => {
+	const c = await createClient(await Ed25519Keypair.create(), {
+		address: "http://" + ip + ":" + LOCAL_API_PORT,
+	});
+	const result = await waitForResolved(
+		async () => {
+			const addresses = await c.peer.addresses.get();
+			const domain = multiaddr(addresses[0]).nodeAddress().address;
+			if (!domain) {
+				throw new Error("Not ready");
+			}
+			return domain;
+		},
+		{
+			delayInterval: 5000,
+			timeout,
+		}
+	);
+	if (!result) {
+		throw new Error("Failed to resolve domain");
+	}
+	return result;
+};

package/src/config.ts

@@ -1,8 +1,9 @@
 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";
 
 const bufferToStream = (myBuffer) => {
 	const tmp = new Duplex();
@@ -16,10 +17,6 @@ export const getHomeConfigDir = (): string => {
 	return configDir;
 };
 
-export const getCredentialsPath = (configDir: string): string => {
-	return path.join(configDir, "credentials.json");
-};
-
 export const getServerConfigPath = (configDir: string): string => {
 	return path.join(configDir, "server");
 };
@@ -32,10 +29,28 @@ export const getNodePath = (directory: string): string => {
 	return path.join(directory, "node");
 };
 
-export const getKeysPath = async (configDir: string): Promise<string> => {
+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)) {
@@ -51,23 +66,6 @@ export const checkExistPath = async (path: string) => {
 	}
 };
 
-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");
-	}
-	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 | Uint8Array
 ): Promise<string> => {

package/src/docker.browser.ts

@@ -0,0 +1 @@
+// Unsupported

package/src/domain.ts

@@ -1,5 +1,4 @@
 import { waitFor, waitForAsync } from "@peerbit/time";
-import { installDocker, startContainer } from "./docker.js";
 
 const isNode = typeof window === undefined || typeof window === "undefined";
 
@@ -146,6 +145,7 @@ export const startCertbot = async (
 	if (!validateEmail(email)) {
 		throw new Error("Email for SSL renenewal is invalid");
 	}
+	const { installDocker, startContainer } = await import("./docker.js");
 
 	const nginxConfigPath = await getNginxFolderPath();
 	await createConfig(nginxConfigPath, domain);

package/src/peerbit.ts

@@ -2,12 +2,14 @@ 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 =
@@ -17,6 +19,7 @@ export const create = (properties: {
 
 	return Peerbit.create({
 		libp2p: {
+			peerId: properties.peerId,
 			addresses: {
 				announce: properties.domain
 					? [

package/src/remotes.ts

@@ -1,12 +1,23 @@
 import fs from "fs";
 
-interface RemoteObject {
+interface AWSOrigin {
+	type: "aws";
+	region: string;
+	instanceId: string;
+}
+
+export type RemoteOrigin = AWSOrigin;
+
+export const DEFAULT_REMOTE_GROUP = "default";
+
+export interface RemoteObject {
 	address: string;
 	name: string;
-	password: string;
+	group: string;
+	origin?: RemoteOrigin;
 }
 
-interface RemotesObject {
+export interface RemotesObject {
 	remotes: RemoteObject[];
 }
 
@@ -32,20 +43,21 @@ export class Remotes {
 	getByName(name: string) {
 		return this.data.remotes.find((x) => x.name === name);
 	}
+
+	getByGroup(group: string) {
+		return this.data.remotes.filter((x) => x.group === group);
+	}
+
 	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);
+
+	add(remote: RemoteObject) {
+		const existing = this.data.remotes.findIndex((x) => x.name === remote.name);
 		if (existing >= 0) {
-			this.data.remotes[existing] = obj;
+			this.data.remotes[existing] = remote;
 		} else {
-			this.data.remotes.push(obj);
+			this.data.remotes.push(remote);
 		}
 		this.save();
 	}

package/src/routes.ts

@@ -1,17 +1,17 @@
 export const getPort = (protocol: string) => {
 	if (protocol === "https:") {
-		return SSL_PORT;
+		return REMOTE_API_PORT;
 	}
 
 	if (protocol === "http:") {
-		return LOCAL_PORT;
+		return LOCAL_API_PORT;
 	}
 
 	throw new Error("Unsupported protocol: " + protocol);
 };
-export const SSL_PORT = 9002;
-export const LOCAL_PORT = 8082;
-
+export const REMOTE_API_PORT = 9002;
+export const LOCAL_API_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";
@@ -20,3 +20,4 @@ export const INSTALL_PATH = "/install";
 export const BOOTSTRAP_PATH = "/network/bootstrap";
 export const RESTART_PATH = "/restart";
 export const TERMINATE_PATH = "/terminate";
+export const STOP_PATH = "/path";