@peerbit/server 2.0.0 → 3.0.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-73eaa3bc.js"></script>
+  <script type="module" crossorigin src="/assets/index-cac7195d.js"></script>
   <link rel="stylesheet" href="/assets/index-5265c558.css">
 </head>
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@peerbit/server",
-	"version": "2.0.0",
+	"version": "3.0.0",
 	"author": "dao.xyz",
 	"repository": {
 		"type": "git",
@@ -52,7 +52,7 @@
 	},
 	"devDependencies": {
 		"@peerbit/test-lib": "^0.0.1",
-		"@peerbit/test-utils": "1.0.16",
+		"@peerbit/test-utils": "1.0.17",
 		"@types/tmp": "^0.2.3",
 		"@types/yargs": "^17.0.24",
 		"aws-sdk": "^2.1259.0",
@@ -63,11 +63,11 @@
 		"@dao-xyz/libp2p-noise": "^12.0.1",
 		"axios": "^1.4.0",
 		"chalk": "^5.3.0",
-		"peerbit": "1.3.0",
+		"peerbit": "1.3.1",
 		"tar-stream": "^3.1.6",
 		"tmp": "^0.2.1",
 		"yargs": "^17.7.2",
 		"zlib": "^1.0.5"
 	},
-	"gitHead": "8d44d24618ae3aa0e5f2f2d77f0825d59774cce4"
+	"gitHead": "06d341c4ea81b70c76018899b029f4419c311500"
 }

package/src/cli.ts

@@ -6,7 +6,12 @@ import {
 } from "./domain.js";
 import { startServerWithNode } from "./server.js";
 import { createRecord } from "./aws.js";
-import { getHomeConfigDir, getPackageName, getRemotesPath } from "./config.js";
+import {
+	getHomeConfigDir,
+	getKeypair,
+	getPackageName,
+	getRemotesPath,
+} from "./config.js";
 import chalk from "chalk";
 import { client } from "./client.js";
 import { InstallDependency, StartProgram } from "./types.js";
@@ -17,6 +22,7 @@ import fs from "fs";
 import path from "path";
 import { toBase64 } from "@peerbit/crypto";
 import { Remotes } from "./remotes.js";
+import { peerIdFromString } from "@libp2p/peer-id";
 
 const padString = function (string: string, padding: number, padChar = " ") {
 	const val = string.valueOf();
@@ -64,14 +70,6 @@ export const cli = async (args?: string[]) => {
 						default: false,
 						alias: "r",
 					})
-					.option("password", {
-						describe:
-							"Setup password so you can interact with the node remotely",
-						type: "string",
-						defaultDescription:
-							"The password from the last session will be used or a password will be generated",
-						default: undefined,
-					})
 					.option("port-api", {
 						describe:
 							"Set API server port. Only modify this when testing locally, since NGINX config depends on the default value",
@@ -94,12 +92,28 @@ export const cli = async (args?: string[]) => {
 					),
 					ports: { api: args["port-api"], node: args["port-node"] },
 					bootstrap: args.bootstrap,
-					password: args.password,
 					newSession: args.reset,
 				});
 			},
 		})
