@silverbulletmd/silverbullet 2.10.0 → 2.12.0

package/client/plugos/hooks/slash_command.ts

@@ -14,6 +14,7 @@ import type {
   SlashCompletionOption,
   SlashCompletions,
 } from "@silverbulletmd/silverbullet/type/client";
+import { matchesNodeContexts } from "../../lib/node_contexts.ts";
 
 const slashCommandRegexp = /([^\w:]|^)\/[\w#-]*/;
 
@@ -46,7 +47,6 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
         });
       }
     }
-    // Iterate over script defined slash commands
     for (const command of Object.values(
       this.client.config.get<Record<string, SlashCommand>>("slashCommands", {}),
     )) {
@@ -70,28 +70,15 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
     // the user is referring to preceding text, not what comes after.
     const currentNode = syntaxTree(ctx.state).resolveInner(ctx.pos, -1);
     if (
-      currentNode.type.name === "CommentBlock" ||
+      currentNode.type.name === "CommentMarkerBlock" ||
       currentNode.type.name === "Link"
     ) {
       return null;
     }
 
-    // Check if the slash command is available in the current context
     const parentNodes = this.client.extractParentNodes(ctx.state, currentNode);
     for (const def of this.slashCommands) {
-      if (
-        def.onlyContexts &&
-        !def.onlyContexts.some((context) =>
-          parentNodes.some((node) => node.startsWith(context)),
-        )
-      ) {
-        continue;
-      }
-      if (
-        def.exceptContexts?.some((context) =>
-          parentNodes.some((node) => node.startsWith(context)),
-        )
-      ) {
+      if (!matchesNodeContexts(def, parentNodes)) {
         continue;
       }
       options.push({
@@ -99,7 +86,6 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
         detail: def.description,
         boost: def.priority,
         apply: () => {
-          // Delete slash command part
           this.client.editorView.dispatch({
             changes: {
               from: prefix!.from + prefixText.indexOf("/"),
@@ -107,7 +93,6 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
               insert: "",
             },
           });
-          // Replace with whatever the completion is
           safeRun(async () => {
             await def.run!();
             this.client.focus();
@@ -126,7 +111,6 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
           detail: slashCompletion.detail,
           boost: slashCompletion.order && -slashCompletion.order,
           apply: () => {
-            // Delete slash command part
             this.client.editorView.dispatch({
               changes: {
                 from: prefix!.from + prefixText.indexOf("/"),
@@ -134,7 +118,6 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
                 insert: "",
               },
             });
-            // Replace with whatever the completion is
             safeRun(async () => {
               await this.client.clientSystem.system.invokeFunction(
                 slashCompletion.invoke,

package/client/plugos/hooks/syscall.ts

@@ -13,7 +13,6 @@ export class SyscallHook implements Hook<SyscallHookT> {
   }
 
   registerSyscalls(system: System<SyscallHookT>) {
-    // Register syscalls from all loaded plugs
     for (const plug of system.loadedPlugs.values()) {
       const syscalls: SysCallMapping = {};
 
@@ -30,7 +29,6 @@ export class SyscallHook implements Hook<SyscallHookT> {
             ? syscallDefinition
             : syscallDefinition.name;
 
-        // Add the syscall to our mapping
         const callback = (ctx: SyscallContext, ...args: any[]) =>
           system.syscall(ctx, "system.invokeFunction", [
             `${plug.manifest!.name}.${name}`,
@@ -46,7 +44,6 @@ export class SyscallHook implements Hook<SyscallHookT> {
           };
         }
 
-        // Register the syscalls with no required permissions
         system.registerSyscalls([], syscalls);
       }
     }
@@ -68,7 +65,6 @@ export class SyscallHook implements Hook<SyscallHookT> {
         continue;
       }
 
-      // Validate syscall name format (should be namespaced)
       if (!syscallName.includes(".")) {
         errors.push(
           `Function ${name} has invalid syscall name "${syscallName}" - must be in format "namespace.name"`,

package/client/plugos/manifest_cache.ts

@@ -2,13 +2,13 @@ import type { KvPrimitives } from "../data/kv_primitives.ts";
 import type { Plug } from "./plug.ts";
 import type { Manifest } from "./types.ts";
 
-export interface ManifestCache<T> {
+export type ManifestCache<T> = {
   getManifest(
     plug: Plug<T>,
     cacheKey: string,
     cacheHash: number,
   ): Promise<Manifest<T>>;
-}
+};
 
 export class KVPrimitivesManifestCache<T> implements ManifestCache<T> {
   constructor(
@@ -23,7 +23,6 @@ export class KVPrimitivesManifestCache<T> implements ManifestCache<T> {
   ): Promise<Manifest<T>> {
     const [cached] = await this.kv.batchGet([[this.manifestPrefix, cacheKey]]);
     if (cached && cached.hash === cacheHash) {
-      // console.log("Using KV cached manifest for", plug.name);
       return cached.manifest;
     }
     await plug.sandbox.init();
@@ -41,34 +40,3 @@ export class KVPrimitivesManifestCache<T> implements ManifestCache<T> {
     return manifest;
   }
 }
-
-export class InMemoryManifestCache<T> implements ManifestCache<T> {
-  private cache = new Map<
-    string,
-    {
-      manifest: Manifest<T>;
-      hash: number;
-    }
-  >();
-
-  async getManifest(
-    plug: Plug<T>,
-    cacheKey: string,
-    cacheHash: number,
-  ): Promise<Manifest<T>> {
-    const cached = this.cache.get(cacheKey);
-    if (cached && cached.hash === cacheHash) {
-      // console.log("Using memory cached manifest for", plug.name);
-      return cached.manifest;
-    }
-    await plug.sandbox.init();
-    const manifest = plug.sandbox.manifest!;
-
-    // Deliverately removing the assets from the manifest to preserve space, will be re-added upon load of actual worker
-    this.cache.set(cacheKey, {
-      manifest: { ...manifest, assets: undefined },
-      hash: cacheHash,
-    });
-    return manifest;
-  }
-}

package/client/plugos/plug.ts

@@ -31,7 +31,6 @@ export class Plug<HookT> {
     const plug = new Plug(system, sandboxFactory);
     plug.path = path;
 
-    // Retrieve the manifest, which may either come from a cache or be loaded from the worker
     plug.manifest = await system.options.manifestCache!.getManifest(
       plug,
       path,
@@ -62,14 +61,12 @@ export class Plug<HookT> {
 
   // Invoke a function
   async invoke(name: string, args: any[]): Promise<any> {
-    // Before we access the manifest
     const funDef = this.manifest!.functions[name];
     if (!funDef) {
       throw new Error(`Function ${name} not found in manifest`);
     }
     const sandbox = this.sandbox!;
     if (funDef.redirect) {
-      // Function redirect, look up
       let plug: Plug<HookT> | undefined = this;
       if (funDef.redirect.indexOf(".") !== -1) {
         const [plugName, functionName] = funDef.redirect.split(".");

package/client/plugos/plug_compile.ts

@@ -24,7 +24,6 @@ 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",
@@ -34,7 +33,6 @@ const workerRuntimePlugin: esbuild.Plugin = {
         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"),
       }));
@@ -70,14 +68,12 @@ export async function compileManifest(
     delete manifest.build;
   }
 
-  // Assets
   const assetsBundle = await bundleAssets(
     path.resolve(rootPath),
     (manifest.assets as string[]) || [],
   );
   manifest.assets = assetsBundle.toJSON();
 
-  // Normalize the edge case of a plug with no functions
   if (!manifest.functions) {
     manifest.functions = {};
   }
@@ -92,13 +88,11 @@ ${Object.entries(manifest.functions)
       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`;
+    return `import {${jsFunctionName} as ${funcName}} from "${path
+      .resolve(filePath)
+      .replaceAll("\\", "\\\\")}";\n`;
   })
   .join("")}
 
@@ -122,8 +116,6 @@ export const plug = {manifest, functionMapping};
 setupMessageListener(functionMapping, manifest, self.postMessage);
 `;
 
-  // console.log("Code:", jsFile);
-
   const tempDir = await mkdtemp(path.join(tmpdir(), "plug-compile-"));
   const inFile = path.join(tempDir, "input.js");
   const outFile = `${destPath}/${manifest.name}.plug.js`;
@@ -152,7 +144,6 @@ setupMessageListener(functionMapping, manifest, self.postMessage);
   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}.`);
@@ -175,7 +166,6 @@ export async function compileManifests(
     building = true;
     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;

package/client/plugos/sandboxes/sandbox.ts

@@ -3,7 +3,7 @@ import type { Manifest } from "../types.ts";
 
 export type SandboxFactory<HookT> = (plug: Plug<HookT>) => Sandbox<HookT>;
 
-export interface Sandbox<HookT> {
+export type Sandbox<HookT> = {
   manifest?: Manifest<HookT>;
 
   init(): Promise<void>;
@@ -11,4 +11,4 @@ export interface Sandbox<HookT> {
   invoke(name: string, args: any[]): Promise<any>;
 
   stop(): void;
-}
+};

package/client/plugos/sandboxes/worker_sandbox.ts

@@ -7,7 +7,6 @@ import { race, timeout } from "@silverbulletmd/silverbullet/lib/async";
 import { fsEndpoint } from "../../spaces/constants.ts";
 
 /**
- * Represents a "safe" execution environment for plug code
  * Effectively this wraps a web worker, the reason to have this split from Plugs is to allow plugs to manage multiple sandboxes, e.g. for performance in the future
  */
 export class WorkerSandbox<HookT> implements Sandbox<HookT> {
@@ -25,7 +24,6 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
     private workerOptions = {},
   ) {}
 
-  /** Factory producing a WorkerSandbox for a plug file at a local space path. */
   static forPath<HookT>(path: string): SandboxFactory<HookT> {
     return (plug) =>
       new WorkerSandbox(
@@ -40,7 +38,6 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
   init(): Promise<void> {
     console.log("Booting up worker from", this.workerUrl.pathname);
     if (this.worker) {
-      // Race condition
       console.warn("Double init of sandbox, ignoring");
       return Promise.resolve();
     }
@@ -54,14 +51,12 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
       timeout(5000).catch((_) =>
         Promise.reject(new Error("Plug timed out during creation")),
       ),
-      new Promise((resolve) => {
+      new Promise<void>((resolve) => {
         this.worker!.onmessage = (ev) => {
           if (ev.data.type === "manifest") {
             this.manifest = ev.data.manifest;
-            // Set manifest in the plug
             this.plug.manifest = this.manifest!;
 
-            // Set assets in the plug
             this.plug.assets = new AssetBundle(
               this.manifest?.assets ? (this.manifest.assets as AssetJson) : {},
             );
@@ -72,7 +67,15 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
           void this.onMessage(ev.data);
         };
       }),
-    ]);
+    ]).catch((e) => {
+      // A worker that failed to come up must not linger: its script fetch may
+      // still be in flight (e.g. on a slow link), and a late boot would
+      // resolve into a sandbox the system already gave up on. Terminating it
+      // also lets a retry start from a clean slate.
+      this.worker?.terminate();
+      this.worker = undefined;
+      throw e;
+    });
   }
 
   async onMessage(data: ControllerMessage) {
@@ -92,7 +95,6 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
               result: result,
             } as WorkerMessage);
         } catch (e: any) {
-          // console.error("Syscall fail", e);
           this.worker &&
             this.worker!.postMessage({
               type: "sysr",
@@ -118,7 +120,6 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
 
   async invoke(name: string, args: any[]): Promise<any> {
     if (!this.worker) {
-      // Lazy initialization
       await this.init();
     }
     this.reqId++;
@@ -138,5 +139,14 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
       this.worker.terminate();
       this.worker = undefined;
     }
+    // A terminated worker will never post the `invr` that would otherwise
+    // settle these.
+    if (this.outstandingInvocations.size > 0) {
+      const error = new Error("Plug sandbox stopped");
+      for (const { reject } of this.outstandingInvocations.values()) {
+        reject(error);
+      }
+      this.outstandingInvocations.clear();
+    }
   }
 }

package/client/plugos/syscalls/capture.ts

@@ -0,0 +1,104 @@
+import {
+  maximumDocumentSize,
+  notFoundError,
+} from "@silverbulletmd/silverbullet/constants";
+import { isValidPath } from "@silverbulletmd/silverbullet/lib/ref";
+import type { CaptureInvocationContext } from "../../capture/invocation.ts";
+import type { Client } from "../../client.ts";
+import type { SysCallMapping } from "../system.ts";
+
+function sameBytes(a: Uint8Array, b: Uint8Array): boolean {
+  return a.length === b.length && a.every((byte, index) => byte === b[index]);
+}
+
+export function captureSyscalls(
+  context: () => CaptureInvocationContext | undefined,
+  client: Client,
+): SysCallMapping {
+  const active = (): CaptureInvocationContext => {
+    const current = context();
+    if (!current) throw new Error("No active capture action");
+    return current;
+  };
+
+  return {
+    "capture.readFile": {
+      callback: async (_ctx, handle: string): Promise<Uint8Array> =>
+        new Uint8Array(await (await active().readFile(handle)).arrayBuffer()),
+      description:
+        "Reads a staged file belonging to the current capture action.",
+      parameters: [
+        {
+          name: "handle",
+          type: "string",
+          description: "File handle from the capture.",
+        },
+      ],
+      returns: [{ type: "byteArray", description: "File bytes." }],
+      examples: [
+        { code: "local bytes = capture.readFile(data.files[1].handle)" },
+      ],
+    },
+    "capture.saveFile": {
+      callback: async (
+        _ctx,
+        handle: string,
+        path: string,
+      ): Promise<boolean> => {
+        if (!isValidPath(path)) throw new Error("Invalid capture file path");
+        const blob = await active().readFile(handle);
+        const limit = client.config.get<number>(
+          "maximumDocumentSize",
+          maximumDocumentSize,
+        );
+        if (typeof limit !== "number" || blob.size > limit * 1024 * 1024) {
+          throw new Error("Shared file is too large");
+        }
+        const bytes = new Uint8Array(await blob.arrayBuffer());
+        let existing = false;
+        try {
+          await client.space.getDocumentMeta(path);
+          existing = true;
+        } catch (error) {
+          if (
+            !(error instanceof Error && error.message === notFoundError.message)
+          )
+            throw error;
+        }
+        if (existing) {
+          const saved = await client.space.readDocument(path);
+          if (!sameBytes(saved.data, bytes))
+            throw new Error(`Shared file conflict: ${path}`);
+          return false;
+        }
+        await client.space.writeDocument(path, bytes);
+        const saved = await client.space.readDocument(path);
+        if (!sameBytes(saved.data, bytes))
+          throw new Error(`Shared file verification failed: ${path}`);
+        return true;
+      },
+      description:
+        "Saves a staged file without overwriting different bytes. Returns true when newly created and false when identical content already exists.",
+      parameters: [
+        {
+          name: "handle",
+          type: "string",
+          description: "File handle from the capture.",
+        },
+        { name: "path", type: "string", description: "New document path." },
+      ],
+      returns: [
+        {
+          type: "boolean",
+          description:
+            "true when the file was created, false when identical bytes already exist.",
+        },
+      ],
+      examples: [
+        {
+          code: 'capture.saveFile(data.files[1].handle, "Inbox/" .. data.files[1].name)',
+        },
+      ],
+    },
+  };
+}