@peerbit/server 3.0.0 → 4.0.1

package/src/client.ts

@@ -2,31 +2,56 @@ 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 { PeerId } from "@libp2p/interface/peer-id";
+import { waitForResolved } from "@peerbit/time";
+import { RemoteOrigin } from "./remotes.js";
 
-export const client = async (
+export const createClient = async (
 	keypair: Identity<Ed25519PublicKey>,
-	endpoint: string = "http://localhost:" + LOCAL_PORT
+	remote: { address: string; origin?: RemoteOrigin } = {
+		address: "http://localhost:" + LOCAL_API_PORT,
+	}
 ) => {
+	// 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;
+		}
+	}
+
+	// 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) => {
@@ -92,14 +117,17 @@ export const client = async (
 				},
 			},
 		},
-		trust: {
-			add: async (key: PublicSignKey | PeerId) => {
+
+		access: {
+			allow: async (key: PublicSignKey | PeerId | string) => {
 				const result = await axiosInstance.put(
 					endpoint +
 						TRUST_PATH +
 						"/" +
 						encodeURIComponent(
-							key instanceof PublicSignKey
+							typeof key === "string"
+								? key
+								: key instanceof PublicSignKey
 								? key.hashcode()
 								: getPublicKeyFromPeerId(key).hashcode()
 						),
@@ -111,7 +139,7 @@ export const client = async (
 				}
 				return result.status === 200 ? true : false;
 			},
-			remove: async (key: PublicSignKey | PeerId) => {
+			deny: async (key: PublicSignKey | PeerId) => {
 				const result = await axiosInstance.delete(
 					endpoint +
 						TRUST_PATH +
@@ -221,6 +249,7 @@ export const client = async (
 				);
 			},
 		},
+
 		restart: async (): Promise<void> => {
 			throwIfNot200(
 				await axiosInstance.post(endpoint + RESTART_PATH, undefined, {
@@ -228,12 +257,48 @@ export const client = async (
 				})
 			);
 		},
-		terminate: async (): Promise<void> => {
+		stop: async (): Promise<void> => {
 			throwIfNot200(
-				await axiosInstance.post(endpoint + TERMINATE_PATH, undefined, {
+				await axiosInstance.post(endpoint + STOP_PATH, undefined, {
 					validateStatus,
 				})
 			);
 		},
+		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/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,7 +2,7 @@ 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";
+import { PeerId } from "@libp2p/interface/peer-id";
 
 export const LIBP2P_LISTEN_PORT = 8001;
 export const create = (properties: {

package/src/remotes.ts

@@ -1,11 +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;
+	group: string;
+	origin?: RemoteOrigin;
 }
 
-interface RemotesObject {
+export interface RemotesObject {
 	remotes: RemoteObject[];
 }
 
@@ -31,19 +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) {
-		const obj: RemoteObject = {
-			address,
-			name,
-		};
-		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,16 +1,16 @@
 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";
@@ -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";

package/src/server.ts

@@ -1,5 +1,9 @@
 import http from "http";
-import { Ed25519Keypair, fromBase64, sha256Base64Sync } from "@peerbit/crypto";
+import {
+	fromBase64,
+	getKeypairFromPeerId,
+	getPublicKeyFromPeerId,
+} from "@peerbit/crypto";
 import { deserialize } from "@dao-xyz/borsh";
 import {
 	Program,
@@ -28,14 +32,14 @@ import {
 import {
 	ADDRESS_PATH,
 	BOOTSTRAP_PATH,
-	TERMINATE_PATH,
 	INSTALL_PATH,
-	LOCAL_PORT,
+	LOCAL_API_PORT,
 	PEER_ID_PATH,
 	PROGRAMS_PATH,
 	PROGRAM_PATH,
 	RESTART_PATH,
 	TRUST_PATH,
+	STOP_PATH,
 } from "./routes.js";
 import { Session } from "./session.js";
 import fs from "fs";
@@ -51,6 +55,7 @@ import { MemoryLevel } from "memory-level";
 import { Trust } from "./trust.js";
 import { getBody, verifyRequest } from "./signes-request.js";
 import { cli } from "./cli.js";
+import { peerIdFromString } from "@libp2p/peer-id";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -68,6 +73,7 @@ export const startServerWithNode = async (properties: {
 	domain?: string;
 	bootstrap?: boolean;
 	newSession?: boolean;
+	grantAccess?: string[];
 	ports?: {
 		node: number;
 		api: number;
@@ -77,12 +83,16 @@ export const startServerWithNode = async (properties: {
 	if (!fs.existsSync(properties.directory)) {
 		fs.mkdirSync(properties.directory, { recursive: true });
 	}
+
+	const trustPeerIds =
+		properties.grantAccess && properties.grantAccess.length > 0
+			? properties.grantAccess.map((x) => peerIdFromString(x))
+			: [];
+
 	const keypair = await getKeypair(properties.directory);
+
 	const peer = await create({
-		directory:
-			properties.directory != null
-				? getNodePath(properties.directory)
-				: undefined,
+		directory: getNodePath(properties.directory),
 		domain: properties.domain,
 		listenPort: properties.ports?.node,
 		peerId: await keypair.toPeerId(),
@@ -120,12 +130,10 @@ export const startServerWithNode = async (properties: {
 		await session.clear();
 	}
 
+	const trust = new Trust(getTrustPath(properties.directory));
 	const server = await startApiServer(peer, {
 		port: properties.ports?.api,
-		configDirectory:
-			properties.directory != null
-				? path.join(properties.directory, "server")
-				: undefined || getHomeConfigDir(),
+		trust,
 		session,
 	});
 	const printNodeInfo = async () => {
@@ -164,6 +172,12 @@ export const startServerWithNode = async (properties: {
 		});
 	};
 	await shutDownHook(peer, server);
+
+	if (trustPeerIds.length > 0) {
+		for (const id of trustPeerIds) {
+			trust.add(getPublicKeyFromPeerId(id).hashcode());
+		}
+	}
 	return { server, node: peer };
 };
 
@@ -212,17 +226,12 @@ function findPeerbitProgramFolder(inputDirectory: string): string | null {
 export const startApiServer = async (
 	client: ProgramClient,
 	properties: {
-		configDirectory: string;
+		trust: Trust;
 		session?: Session;
 		port?: number;
 	}
 ): Promise<http.Server> => {
-	const port = properties?.port ?? LOCAL_PORT;
-	if (!fs.existsSync(properties.configDirectory)) {
-		fs.mkdirSync(properties.configDirectory, { recursive: true });
-	}
-
-	const trust = new Trust(getTrustPath(properties.configDirectory));
+	const port = properties?.port ?? LOCAL_API_PORT;
 
 	const restart = async () => {
 		await client.stop();
@@ -259,7 +268,7 @@ export const startApiServer = async (
 		if (result.equals(client.identity.publicKey)) {
 			return body;
 		}
-		if (trust.isTrusted(result.hashcode())) {
+		if (properties.trust.isTrusted(result.hashcode())) {
 			return body;
 		}
 		throw new Error("Not trusted");
@@ -547,13 +556,13 @@ export const startApiServer = async (
 					} else if (req.url.startsWith(TRUST_PATH)) {
 						switch (req.method) {
 							case "PUT": {
-								trust.add(getPathValue(req, 1));
+								properties.trust.add(getPathValue(req, 1));
 								res.writeHead(200);
 								res.end();
 								break;
 							}
 							case "DELETE": {
-								const removed = trust.remove(getPathValue(req, 1));
+								const removed = properties.trust.remove(getPathValue(req, 1));
 								res.writeHead(200);
 								res.end(removed);
 								break;
@@ -574,7 +583,7 @@ export const startApiServer = async (
 								r404();
 								break;
 						}
-					} else if (req.url.startsWith(TERMINATE_PATH)) {
+					} else if (req.url.startsWith(STOP_PATH)) {
 						switch (req.method) {
 							case "POST":
 								res.writeHead(200);
@@ -586,7 +595,18 @@ export const startApiServer = async (
 								r404();
 								break;
 						}
-					} else if (req.url.startsWith(PEER_ID_PATH)) {
+					} /* else if (req.url.startsWith(TERMINATE_PATH)) {
+						switch (req.method) {
+							case "POST":
+								execSync("shutdown -h now")
+								process.exit(0);
+								break;
+
+							default:
+								r404();
+								break;
+						}
+					}  */ else if (req.url.startsWith(PEER_ID_PATH)) {
 						res.writeHead(200);
 						res.end(client.peerId.toString());
 					} else if (req.url.startsWith(ADDRESS_PATH)) {

package/src/trust.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 
 export class Trust {
-	private trusted: string[];
+	trusted: string[];
 	constructor(readonly path: string) {
 		if (fs.existsSync(path)) {
 			this.trusted = JSON.parse(