electrobun 0.0.19-beta.7 → 0.0.19-beta.71

package/dist/api/bun/core/Socket.ts

@@ -0,0 +1,181 @@
+import type { ServerWebSocket } from "bun";
+import { BrowserView } from "./BrowserView";
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+
+function base64ToUint8Array(base64: string) {
+  {
+    return new Uint8Array(
+      atob(base64)
+        .split("")
+        .map((char) => char.charCodeAt(0))
+    );
+  }
+}
+
+// Encrypt function
+function encrypt(secretKey: Uint8Array, text: string) {
+  const iv = new Uint8Array(randomBytes(12)); // IV for AES-GCM
+  const cipher = createCipheriv("aes-256-gcm", secretKey, iv);
+  const encrypted = Buffer.concat([
+    new Uint8Array(cipher.update(text, "utf8")),
+    new Uint8Array(cipher.final()),
+  ]).toString("base64");
+  const tag = cipher.getAuthTag().toString("base64");
+  return { encrypted, iv: Buffer.from(iv).toString("base64"), tag };
+}
+
+// Decrypt function
+function decrypt(
+  secretKey: Uint8Array,
+  encryptedData: Uint8Array,
+  iv: Uint8Array,
+  tag: Uint8Array
+) {
+  const decipher = createDecipheriv("aes-256-gcm", secretKey, iv);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([
+    new Uint8Array(decipher.update(encryptedData)),
+    new Uint8Array(decipher.final()),
+  ]);
+  return decrypted.toString("utf8");
+}
+
+export const socketMap: {
+  [webviewId: string]: {
+    socket: null | ServerWebSocket<unknown>;
+    queue: string[];
+  };
+} = {};
+
+const startRPCServer = () => {
+  const startPort = 50000;
+  const endPort = 65535;
+  const payloadLimit = 1024 * 1024 * 500; // 500MB
+  let port = startPort;
+  let server = null;
+
+  while (port <= endPort) {
+    try {
+      server = Bun.serve<{ webviewId: number }>({
+        port,
+        fetch(req, server) {
+          const url = new URL(req.url);
+          //   const token = new URL(req.url).searchParams.get("token");
+          //   if (token !== AUTH_TOKEN)
+          //     return new Response("Unauthorized", { status: 401 });
+          //   console.log("fetch!!", url.pathname);
+          if (url.pathname === "/socket") {
+            const webviewIdString = url.searchParams.get("webviewId");
+            if (!webviewIdString) {
+              return new Response("Missing webviewId", { status: 400 });
+            }
+            const webviewId = parseInt(webviewIdString, 10);
+            const success = server.upgrade(req, { data: { webviewId } });
+            return success
+              ? undefined
+              : new Response("Upgrade failed", { status: 500 });
+          }
+
+          console.log("unhandled RPC Server request", req.url);
+        },
+        websocket: {
+          idleTimeout: 960,
+          // 500MB max payload should be plenty
+          maxPayloadLength: payloadLimit,
+          // Anything beyond the backpressure limit will be dropped
+          backpressureLimit: payloadLimit * 2,
+          open(ws) {
+            const { webviewId } = ws.data;
+
+            if (!socketMap[webviewId]) {
+              socketMap[webviewId] = { socket: ws, queue: [] };
+            } else {
+              socketMap[webviewId].socket = ws;
+            }
+          },
+          close(ws, code, reason) {
+            const { webviewId } = ws.data;
+            console.log("Closed:", webviewId, code, reason);
+            socketMap[webviewId].socket = null;
+          },
+
+          message(ws, message) {
+            const { webviewId } = ws.data;
+            const browserView = BrowserView.getById(webviewId);
+
+            if (browserView.rpcHandler) {
+              if (typeof message === "string") {
+                try {
+                  const encryptedPacket = JSON.parse(message);
+                  const decrypted = decrypt(
+                    browserView.secretKey,
+                    base64ToUint8Array(encryptedPacket.encryptedData),
+                    base64ToUint8Array(encryptedPacket.iv),
+                    base64ToUint8Array(encryptedPacket.tag)
+                  );
+
+                  // Note: At this point the secretKey for the webview id would
+                  // have had to match the encrypted packet data, so we can trust
+                  // that this message can be passed to this browserview's rpc
+                  // methods.
+                  browserView.rpcHandler(JSON.parse(decrypted));
+                } catch (error) {
+                  console.log("Error handling message:", error);
+                }
+              } else if (message instanceof ArrayBuffer) {
+                console.log("TODO: Received ArrayBuffer message:", message);
+              }
+            }
+          },
+        },
+      });
+
+      break;
+    } catch (error: any) {
+      if (error.code === "EADDRINUSE") {
+        console.log(`Port ${port} in use, trying next port...`);
+        port++;
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  return { rpcServer: server, rpcPort: port };
+};
+
+export const { rpcServer, rpcPort } = startRPCServer();
+
+// Will return true if message was sent over websocket
+// false if it was not (caller should fallback to postMessage/evaluateJS rpc)
+export const sendMessageToWebviewViaSocket = (
+  webviewId: number,
+  message: any
+): boolean => {
+  const rpc = socketMap[webviewId];
+  const browserView = BrowserView.getById(webviewId);
+
+  if (rpc?.socket?.readyState === WebSocket.OPEN) {
+    try {
+      const unencryptedString = JSON.stringify(message);
+      const encrypted = encrypt(browserView.secretKey, unencryptedString);
+
+      const encryptedPacket = {
+        encryptedData: encrypted.encrypted,
+        iv: encrypted.iv,
+        tag: encrypted.tag,
+      };
+
+      const encryptedPacketString = JSON.stringify(encryptedPacket);
+
+      rpc.socket.send(encryptedPacketString);
+      return true;
+    } catch (error) {
+      console.error("Error sending message to webview via socket:", error);
+    }
+  }
+
+  return false;
+};
+
+console.log("Server started at", rpcServer?.url.origin);

package/dist/api/bun/core/Tray.ts

@@ -0,0 +1,107 @@
+import { ffi, type MenuItemConfig } from "../proc/native";
+import electrobunEventEmitter from "../events/eventEmitter";
+import { VIEWS_FOLDER } from "./Paths";
+import { join } from "path";
+import {FFIType} from 'bun:ffi';
+
+let nextTrayId = 1;
+const TrayMap = {};
+
+type ConstructorOptions = {
+  title?: string;
+  image?: string;
+  template?: boolean;
+  width?: number;
+  height?: number;
+};
+
+export class Tray {
+  id: number = nextTrayId++;
+  ptr: FFIType.ptr;
+
+  constructor({
+    title = "",
+    image = "",
+    template = true,
+    width = 16,
+    height = 16,
+  }: ConstructorOptions = {}) {
+    console.log("img", image);
+    console.log("img", this.resolveImagePath(image));
+    this.ptr = ffi.request.createTray({
+      id: this.id,
+      title,
+      image: this.resolveImagePath(image),
+      template,
+      width,
+      height,
+    });
+
+    TrayMap[this.id] = this;
+  }
+
+  resolveImagePath(imgPath: string) {
+    if (imgPath.startsWith("views://")) {
+      return join(VIEWS_FOLDER, imgPath.replace("views://", ""));
+    } else {
+      // can specify any file path here
+      return imgPath;
+    }
+  }
+
+  setTitle(title: string) {
+    ffi.request.setTrayTitle({ id: this.id, title });
+  }
+
+  setImage(imgPath: string) {
+    ffi.request.setTrayImage({
+      id: this.id,
+      image: this.resolveImagePath(imgPath),
+    });
+  }
+
+  setMenu(menu: Array<MenuItemConfig>) {
+    const menuWithDefaults = menuConfigWithDefaults(menu);
+    ffi.request.setTrayMenu({
+      id: this.id,
+      menuConfig: JSON.stringify(menuWithDefaults),
+    });
+  }
+
+  on(name: "tray-clicked", handler) {
+    const specificName = `${name}-${this.id}`;
+    electrobunEventEmitter.on(specificName, handler);
+  }
+
+  static getById(id: number) {
+    return TrayMap[id];
+  }
+
+  static getAll() {
+    return Object.values(TrayMap);
+  }
+}
+
+const menuConfigWithDefaults = (
+  menu: Array<MenuItemConfig>
+): Array<MenuItemConfig> => {
+  return menu.map((item) => {
+    if (item.type === "divider" || item.type === "separator") {
+      return { type: "divider" };
+    } else {
+      return {
+        label: item.label || "",
+        type: item.type || "normal",
+        action: item.action || "",
+        // default enabled to true unless explicitly set to false
+        enabled: item.enabled === false ? false : true,
+        checked: Boolean(item.checked),
+        hidden: Boolean(item.hidden),
+        tooltip: item.tooltip || undefined,
+        ...(item.submenu
+          ? { submenu: menuConfigWithDefaults(item.submenu) }
+          : {}),
+      };
+    }
+  });
+};

package/dist/api/bun/core/Updater.ts

@@ -0,0 +1,395 @@
+import { join, dirname, resolve } from "path";
+import { homedir } from "os";
+import { renameSync, unlinkSync, mkdirSync, rmdirSync, statSync } from "fs";
+import tar from "tar";
+import { ZstdInit } from "@oneidentity/zstd-js/wasm";
+import { OS as currentOS, ARCH as currentArch } from '../../shared/platform';
+
+const appSupportDir = join(homedir(), "Library", "Application Support");
+
+// todo (yoav): share type with cli
+let localInfo: {
+  version: string;
+  hash: string;
+  bucketUrl: string;
+  channel: string;
+  name: string;
+  identifier: string;
+};
+
+let updateInfo: {
+  version: string;
+  hash: string;
+  updateAvailable: boolean;
+  updateReady: boolean;
+  error: string;
+};
+
+const Updater = {
+  // workaround for some weird state stuff in this old version of bun
+  // todo: revisit after updating to the latest bun
+  updateInfo: () => {
+    return updateInfo;
+  },
+  // todo: allow switching channels, by default will check the current channel
+  checkForUpdate: async () => {
+    const localInfo = await Updater.getLocallocalInfo();
+
+    if (localInfo.channel === "dev") {
+      return {
+        version: localInfo.version,
+        hash: localInfo.hash,
+        updateAvailable: false,
+        updateReady: false,
+        error: "",
+      };
+    }
+
+    const channelBucketUrl = await Updater.channelBucketUrl();
+    const cacheBuster = Math.random().toString(36).substring(7);
+    const platformFolder = `${localInfo.channel}-${currentOS}-${currentArch}`;
+    const updateInfoUrl = join(localInfo.bucketUrl, platformFolder, `update.json?${cacheBuster}`);
+
+    try {
+      const updateInfoResponse = await fetch(updateInfoUrl);
+
+      if (updateInfoResponse.ok) {
+        // todo: this seems brittle
+        updateInfo = await updateInfoResponse.json();
+
+        if (updateInfo.hash !== localInfo.hash) {
+          updateInfo.updateAvailable = true;
+        }
+      } else {
+        return {
+          version: "",
+          hash: "",
+          updateAvailable: false,
+          updateReady: false,
+          error: `Failed to fetch update info from ${updateInfoUrl}`,
+        };
+      }
+    } catch (error) {
+      return {
+        version: "",
+        hash: "",
+        updateAvailable: false,
+        updateReady: false,
+        error: `Failed to fetch update info from ${updateInfoUrl}`,
+      };
+    }
+
+    return updateInfo;
+  },
+
+  downloadUpdate: async () => {
+    const appDataFolder = await Updater.appDataFolder();
+    const channelBucketUrl = await Updater.channelBucketUrl();
+    const appFileName = localInfo.name;
+
+    let currentHash = (await Updater.getLocallocalInfo()).hash;
+    let latestHash = (await Updater.checkForUpdate()).hash;
+
+    const extractionFolder = join(appDataFolder, "self-extraction");
+    if (!(await Bun.file(extractionFolder).exists())) {
+      mkdirSync(extractionFolder, { recursive: true });
+    }
+
+    let currentTarPath = join(extractionFolder, `${currentHash}.tar`);
+    const latestTarPath = join(extractionFolder, `${latestHash}.tar`);
+
+    const seenHashes = [];
+
+    // todo (yoav): add a check to the while loop that checks for a hash we've seen before
+    // so that update loops that are cyclical can be broken
+    if (!(await Bun.file(latestTarPath).exists())) {
+      while (currentHash !== latestHash) {
+        seenHashes.push(currentHash);
+        const currentTar = Bun.file(currentTarPath);
+
+        if (!(await currentTar.exists())) {
+          // tar file of the current version not found
+          // so we can't patch it. We need the byte-for-byte tar file
+          // so break out and download the full version
+          break;
+        }
+
+        // check if there's a patch file for it
+        const platformFolder = `${localInfo.channel}-${currentOS}-${currentArch}`;
+        const patchResponse = await fetch(
+          join(localInfo.bucketUrl, platformFolder, `${currentHash}.patch`)
+        );
+
+        if (!patchResponse.ok) {
+          // patch not found
+          break;
+        }
+
+        // The patch file's name is the hash of the "from" version
+        const patchFilePath = join(
+          appDataFolder,
+          "self-extraction",
+          `${currentHash}.patch`
+        );
+        await Bun.write(patchFilePath, await patchResponse.arrayBuffer());
+        // patch it to a tmp name
+        const tmpPatchedTarFilePath = join(
+          appDataFolder,
+          "self-extraction",
+          `from-${currentHash}.tar`
+        );
+
+        // Note: cwd should be Contents/MacOS/ where the binaries are in the amc app bundle
+        try {
+          Bun.spawnSync([
+            "bspatch",
+            currentTarPath,
+            tmpPatchedTarFilePath,
+            patchFilePath,
+          ]);
+        } catch (error) {
+          break;
+        }
+
+        let versionSubpath = "";
+        const untarDir = join(appDataFolder, "self-extraction", "tmpuntar");
+        mkdirSync(untarDir, { recursive: true });
+
+        // extract just the version.json from the patched tar file so we can see what hash it is now
+        const resourcesDir = 'Resources'; // Always use capitalized Resources
+        await tar.x({
+          // gzip: false,
+          file: tmpPatchedTarFilePath,
+          cwd: untarDir,
+          filter: (path, stat) => {
+            if (path.endsWith(`${resourcesDir}/version.json`)) {
+              versionSubpath = path;
+              return true;
+            } else {
+              return false;
+            }
+          },
+        });
+
+        const currentVersionJson = await Bun.file(
+          join(untarDir, versionSubpath)
+        ).json();
+        const nextHash = currentVersionJson.hash;
+
+        if (seenHashes.includes(nextHash)) {
+          console.log("Warning: cyclical update detected");
+          break;
+        }
+
+        seenHashes.push(nextHash);
+
+        if (!nextHash) {
+          break;
+        }
+        // Sync the patched tar file to the new hash
+        const updatedTarPath = join(
+          appDataFolder,
+          "self-extraction",
+          `${nextHash}.tar`
+        );
+        renameSync(tmpPatchedTarFilePath, updatedTarPath);
+
+        // delete the old tar file
+        unlinkSync(currentTarPath);
+        unlinkSync(patchFilePath);
+        rmdirSync(untarDir, { recursive: true });
+
+        currentHash = nextHash;
+        currentTarPath = join(
+          appDataFolder,
+          "self-extraction",
+          `${currentHash}.tar`
+        );
+        // loop through applying patches until we reach the latest version
+        // if we get stuck then exit and just download the full latest version
+      }
+
+      // If we weren't able to apply patches to the current version,
+      // then just download it and unpack it
+      if (currentHash !== latestHash) {
+        const cacheBuster = Math.random().toString(36).substring(7);
+        const platformFolder = `${localInfo.channel}-${currentOS}-${currentArch}`;
+        const urlToLatestTarball = join(
+          localInfo.bucketUrl,
+          platformFolder,
+          `${appFileName}.app.tar.zst`
+        );
+        const prevVersionCompressedTarballPath = join(
+          appDataFolder,
+          "self-extraction",
+          "latest.tar.zst"
+        );
+        const response = await fetch(urlToLatestTarball + `?${cacheBuster}`);
+
+        if (response.ok && response.body) {
+          const reader = response.body.getReader();
+
+          const writer = Bun.file(prevVersionCompressedTarballPath).writer();
+
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            await writer.write(value);
+          }
+          await writer.flush();
+          writer.end();
+        } else {
+          console.log("latest version not found at: ", urlToLatestTarball);
+        }
+
+        await ZstdInit().then(async ({ ZstdSimple }) => {
+          const data = new Uint8Array(
+            await Bun.file(prevVersionCompressedTarballPath).arrayBuffer()
+          );
+          const uncompressedData = ZstdSimple.decompress(data);
+
+          await Bun.write(latestTarPath, uncompressedData);
+        });
+
+        unlinkSync(prevVersionCompressedTarballPath);
+        try {
+          unlinkSync(currentTarPath);
+        } catch (error) {
+          // Note: ignore the error. it may have already been deleted by the patching process
+          // if the patching process only got halfway
+        }
+      }
+    }
+
+    // Note: Bun.file().exists() caches the result, so we nee d an new instance of Bun.file() here
+    // to check again
+    if (await Bun.file(latestTarPath).exists()) {
+      // download patch for this version, apply it.
+      // check for patch from that tar and apply it, until it matches the latest version
+      // as a fallback it should just download and unpack the latest version
+      updateInfo.updateReady = true;
+    } else {
+      updateInfo.error = "Failed to download latest version";
+    }
+  },
+
+  // todo (yoav): this should emit an event so app can cleanup or block the restart
+  // todo (yoav): rename this to quitAndApplyUpdate or something
+  applyUpdate: async () => {
+    if (updateInfo?.updateReady) {
+      const appDataFolder = await Updater.appDataFolder();
+      const extractionFolder = join(appDataFolder, "self-extraction");
+      if (!(await Bun.file(extractionFolder).exists())) {
+        mkdirSync(extractionFolder, { recursive: true });
+      }
+
+      let latestHash = (await Updater.checkForUpdate()).hash;
+      const latestTarPath = join(extractionFolder, `${latestHash}.tar`);
+
+      let appBundleSubpath: string = "";
+
+      if (await Bun.file(latestTarPath).exists()) {
+        await tar.x({
+          // gzip: false,
+          file: latestTarPath,
+          cwd: extractionFolder,
+          onentry: (entry) => {
+            // find the first .app bundle in the tarball
+            // Some apps may have nested .app bundles
+            if (!appBundleSubpath && entry.path.endsWith(".app/")) {
+              appBundleSubpath = entry.path;
+            }
+          },
+        });
+
+        if (!appBundleSubpath) {
+          console.error("Failed to find app bundle in tarball");
+          return;
+        }
+
+        // Note: resolve here removes the extra trailing / that the tar file adds
+        const newAppBundlePath = resolve(
+          join(extractionFolder, appBundleSubpath)
+        );
+        // Note: dirname(process.execPath) is the path to the running app bundle's
+        // Contents/MacOS directory
+        const runningAppBundlePath = resolve(
+          dirname(process.execPath),
+          "..",
+          ".."
+        );
+        const backupAppBundlePath = join(extractionFolder, "backup.app");
+
+        try {
+          // const backupState = statSync(backupAppBundlePath);
+          if (statSync(backupAppBundlePath, { throwIfNoEntry: false })) {
+            rmdirSync(backupAppBundlePath, { recursive: true });
+          } else {
+            console.log("backupAppBundlePath does not exist");
+          }
+          renameSync(runningAppBundlePath, backupAppBundlePath);
+          renameSync(newAppBundlePath, runningAppBundlePath);
+        } catch (error) {
+          console.error("Failed to replace app with new version", error);
+          return;
+        }
+
+        await Bun.spawn(["open", runningAppBundlePath]);
+        process.exit(0);
+      }
+    }
+  },
+
+  channelBucketUrl: async () => {
+    await Updater.getLocallocalInfo();
+    const platformFolder = `${localInfo.channel}-${currentOS}-${currentArch}`;
+    return join(localInfo.bucketUrl, platformFolder);
+  },
+
+  appDataFolder: async () => {
+    await Updater.getLocallocalInfo();
+    const appDataFolder = join(
+      appSupportDir,
+      localInfo.identifier,
+      localInfo.name
+    );
+
+    return appDataFolder;
+  },
+
+  // TODO: consider moving this from "Updater.localInfo" to "BuildVars"
+  localInfo: {
+    version: async () => {
+      return (await Updater.getLocallocalInfo()).version;
+    },
+    hash: async () => {
+      return (await Updater.getLocallocalInfo()).hash;
+    },
+    channel: async () => {
+      return (await Updater.getLocallocalInfo()).channel;
+    },
+    bucketUrl: async () => {
+      return (await Updater.getLocallocalInfo()).bucketUrl;
+    },
+  },
+
+  getLocallocalInfo: async () => {
+    if (localInfo) {
+      return localInfo;
+    }
+
+    try {
+      const resourcesDir = 'Resources'; // Always use capitalized Resources
+      localInfo = await Bun.file(`../${resourcesDir}/version.json`).json();
+      return localInfo;
+    } catch (error) {
+      // Handle the error
+      console.error("Failed to read version.json", error);
+
+      // Then rethrow so the app crashes
+      throw error;
+    }
+  },
+};
+
+export { Updater };