electrobun 0.0.17 → 0.0.19-beta.1

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

@@ -1,181 +0,0 @@
-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

@@ -1,105 +0,0 @@
-import { zigRPC, type MenuItemConfig } from "../proc/zig";
-import electrobunEventEmitter from "../events/eventEmitter";
-import { VIEWS_FOLDER } from "./Paths";
-import { join } from "path";
-
-let nextTrayId = 1;
-const TrayMap = {};
-
-type ConstructorOptions = {
-  title?: string;
-  image?: string;
-  template?: boolean;
-  width?: number;
-  height?: number;
-};
-
-export class Tray {
-  id: number = nextTrayId++;
-
-  constructor({
-    title = "",
-    image = "",
-    template = true,
-    width = 16,
-    height = 16,
-  }: ConstructorOptions = {}) {
-    console.log("img", image);
-    console.log("img", this.resolveImagePath(image));
-    zigRPC.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) {
-    zigRPC.request.setTrayTitle({ id: this.id, title });
-  }
-
-  setImage(imgPath: string) {
-    zigRPC.request.setTrayImage({
-      id: this.id,
-      image: this.resolveImagePath(imgPath),
-    });
-  }
-
-  setMenu(menu: Array<MenuItemConfig>) {
-    const menuWithDefaults = menuConfigWithDefaults(menu);
-    zigRPC.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

@@ -1,387 +0,0 @@
-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";
-
-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 updateInfoUrl = join(channelBucketUrl, `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;
-
-    let currentTarPath = join(
-      appDataFolder,
-      "self-extraction",
-      `${currentHash}.tar`
-    );
-    const latestTarPath = join(
-      appDataFolder,
-      "self-extraction",
-      `${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 patchResponse = await fetch(
-          join(channelBucketUrl, `${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
-        await tar.x({
-          // gzip: false,
-          file: tmpPatchedTarFilePath,
-          cwd: untarDir,
-          filter: (path, stat) => {
-            if (path.endsWith("Resources/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 urlToLatestTarball = join(
-          channelBucketUrl,
-          `${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");
-      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();
-    // todo: tmp hardcode canary
-    return join(localInfo.bucketUrl, localInfo.channel);
-  },
-
-  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 {
-      localInfo = await Bun.file("../Resources/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 };