server.ts

import { inflateSync } from "node:zlib";
import { encodeBase64 } from "@sigma/rust-base64";
import { z } from "zod";
import { thingsDecryptText, thingsEncryptText } from "./crypto.ts";

/**
 * CONFIGURATION
 */
const sslKey = {
	key: Deno.readTextFileSync("./ssl/cert.key"),
	cert: Deno.readTextFileSync("./ssl/cert.pem"),
};
const ShowBase64 = false;

/**
 * Print the given bytes
 * @param bytes
 * @param contentEncoding
 */
function printBytes(bytes: Uint8Array, contentEncoding: string | null): void {
	if (ShowBase64) {
		console.log("-------- BASE64 ------------");
		console.log(encodeBase64(bytes));
		console.log("-------- BASE64 END --------");
	}

	console.log(decodeBytes(bytes, contentEncoding));
}

/**
 * Decode the given bytes to string using the given content-encoding.
 * @param bytes
 * @param contentEncoding
 */
function decodeBytes(
	bytes: Uint8Array,
	contentEncoding: string | null,
): string {
	if (contentEncoding === "deflate") {
		const out = inflateSync(bytes);
		return out.toString();
	}

	return new TextDecoder().decode(bytes);
}

/**
 * SERVER
 */
Deno.serve(
	{
		port: 443,
		hostname: "0.0.0.0",
		...sslKey,
		onError: (err) => {
			console.error(err);
			return new Response("ERROR", {
				status: 500,
			});
		},
	},
	async (_req): Promise<Response> => {
		console.log(_req.url);
		if (!_req.url.startsWith("https://cloud.culturedcode.com/")) {
			return new Response("...", {
				status: 400,
			});
		}

		if (_req.url.endsWith("/meow")) {
			return new Response("Meow.");
		}

		console.log("------------ REQUEST -------------");
		console.log(_req);

		let rBytes: Uint8Array | undefined = undefined;
		if (_req.body) {
			const blob = await _req.blob();
			rBytes = await blob.bytes();
			printBytes(rBytes, _req.headers.get("content-encoding"));
		}
		console.log("------------ REQUEST END ---------");

		/**
		 * INTERCEPTING WRITES
		 */
		if (rBytes && /version\/1\/history\/.+?\/commit/.test(_req.url)) {
			// WRITE request
			/**
			 * Parse the request into an object.
			 */
			const payload = z
				.record(
					z.string(),
					z
						.object({
							p: z
								.object({
									tt: z.string().optional(),
									nt: z
										.object({
											v: z.string().optional(),
											ps: z
												.array(
													z
														.object({
															r: z.string().optional(),
														})
														.passthrough(),
												)
												.optional(),
										})
										.passthrough()
										.optional(),
								})
								.passthrough(),
						})
						.passthrough(),
				)
				.parse(
					JSON.parse(decodeBytes(rBytes, _req.headers.get("content-encoding"))),
				);

			/**
			 * Encrypt the payload's sensitive fields.
			 */
			for (const [k, v] of Object.entries(payload)) {
				await Promise.all([
					(async () => {
						if (!v.p.tt) {
							return;
						}
						payload[k].p.tt = await thingsEncryptText(v.p.tt);
					})(),
					(async () => {
						if (!v.p.nt?.v || !payload[k].p.nt) {
							return;
						}
						payload[k].p.nt.v = await thingsEncryptText(v.p.nt.v);
					})(),
					(async () => {
						if (!v.p.nt?.ps || !payload[k].p.nt?.ps) {
							return; // ignore updates with no text
						}
						for (const [i, va] of v.p.nt.ps.entries()) {
							if (!va.r) {
								continue;
							}

							payload[k].p.nt.ps[i].r = await thingsEncryptText(va.r);
						}
					})(),
				]);
			}

			// TODO: deflate to make it smaller
			rBytes = new TextEncoder().encode(JSON.stringify(payload));
			// note: The fetch API will take care of deflating
		}

		/**
		 * MAKING THE REQUEST
		 */
		const resp = await fetch(_req.url, {
			headers: _req.headers,
			method: _req.method,
			body: rBytes,
		});

		console.log("------ RESP ---------");
		console.log(resp);
		const blob = await resp.blob();
		let bytes = await blob.bytes();
		printBytes(bytes, resp.headers.get("content-encoding"));
		console.log("------ RESP END ---------");

		// clone the headers; this is needed because the response headers are immutable.
		const headers = new Headers();
		for (const [k, v] of resp.headers.entries()) {
			headers.set(k, v);
		}

		try {
			/**
			 * INTERCEPTING READS
			 */
			if (/version\/1\/history\/.+?\/items/.test(_req.url)) {
				/**
				 * Parse the response
				 */
				// FIXME: deduplicate schemas
				const payload = z
					.object({
						items: z.array(
							z.record(
								z.string(),
								z
									.object({
										p: z
											.object({
												tt: z.string().optional(),
												nt: z
													.object({
														v: z.string().optional(),
														ps: z
															.array(
																z
																	.object({
																		r: z.string().optional(),
																	})
																	.passthrough(),
															)
															.optional(),
													})
													.passthrough()
													.optional(),
											})
											.passthrough(),
									})
									.passthrough(),
							),
						),
					})
					.passthrough()
					.parse(
						JSON.parse(
							decodeBytes(bytes, resp.headers.get("content-encoding")),
						),
					);

				/**
				 * Decrypt the payload's sensitive fields
				 */
				for (const [updateIndex, update] of payload.items.entries()) {
					for (const [taskId, taskValue] of Object.entries(update)) {
						await Promise.all([
							(async () => {
								if (!taskValue.p.tt) {
									return; // ignore updates with no text
								}
								payload.items[updateIndex][taskId].p.tt =
									await thingsDecryptText(taskValue.p.tt);
							})(),
							(async () => {
								if (
									!taskValue.p.nt?.v ||
									!payload.items[updateIndex][taskId].p.nt
								) {
									return; // ignore updates with no text
								}
								payload.items[updateIndex][taskId].p.nt.v =
									await thingsDecryptText(taskValue.p.nt.v);
							})(),
							(async () => {
								if (!taskValue.p.nt?.ps) {
									return; // ignore updates with no text
								}
								for (const [i, v] of taskValue.p.nt.ps.entries()) {
									if (!v.r) {
										continue;
									}

									if (!payload.items[updateIndex][taskId].p.nt?.ps?.[i]) {
										throw new Error(
											"Something is kinda wrong. I just added this check for the TypeScript compiler. Please forgive me.",
										);
									}

									payload.items[updateIndex][taskId].p.nt.ps[i].r =
										await thingsDecryptText(v.r);
								}
							})(),
						]);
					}
				}

				/**
				 * REWRITE THE BODY
				 * Note: we should ideally be deflating to save bandwidth.
				 */
				bytes = new TextEncoder().encode(JSON.stringify(payload));
				headers.delete("content-encoding"); // otherwise, the Things app crashes...
			}
		} catch (err) {
			console.error(`Error running interception: ${err}`);
			return new Response("ERROR2", {
				status: 500,
			});
		}

		return new Response(bytes, {
			headers: headers,
			status: resp.status,
		});
	},
);