@peerbit/server 1.1.2 → 3.0.0

package/src/session.ts

@@ -0,0 +1,69 @@
+import { AbstractLevel } from "abstract-level";
+
+export class Session {
+	programs: KV;
+	imports: KV;
+	constructor(
+		readonly level: AbstractLevel<
+			string | Buffer | Uint8Array,
+			string,
+			Uint8Array
+		>
+	) {
+		this.imports = new KV(
+			this.level.sublevel<string, Uint8Array>("imports", {
+				keyEncoding: "utf8",
+				valueEncoding: "view",
+			})
+		);
+		this.programs = new KV(
+			this.level.sublevel<string, Uint8Array>("programs", {
+				keyEncoding: "utf8",
+				valueEncoding: "view",
+			})
+		);
+	}
+
+	async clear() {
+		await this.imports.clear();
+		await this.programs.clear();
+	}
+}
+
+export class KV {
+	constructor(
+		readonly level: AbstractLevel<
+			string | Buffer | Uint8Array,
+			string,
+			Uint8Array
+		>
+	) {}
+
+	add(key: string, arg: Uint8Array) {
+		return this.level.put(key, arg);
+	}
+
+	remove(key: string) {
+		return this.level.del(key);
+	}
+
+	async all(): Promise<[string, Uint8Array][]> {
+		const res: [string, Uint8Array][] = [];
+		for await (const [key, value] of this.level.iterator()) {
+			res.push([key, value]);
+		}
+		return res;
+	}
+
+	async open() {
+		await this.level.open();
+	}
+
+	async close() {
+		await this.level.close();
+	}
+
+	async clear() {
+		await this.level.clear();
+	}
+}

package/src/signes-request.ts

@@ -0,0 +1,84 @@
+import {
+	Identity,
+	PublicSignKey,
+	SignatureWithKey,
+	fromBase64,
+	toBase64,
+	verify,
+	Ed25519PublicKey,
+} from "@peerbit/crypto";
+import { deserialize, serialize, BinaryWriter } from "@dao-xyz/borsh";
+import http from "http";
+
+const SIGNATURE_KEY = "X-Peerbit-Signature";
+const SIGNATURE_TIME_KEY = "X-Peerbit-Signature-Time";
+
+export const signRequest = async (
+	headers: Record<string, string>,
+	method: string,
+	path: string,
+	data: string | undefined,
+	keypair: Identity<Ed25519PublicKey>
+) => {
+	const sigTimestamp = Math.round(new Date().getTime() / 1000).toString();
+	const write = new BinaryWriter();
+	if (!method) {
+		throw new Error("Expecting method");
+	}
+	if (!path) {
+		throw new Error("Expecting path");
+	}
+
+	write.string(
+		method.toLowerCase() + path.toLowerCase() + sigTimestamp + (data || "")
+	);
+	const signature = await keypair.sign(write.finalize());
+	headers[SIGNATURE_TIME_KEY] = sigTimestamp;
+	headers[SIGNATURE_KEY] = toBase64(serialize(signature));
+};
+
+export const getBody = (req: http.IncomingMessage): Promise<string> => {
+	return new Promise((resolve, reject) => {
+		let body = "";
+		req.on("data", (d) => {
+			body += d;
+		});
+		req.on("end", () => {
+			resolve(body);
+		});
+		req.on("error", (e) => reject(e));
+	});
+};
+
+export const verifyRequest = async (
+	headers: Record<string, string | string[] | undefined>,
+	method: string,
+	path: string,
+	body = ""
+): Promise<PublicSignKey> => {
+	const timestamp =
+		headers[SIGNATURE_TIME_KEY] || headers[SIGNATURE_TIME_KEY.toLowerCase()];
+	if (typeof timestamp !== "string") {
+		throw new Error("Unexpected timestamp type: " + typeof timestamp);
+	}
+
+	const write = new BinaryWriter();
+	if (!method) {
+		throw new Error("Expecting method");
+	}
+	if (!path) {
+		throw new Error("Expecting path");
+	}
+
+	write.string(method.toLowerCase() + path.toLowerCase() + timestamp + body);
+	const signature =
+		headers[SIGNATURE_KEY] || headers[SIGNATURE_KEY.toLowerCase()];
+	if (typeof signature !== "string") {
+		throw new Error("Unexpected signature type: " + typeof signature);
+	}
+	const signatureWithKey = deserialize(fromBase64(signature), SignatureWithKey);
+	if (await verify(signatureWithKey, write.finalize())) {
+		return signatureWithKey.publicKey;
+	}
+	throw new Error("Invalid signature");
+};

package/src/trust.browser.ts

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

package/src/trust.ts

@@ -0,0 +1,39 @@
+import fs from "fs";
+
+export class Trust {
+	private trusted: string[];
+	constructor(readonly path: string) {
+		if (fs.existsSync(path)) {
+			this.trusted = JSON.parse(
+				fs.readFileSync(path).toString("utf-8")
+			) as string[];
+		} else {
+			this.trusted = [];
+		}
+	}
+
+	save() {
+		fs.writeFileSync(this.path, JSON.stringify(this.trusted));
+	}
+
+	isTrusted(hashcode: string) {
+		return this.trusted.includes(hashcode);
+	}
+
+	add(key: string) {
+		if (this.isTrusted(key)) {
+			return;
+		}
+		this.trusted.push(key);
+		this.save();
+	}
+
+	remove(hashcode: string) {
+		const existing = this.trusted.findIndex((x) => (x = hashcode));
+		if (existing >= 0) {
+			this.trusted.splice(existing, 1);
+			return true;
+		}
+		return false;
+	}
+}

package/src/types.ts

@@ -5,3 +5,16 @@ export interface StartByBase64 {
 	base64: string;
 }
 export type StartProgram = StartByVariant | StartByBase64;
+
+export interface InstallWithTGZ {
+	type: "tgz";
+	name: string;
+	base64: string;
+}
+
+export interface InstallWithNPM {
+	type: "npm";
+	name: string;
+}
+
+export type InstallDependency = InstallWithTGZ | InstallWithNPM;

package/lib/ui/assets/config.browser-4ed993c7.js

@@ -1 +0,0 @@
-