@silverbulletmd/silverbullet 2.5.3 → 2.6.1

package/client/plugos/plug_compile.ts

@@ -7,24 +7,30 @@ import * as esbuild from "esbuild";
 import { bundleAssets } from "../asset_bundle/builder.ts";
 import type { Manifest } from "./types.ts";
 
-import { existsSync } from "node:fs";
-
-// Resolve the pre-built worker_runtime bundle path
-// When running from source: ../../dist/worker_runtime_bundle.js (from client/plugos/)
-// When bundled: ./worker_runtime_bundle.js (from dist/)
-const currentDir = import.meta.dirname;
-const bundledPath = path.join(currentDir, "worker_runtime_bundle.js");
-const sourcePath = path.join(currentDir, "../../dist/worker_runtime_bundle.js");
-const workerRuntimeBundlePath = existsSync(bundledPath)
-  ? bundledPath
-  : sourcePath;
+// 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) {
-    build.onResolve({ filter: /^worker-runtime$/ }, () => ({
-      path: workerRuntimeBundlePath,
-    }));
+    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"),
+      }));
+    }
   },
 };
 
@@ -50,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();
 
@@ -63,34 +69,32 @@ export async function compileManifest(
 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 "${
-        // 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
@@ -130,10 +134,10 @@ setupMessageListener(functionMapping, manifest, self.postMessage);
   let jsCode = await readFile(outFile, "utf-8");
   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;
 }
@@ -155,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;
   }
@@ -181,21 +183,21 @@ export function patchBundledJS(code: string): string {
 }
 
 export async function plugCompileCommand(
-  { dist, debug, info }: {
+  {
+    dist,
+    debug,
+    info,
+  }: {
     dist: string;
     debug: boolean;
     info: boolean;
   },
   ...manifestPaths: string[]
 ) {
-  await compileManifests(
-    manifestPaths,
-    dist,
-    {
-      debug: debug,
-      info: info,
-    },
-  );
-  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 due to TypeScript fetch type limitations
-    } 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/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,18 +75,20 @@ 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": {

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),
       );
     },
   };