Merge pull request #53 from fullstackedorg/p2p

Peer-to-Peer Connectivity

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "editor-sample-demo"]
 	path = editor-sample-demo
 	url = https://github.com/fullstackedorg/editor-sample-demo.git
+[submodule "lib/go"]
+	path = lib/go
+	url = https://github.com/golang/go.git

editor/api/config/index.ts

@@ -1,13 +1,13 @@
 import rpc from "../../rpc";
-
+import git from "../git";
 import projects from "../projects";
-
-import { Project, GitAuths } from "../projects/types";
+import { Project, GitAuths, Connectivity } from "../projects/types";
 import { CONFIG_TYPE } from "./types";
 
 type DATA_TYPE = {
     [CONFIG_TYPE.PROJECTS]: Project[];
     [CONFIG_TYPE.GIT]: GitAuths;
+    [CONFIG_TYPE.CONNECTIVITY]: Connectivity;
 };
 
 export default {
@@ -17,17 +17,17 @@ export default {
         if (await rpc().fs.exists(configDir, { absolutePath: true })) return;
 
         await rpc().fs.mkdir(configDir, { absolutePath: true });
-        await projects.import(
+        const project = await projects.import(
             {
                 title: "Demo",
-                location: "fullstackedorg/editor-sample-demo"
-                // TODO: uncomment when webcontainer git CORS fixed
-                // gitRepository: {
-                //     url: "https://github.com/fullstackedorg/editor-sample-demo.git"
-                // }
+                location: "fullstackedorg/editor-sample-demo",
+                gitRepository: {
+                    url: "https://github.com/fullstackedorg/editor-sample-demo.git"
+                }
             },
             (await rpc().fs.readFile("Demo.zip")) as Uint8Array
         );
+        await git.init(project);
     },
     async load<T extends CONFIG_TYPE>(type: T): Promise<DATA_TYPE[T] | null> {
         const configDir = await rpc().directories.config();

editor/api/config/types.ts

@@ -1,4 +1,5 @@
 export enum CONFIG_TYPE {
     PROJECTS = "projects",
-    GIT = "git"
+    GIT = "git",
+    CONNECTIVITY = "connectivity"
 }

editor/api/connectivity/cryptoUtils.ts

@@ -0,0 +1,82 @@
+// for large strings, use this from https://stackoverflow.com/a/49124600
+export const toBase64 = (data: ArrayBufferLike) =>
+    btoa(
+        new Uint8Array(data).reduce(
+            (data, byte) => data + String.fromCharCode(byte),
+            ""
+        )
+    );
+
+export const fromBase64 = (data: string) =>
+    Uint8Array.from(atob(data), (c) => c.charCodeAt(null));
+
+export const generateHash = (byteLength: number) =>
+    toBase64(crypto.getRandomValues(new Uint8Array(byteLength)));
+
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+
+export async function encrypt(data: string, key: string) {
+    const salt = crypto.getRandomValues(new Uint8Array(16));
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const cryptoKey = await importKey(key);
+    const derivedKey = await deriveKey(cryptoKey, salt, "encrypt");
+    const encryptedContent = await crypto.subtle.encrypt(
+        {
+            name: "AES-GCM",
+            iv
+        },
+        derivedKey,
+        textEncoder.encode(data)
+    );
+
+    const encryptedContentArr = new Uint8Array(encryptedContent);
+    let buff = new Uint8Array(
+        salt.byteLength + iv.byteLength + encryptedContentArr.byteLength
+    );
+    buff.set(salt, 0);
+    buff.set(iv, salt.byteLength);
+    buff.set(encryptedContentArr, salt.byteLength + iv.byteLength);
+    return toBase64(buff);
+}
+
+export async function decrypt(base64: string, key: string) {
+    const encryptedDataBuff = fromBase64(base64);
+    const salt = encryptedDataBuff.slice(0, 16);
+    const iv = encryptedDataBuff.slice(16, 16 + 12);
+    const data = encryptedDataBuff.slice(16 + 12);
+    const cryptoKey = await importKey(key);
+    const derivedKey = await deriveKey(cryptoKey, salt, "decrypt");
+    const decryptedContent = await crypto.subtle.decrypt(
+        {
+            name: "AES-GCM",
+            iv
+        },
+        derivedKey,
+        data
+    );
+    return textDecoder.decode(decryptedContent);
+}
+
+const importKey = (key: string) =>
+    crypto.subtle.importKey("raw", textEncoder.encode(key), "PBKDF2", false, [
+        "deriveKey"
+    ]);
+
+const deriveKey = (
+    cryptoKey: CryptoKey,
+    salt: ArrayBufferLike,
+    keyUsage: "encrypt" | "decrypt"
+) =>
+    crypto.subtle.deriveKey(
+        {
+            name: "PBKDF2",
+            salt,
+            iterations: 250000,
+            hash: "SHA-256"
+        },
+        cryptoKey,
+        { name: "AES-GCM", length: 256 },
+        false,
+        [keyUsage]
+    );