@silverbulletmd/silverbullet 2.4.2 → 2.6.1

package/client/plugos/plug_compile.ts

@@ -3,23 +3,39 @@ import { readFile, writeFile, mkdtemp, rm, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as YAML from "js-yaml";
 
-import { denoPlugin, esbuild } from "../../build_deps.ts";
+import * as esbuild from "esbuild";
 import { bundleAssets } from "../asset_bundle/builder.ts";
 import type { Manifest } from "./types.ts";
-import { version } from "../../version.ts";
 
-// const workerRuntimeUrl = new URL(
-//   "../lib/plugos/worker_runtime.ts",
-//   import.meta.url,
-// );
-const workerRuntimeUrl =
-  `https://deno.land/x/silverbullet@${version}/client/plugos/worker_runtime.ts`;
+// When bundled by build_plug_compile.ts, this is replaced with the pre-bundled
+// worker runtime JS. When running from source, it's undefined and esbuild
+// resolves the .ts file directly (it handles TypeScript natively).
+declare const __EMBEDDED_WORKER_RUNTIME_JS__: string | undefined;
+
+const workerRuntimePlugin: esbuild.Plugin = {
+  name: "worker-runtime",
+  setup(build) {
+    if (typeof __EMBEDDED_WORKER_RUNTIME_JS__ !== "undefined") {
+      // Bundled CLI: serve pre-bundled JS from the embedded constant
+      build.onResolve({ filter: /^worker-runtime$/ }, () => ({
+        path: "worker-runtime",
+        namespace: "worker-runtime",
+      }));
+      build.onLoad({ filter: /.*/, namespace: "worker-runtime" }, () => ({
+        contents: __EMBEDDED_WORKER_RUNTIME_JS__,
+        loader: "js",
+      }));
+    } else {
+      // From source: point directly at the .ts file, esbuild handles it
+      build.onResolve({ filter: /^worker-runtime$/ }, () => ({
+        path: path.join(import.meta.dirname, "worker_runtime.ts"),
+      }));
+    }
+  },
+};
 
 export type CompileOptions = {
   debug?: boolean;
-  runtimeUrl?: string;
-  // path to config file
-  configPath?: string;
   // Print info on bundle size
   info?: boolean;
 };
@@ -40,7 +56,7 @@ export async function compileManifest(
   // Assets
   const assetsBundle = await bundleAssets(
     path.resolve(rootPath),
-    manifest.assets as string[] || [],
+    (manifest.assets as string[]) || [],
   );
   manifest.assets = assetsBundle.toJSON();
 
@@ -50,39 +66,35 @@ export async function compileManifest(
   }
 
   const jsFile = `
-import { setupMessageListener } from "${
-    options.runtimeUrl || workerRuntimeUrl
-  }";
+import { setupMessageListener } from "worker-runtime";
 
 // Imports
-${
-    Object.entries(manifest.functions).map(([funcName, def]) => {
-      if (!def.path) {
-        return "";
-      }
-      let [filePath, jsFunctionName] = def.path.split(":");
-      // Resolve path
-      filePath = path.join(rootPath, filePath);
-
-      return `import {${jsFunctionName} as ${funcName}} from "file://${
-        // Replacing \ with / for Windows
-        path.resolve(filePath).replaceAll(
-          "\\",
-          "\\\\",
-        )}";\n`;
-    }).join("")
-  }
+${Object.entries(manifest.functions)
+  .map(([funcName, def]) => {
+    if (!def.path) {
+      return "";
+    }
+    let [filePath, jsFunctionName] = def.path.split(":");
+    // Resolve path
+    filePath = path.join(rootPath, filePath);
+
+    return `import {${jsFunctionName} as ${funcName}} from "${
+      // Replacing \ with / for Windows
+      path.resolve(filePath).replaceAll("\\", "\\\\")
+    }";\n`;
+  })
+  .join("")}
 
 // Function mapping
 const functionMapping = {
-${
-    Object.entries(manifest.functions).map(([funcName, def]) => {
-      if (!def.path) {
-        return "";
-      }
-      return `  ${funcName}: ${funcName},\n`;
-    }).join("")
-  }
+${Object.entries(manifest.functions)
+  .map(([funcName, def]) => {
+    if (!def.path) {
+      return "";
+    }
+    return `  ${funcName}: ${funcName},\n`;
+  })
+  .join("")}
 };
 
 // Manifest
@@ -111,12 +123,7 @@ setupMessageListener(functionMapping, manifest, self.postMessage);
     outfile: outFile,
     metafile: options.info,
     treeShaking: true,
-    plugins: [
-      denoPlugin({
-        configPath: options.configPath &&
-          path.resolve(process.cwd(), options.configPath),
-      }),
-    ],
+    plugins: [workerRuntimePlugin],
   });
 
   if (options.info) {
@@ -125,12 +132,12 @@ setupMessageListener(functionMapping, manifest, self.postMessage);
   }
 
   let jsCode = await readFile(outFile, "utf-8");