-
+		.command({
+			command: "id",
+			describe: "Get peer id",
+			builder: (yargs: yargs.Argv) => {
+				yargs.option("directory", {
+					describe: "Peerbit directory",
+					defaultDescription: "~.peerbit",
+					type: "string",
+					alias: "d",
+					default: getHomeConfigDir(),
+				});
+				return yargs;
+			},
+			handler: async (args) => {
+				const kp = await getKeypair(args.directory);
+				console.log((await kp.toPeerId()).toString());
+			},
+		})
 		.command(
 			"domain",
 			"Setup a domain and certificate for this node",
@@ -254,7 +268,7 @@ export const cli = async (args?: string[]) => {
 					},
 				})
 				.command({
-					command: "add <name> <address> <password>",
+					command: "add <name> <address>",
 					describe: "Add remote",
 					builder: (yargs: yargs.Argv) => {
 						yargs
@@ -268,11 +282,6 @@ export const cli = async (args?: string[]) => {
 								describe: "Remote address",
 								demandOption: true,
 							})
-							.positional("password", {
-								type: "string",
-								describe: "Password",
-								demandOption: true,
-							})
 							.option("directory", {
 								describe: "Peerbit directory",
 								defaultDescription: "~.peerbit",
@@ -287,7 +296,10 @@ export const cli = async (args?: string[]) => {
 						if (args.name === "localhost") {
 							throw new Error("Remote can not be named 'localhost'");
 						}
-						const api = await client(args.password, args.address);
+						const api = await client(
+							await getKeypair(args.directory),
+							args.address
+						);
 						try {
 							await api.program.list();
 						} catch (error) {
@@ -297,7 +309,7 @@ export const cli = async (args?: string[]) => {
 							fs.mkdirSync(args.directory, { recursive: true });
 						}
 						const remotes = new Remotes(getRemotesPath(args.directory));
-						remotes.add(args.name, args.address, args.password);
+						remotes.add(args.name, args.address);
 					},
 				})
 				.command({
@@ -363,20 +375,19 @@ export const cli = async (args?: string[]) => {
 							api: Awaited<ReturnType<typeof client>>;
 						}[] = [];
 						console.log(getRemotesPath(connectArgs.directory));
+						const config = await import("./config.js");
+						const keypair = await config.getKeypair(connectArgs.directory);
+
 						if (names.length > 0) {
 							const remotes = new Remotes(
 								getRemotesPath(connectArgs.directory)
 							);
 							for (const name of names) {
 								if (name === "localhost") {
-									const config = await import("./config.js");
-									const adminPassword = await config.loadPassword(
-										config.getServerConfigPath(connectArgs.directory)
-									);
 									apis.push({
 										log: (string) => console.log("localhost: " + string),
 										name: "localhost",
-										api: await client(adminPassword),
+										api: await client(keypair),
 									});
 								} else {
 									const remote = remotes.getByName(name);
@@ -389,10 +400,11 @@ export const cli = async (args?: string[]) => {
 									} else {
 										logFn = (string) => console.log(string);
 									}
+
 									apis.push({
 										log: logFn,
 										name,
-										api: await client(remote.password, remote.address),
+										api: await client(keypair, remote.address),
 									});
 								}
 							}
@@ -437,6 +449,50 @@ export const cli = async (args?: string[]) => {
 										.demandCommand();
 									return yargs;
 								})
+								.command(
+									"access",
+									"Modify access control for this node",
+									(yargs) => {
+										yargs
+											.command({
+												command: "grant <peer-id>",
+												describe: "Give a peer-id admin capabilities",
+												builder: (yargs: yargs.Argv) => {
+													yargs.positional("peer-id", {
+														describe: "Peer id",
+														type: "string",
+														demandOption: true,
+													});
+													return yargs;
+												},
+												handler: async (args) => {
+													const peerId = peerIdFromString(args["peer-id"]);
+													for (const api of apis) {
+														await api.api.trust.add(peerId);
+													}
+												},
+											})
+											.command({
+												command: "deny <peer-id>",
+												describe: "Remove admin capabilities from peer-id",
+												builder: (yargs: yargs.Argv) => {
+													yargs.positional("peer-id", {
+														describe: "Peer id",
+														demandOption: true,
+													});
+													return yargs;
+												},
+												handler: async (args) => {
+													const peerId = peerIdFromString(args["peer-id"]);
+													for (const api of apis) {
+														await api.api.trust.remove(peerId);
+													}
+												},
+											})
+											.strict()
+											.demandCommand();
+									}
+								)
 								.command("network", "Manage network", (yargs) => {
 									yargs
 										.command({

package/src/client.ts

@@ -9,21 +9,37 @@ import {
 	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 (
-	password: string,
+	keypair: Identity<Ed25519PublicKey>,
 	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 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 +69,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 +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[]
@@ -83,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);
@@ -100,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(),
 						}
 					)
 				);
@@ -125,7 +173,7 @@ export const client = async (
 
 			drop: async (address: string): Promise<void> => {
 				throwIfNot200(
-					await axios.delete(
+					await axiosInstance.delete(
 						endpoint +
 							PROGRAM_PATH +
 							"/" +
@@ -133,7 +181,6 @@ export const client = async (
 							"?delete=true",
 						{
 							validateStatus,
-							headers: await getHeaders(),
 						}
 					)
 				);
@@ -141,9 +188,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 +197,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,26 +215,23 @@ 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> => {
 			throwIfNot200(
-				await axios.post(endpoint + TERMINATE_PATH, undefined, {
+				await axiosInstance.post(endpoint + TERMINATE_PATH, undefined, {
 					validateStatus,
-					headers: await getHeaders(),
 				})
 			);
 		},

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

@@ -3,7 +3,6 @@ import fs from "fs";
 interface RemoteObject {
 	address: string;
 	name: string;
-	password: string;
 }
 
 interface RemotesObject {
@@ -35,11 +34,10 @@ export class Remotes {
 	getByAddress(address: string) {
 		return this.data.remotes.find((x) => x.address === address);
 	}
-	add(name: string, address: string, password: string) {
+	add(name: string, address: string) {
 		const obj: RemoteObject = {
 			address,
 			name,
-			password,
 		};
 		const existing = this.data.remotes.findIndex((x) => x.name === name);
 		if (existing >= 0) {

package/src/routes.ts

@@ -11,7 +11,7 @@ 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";