-  jsCode = patchDenoLibJS(jsCode);
+  jsCode = patchBundledJS(jsCode);
   await writeFile(outFile, jsCode, "utf-8");
-  
+
   // Clean up temp directory
   await rm(tempDir, { recursive: true, force: true });
-  
+
   console.log(`Plug ${manifest.name} written to ${outFile}.`);
   return outFile;
 }
@@ -152,19 +159,17 @@ export async function compileManifests(
     await mkdir(dist, { recursive: true });
     const startTime = Date.now();
     // Build all plugs in parallel
-    await Promise.all(manifestFiles.map(async (plugManifestPath) => {
-      const manifestPath = plugManifestPath as string;
-      try {
-        await compileManifest(
-          manifestPath,
-          dist,
-          options,
-        );
-      } catch (e: any) {
-        console.error(`Error building ${manifestPath}:`, e.message);
-        throw e;
-      }
-    }));
+    await Promise.all(
+      manifestFiles.map(async (plugManifestPath) => {
+        const manifestPath = plugManifestPath as string;
+        try {
+          await compileManifest(manifestPath, dist, options);
+        } catch (e: any) {
+          console.error(`Error building ${manifestPath}:`, e.message);
+          throw e;
+        }
+      }),
+    );
     console.log(`Done building plugs in ${Date.now() - startTime}ms`);
     building = false;
   }
@@ -172,31 +177,27 @@ export async function compileManifests(
   await buildAll();
 }
 
-export function patchDenoLibJS(code: string): string {
-  // The Deno std lib has one occurence of a regex that Webkit JS doesn't (yet parse), we'll strip it because it's likely never invoked anyway, YOLO
+export function patchBundledJS(code: string): string {
+  // One bundled dependency has a lookbehind regex that WebKit can't parse; replace it with a no-op
   return code.replaceAll("/(?<=\\n)/", "/()/");
 }
 
 export async function plugCompileCommand(
-  { dist, debug, info, config, runtimeUrl }: {
+  {
+    dist,
+    debug,
+    info,
+  }: {
     dist: string;
     debug: boolean;
     info: boolean;
-    config?: string;
-    runtimeUrl?: string;
   },
   ...manifestPaths: string[]
 ) {
-  await compileManifests(
-    manifestPaths,
-    dist,
-    {
-      debug: debug,
-      info: info,
-      runtimeUrl,
-      configPath: config,
-    },
-  );
-  esbuild.stop();
+  await compileManifests(manifestPaths, dist, {
+    debug: debug,
+    info: info,
+  });
+  await esbuild.stop();
   process.exit(0);
 }

package/client/plugos/protocol.ts

@@ -3,38 +3,38 @@ import type { Manifest } from "@silverbulletmd/silverbullet/type/manifest";
 // Messages received from the worker
 export type ControllerMessage =
   | {
-    // Parsed manifest when worker is initialized
-    type: "manifest";
-    manifest: Manifest;
-  }
+      // Parsed manifest when worker is initialized
+      type: "manifest";
+      manifest: Manifest;
+    }
   | {
-    // Function invocation result
-    type: "invr";
-    id: number;
-    error?: string;
-    result?: any;
-  }
+      // Function invocation result
+      type: "invr";
+      id: number;
+      error?: string;
+      result?: any;
+    }
   | {
-    // Syscall
-    type: "sys";
-    id: number;
-    name: string;
-    args: any[];
-  };
+      // Syscall
+      type: "sys";
+      id: number;
+      name: string;
+      args: any[];
+    };
 
 // Messages received inside the worker
 export type WorkerMessage =
   | {
-    // Function invocation
-    type: "inv";
-    id: number;
-    name: string;
-    args: any[];
-  }
+      // Function invocation
+      type: "inv";
+      id: number;
+      name: string;
+      args: any[];
+    }
   | {
-    // Syscall result
-    type: "sysr";
-    id: number;
-    result?: any;
-    error?: any;
-  };
+      // Syscall result
+      type: "sysr";
+      id: number;
+      result?: any;
+      error?: any;
+    };

package/client/plugos/proxy_fetch.ts

@@ -35,12 +35,13 @@ export async function performLocalFetch(
 ): Promise<ProxyFetchResponse64> {
   const result = await fetch(
     url,
-    req && {
-      method: req.method,
-      headers: req.headers,
-      body: req.base64Body && base64Decode(req.base64Body),
-      // Casting  to "any" for now, since of weird Deno typing
-    } as any,
+    req &&
+      ({
+        method: req.method,
+        headers: req.headers,
+        body: req.base64Body && base64Decode(req.base64Body),
+        // Casting to any due to TypeScript fetch type limitations
+      } as any),
   );
   return {
     ok: result.ok,

package/client/plugos/sandboxes/web_worker_sandbox.ts

@@ -11,7 +11,7 @@ export function createWorkerSandboxFromLocalPath<HookT>(
       plug,
       new URL(
         name,
-        document.baseURI.slice(0, -1) + fsEndpoint + "/", // We're NOT striping trailing '/', this used to be `location.origin`
+        `${document.baseURI.slice(0, -1) + fsEndpoint}/`, // We're NOT striping trailing '/', this used to be `location.origin`
       ),
     );
 }

package/client/plugos/sandboxes/worker_sandbox.ts

@@ -22,8 +22,7 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
     readonly plug: Plug<HookT>,
     public workerUrl: URL,
     private workerOptions = {},
-  ) {
-  }
+  ) {}
 
   /**
    * Should only invoked lazily (either by invoke, or by a ManifestCache to load the manifest)
@@ -43,7 +42,7 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
     return race([
       // We're adding a timeout of 5s here to handle the case where a plug blows up during initialization
       timeout(5000).catch((_) =>
-        Promise.reject(new Error("Plug timed out during creation"))
+        Promise.reject(new Error("Plug timed out during creation")),
       ),
       new Promise((resolve) => {
         this.worker!.onmessage = (ev) => {
@@ -54,13 +53,13 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
 
             // Set assets in the plug
             this.plug.assets = new AssetBundle(
-              this.manifest?.assets ? this.manifest.assets as AssetJson : {},
+              this.manifest?.assets ? (this.manifest.assets as AssetJson) : {},
             );
 
             return resolve();
           }
 
-          this.onMessage(ev.data);
+          void this.onMessage(ev.data);
         };
       }),
     ]);
@@ -76,28 +75,29 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
         try {
           const result = await this.plug.syscall(data.name!, data.args!);
 
-          this.worker && this.worker!.postMessage({
-            type: "sysr",
-            id: data.id,
-            result: result,
-          } as WorkerMessage);
+          this.worker &&
+            this.worker!.postMessage({
+              type: "sysr",
+              id: data.id,
+              result: result,
+            } as WorkerMessage);
         } catch (e: any) {
           // console.error("Syscall fail", e);
-          this.worker && this.worker!.postMessage({
-            type: "sysr",
-            id: data.id,
-            error: e.message,
-          } as WorkerMessage);
+          this.worker &&
+            this.worker!.postMessage({
+              type: "sysr",
+              id: data.id,
+              error: e.message,
+            } as WorkerMessage);
         }
         break;
       case "invr": {
         const resultCbs = this.outstandingInvocations.get(data.id!);
         this.outstandingInvocations.delete(data.id!);
         if (data.error) {
-          resultCbs &&
-            resultCbs.reject(new Error(data.error));
+          resultCbs?.reject(new Error(data.error));
         } else {
-          resultCbs && resultCbs.resolve(data.result);
+          resultCbs?.resolve(data.result);
         }
         break;
       }

package/client/plugos/syscalls/asset.ts

@@ -4,9 +4,7 @@ import type { FileMeta } from "../../../plug-api/types/index.ts";
 export default function assetSyscalls(system: System<any>): SysCallMapping {
   return {
     "asset.readAsset": (_ctx, plugName: string, name: string): string => {
-      return system.loadedPlugs.get(plugName)!.assets!.readFileAsDataUrl(
-        name,
-      );
+      return system.loadedPlugs.get(plugName)!.assets!.readFileAsDataUrl(name);
     },
     "asset.listFiles": (_ctx, plugName: string): FileMeta[] => {
       const assets = system.loadedPlugs.get(plugName)!.assets!;

package/client/plugos/syscalls/code_widget.ts

@@ -12,9 +12,7 @@ export function codeWidgetSyscalls(
       body: string,
       pageName: string,
     ): Promise<CodeWidgetContent | null> => {
-      const langCallback = codeWidgetHook.codeWidgetCallbacks.get(
-        lang,
-      );
+      const langCallback = codeWidgetHook.codeWidgetCallbacks.get(lang);
       if (!langCallback) {
         throw new Error(`Code widget ${lang} not found`);
       }

package/client/plugos/syscalls/config.ts

@@ -23,11 +23,7 @@ export function configSyscalls(config: Config): SysCallMapping {
       keyOrValues = await luaValueToJS(keyOrValues, LuaStackFrame.lostFrame);
       config.set(keyOrValues as any, value);
     },
-    "config.insert": (
-      _ctx,
-      key: string | string[],
-      value: any,
-    ) => {
+    "config.insert": (_ctx, key: string | string[], value: any) => {
       config.insert(key, value);
     },
     "config.has": (_ctx, path: string) => {

package/client/plugos/syscalls/datastore.ts

@@ -61,7 +61,7 @@ export function dataStoreReadSyscalls(
         }
       }
       return (await queryLua<any>(ds.kv, prefix, query, env, sf)).map((item) =>
-        luaValueToJS(item, sf)
+        luaValueToJS(item, sf),
       );
     },
   };