@silverbulletmd/silverbullet 2.4.1

package/client/plugos/hooks/event.ts

@@ -0,0 +1,187 @@
+// deno-lint-ignore-file ban-types
+import type { Manifest } from "../types.ts";
+import type { System } from "../system.ts";
+import type { EventHookI } from "../eventhook.ts";
+import type { EventHookT } from "@silverbulletmd/silverbullet/type/manifest";
+import type { Config } from "../../config.ts";
+
+// System events:
+// - plug:load (plugName: string)
+
+export class EventHook implements EventHookI {
+  private system?: System<EventHookT>;
+  private localListeners: Map<string, ((...args: any[]) => any)[]> = new Map();
+
+  constructor(readonly config?: Config) {
+  }
+
+  addLocalListener(eventName: string, callback: (...args: any[]) => any) {
+    if (!this.localListeners.has(eventName)) {
+      this.localListeners.set(eventName, []);
+    }
+    this.localListeners.get(eventName)!.push(callback);
+  }
+
+  removeLocalListener(eventName: string, callback: (...args: any[]) => any) {
+    if (!this.localListeners.has(eventName)) {
+      return;
+    }
+    const listeners = this.localListeners.get(eventName)!;
+    const index = listeners.indexOf(callback);
+    if (index !== -1) {
+      listeners.splice(index, 1);
+    }
+    if (listeners.length === 0) {
+      this.localListeners.delete(eventName);
+    }
+  }
+
+  // Pull all events listened to
+  listEvents(): string[] {
+    if (!this.system) {
+      throw new Error("Event hook is not initialized");
+    }
+    const eventNames = new Set<string>();
+    for (const plug of this.system.loadedPlugs.values()) {
+      for (const functionDef of Object.values(plug.manifest!.functions)) {
+        if (functionDef.events) {
+          for (const eventName of functionDef.events) {
+            eventNames.add(eventName);
+          }
+        }
+      }
+    }
+    for (const eventName of this.localListeners.keys()) {
+      eventNames.add(eventName);
+    }
+    if (this.config) {
+      const configListeners: Record<string, Function[]> = this.config.get(
+        "eventListeners",
+        {},
+      );
+      for (const name of Object.keys(configListeners)) {
+        eventNames.add(name);
+      }
+    }
+
+    return [...eventNames];
+  }
+
+  async dispatchEvent(eventName: string, ...args: any[]): Promise<any[]> {
+    if (!this.system) {
+      throw new Error("Event hook is not initialized");
+    }
+    const promises: Promise<any>[] = [];
+    for (const plug of this.system.loadedPlugs.values()) {
+      const manifest = plug.manifest;
+      for (
+        const [name, functionDef] of Object.entries(
+          manifest!.functions,
+        )
+      ) {
+        if (functionDef.events) {
+          for (const event of functionDef.events) {
+            if (
+              event === eventName || eventNameToRegex(event).test(eventName)
+            ) {
+              // Only dispatch functions that can run in this environment
+              if (plug.canInvoke(name)) {
+                // Queue the promise
+                promises.push((async () => {
+                  try {
+                    return await plug.invoke(name, args);
+                  } catch (e: any) {
+                    console.error(
+                      `Error dispatching event ${eventName} to ${plug.manifest.name}.${name}: ${e.message}`,
+                    );
+                    throw e;
+                  }
+                })());
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Local listeners
+    for (const [name, localListeners] of this.localListeners) {
+      if (eventNameToRegex(name).test(eventName)) {
+        for (const localListener of localListeners) {
+          // Queue the promise
+          promises.push((async () => {
+            return await Promise.resolve(localListener(...args));
+          })());
+        }
+      }
+    }
+
+    // Space Lua listeners
+    if (this.config) {
+      const configListeners: Record<string, Function[]> = this.config.get(
+        "eventListeners",
+        {},
+      );
+      for (const [name, listeners] of Object.entries(configListeners)) {
+        if (eventNameToRegex(name).test(eventName)) {
+          for (const listener of listeners) {
+            promises.push((async () => {
+              return await Promise.resolve(
+                listener({
+                  name: eventName,
+                  // Most events have a single argument, so let's optimize for that, otherwise pass all arguments as an array
+                  data: args.length === 1 ? args[0] : args,
+                }),
+              );
+            })());
+          }
+        }
+      }
+    }
+
+    // Wait for all promises to resolve
+    return (await Promise.allSettled(promises))
+      .filter((result) => {
+        if (result.status === "rejected") {
+          console.error(
+            "Error while dispatching event",
+            eventName,
+            ":",
+            result.reason,
+          );
+        }
+        return result.status === "fulfilled";
+      })
+      .map((result) => result.value)
+      .filter((result) => result != null); // This keeps non-null/undefined results
+  }
+
+  apply(system: System<EventHookT>): void {
+    this.system = system;
+    this.system.on({
+      plugLoaded: async (plug) => {
+        await this.dispatchEvent("plug:load", plug.manifest.name);
+      },
+    });
+  }
+
+  validateManifest(manifest: Manifest<EventHookT>): string[] {
+    const errors = [];
+    for (
+      const [_, functionDef] of Object.entries(
+        manifest.functions || {},
+      )
+    ) {
+      if (functionDef.events && !Array.isArray(functionDef.events)) {
+        errors.push("'events' key must be an array of strings");
+      }
+    }
+    return errors;
+  }
+}
+
+function eventNameToRegex(eventName: string): RegExp {
+  return new RegExp(
+    `^${eventName.replace(/\*/g, ".*").replace(/\//g, "\\/")}$`,
+  );
+}

package/client/plugos/hooks/mq.ts

@@ -0,0 +1,154 @@
+// deno-lint-ignore-file ban-types
+import type { Hook, Manifest } from "../types.ts";
+import type { System } from "../system.ts";
+import { throttle } from "@silverbulletmd/silverbullet/lib/async";
+import type { MQHookT } from "@silverbulletmd/silverbullet/type/manifest";
+import type { DataStoreMQ, QueueWorker } from "../../data/mq.datastore.ts";
+import type {
+  MQMessage,
+  MQSubscribeOptions,
+} from "@silverbulletmd/silverbullet/type/datastore";
+import type { Config } from "../../config.ts";
+
+export type MQListenerSpec =
+  & MQSubscribeOptions
+  & {
+    queue: string;
+    autoAck?: boolean;
+    run: Function;
+  };
+
+export class MQHook implements Hook<MQHookT> {
+  subscriptions: QueueWorker[] = [];
+  throttledReloadQueues = throttle(() => {
+    this.reloadQueues();
+  }, 1000);
+
+  constructor(
+    private system: System<MQHookT>,
+    readonly mq: DataStoreMQ,
+    readonly config: Config,
+  ) {
+  }
+
+  apply(system: System<MQHookT>): void {
+    this.system = system;
+    system.on({
+      plugLoaded: () => {
+        this.throttledReloadQueues();
+      },
+      plugUnloaded: () => {
+        this.throttledReloadQueues();
+      },
+    });
+
+    this.throttledReloadQueues();
+  }
+
+  stop() {
+    this.subscriptions.forEach((worker) => worker.stop());
+    this.subscriptions = [];
+  }
+
+  reloadQueues() {
+    this.stop();
+    // Plug based subscriptions
+    for (const plug of this.system.loadedPlugs.values()) {
+      if (!plug.manifest) {
+        continue;
+      }
+      for (
+        const [name, functionDef] of Object.entries(
+          plug.manifest.functions,
+        )
+      ) {
+        if (!functionDef.mqSubscriptions) {
+          continue;
+        }
+        const subscriptions = functionDef.mqSubscriptions;
+        for (const subscriptionDef of subscriptions) {
+          const queue = subscriptionDef.queue;
+          this.subscriptions.push(
+            this.mq.subscribe(
+              queue,
+              {
+                batchSize: subscriptionDef.batchSize,
+                pollInterval: subscriptionDef.pollInterval,
+              },
+              async (messages: MQMessage[]) => {
+                try {
+                  await plug.invoke(name, [messages]);
+                  if (subscriptionDef.autoAck) {
+                    await this.mq.batchAck(queue, messages.map((m) => m.id));
+                  }
+                } catch (e: any) {
+                  console.error(
+                    "Execution of mqSubscription for queue",
+                    queue,
+                    "invoking",
+                    name,
+                    "with messages",
+                    messages,
+                    "failed:",
+                    e,
+                  );
+                }
+              },
+            ),
+          );
+        }
+      }
+    }
+    // Space Lua based subscriptions
+    const configListeners: Record<string, MQListenerSpec[]> = this.config.get(
+      "mqSubscriptions",
+      {},
+    );
+    for (const [queue, listeners] of Object.entries(configListeners)) {
+      for (const listener of listeners) {
+        // console.log("Subscribing to", queue, listener);
+        this.subscriptions.push(
+          this.mq.subscribe(
+            queue,
+            {
+              batchSize: listener.batchSize,
+              pollInterval: listener.pollInterval,
+            },
+            async (messages: MQMessage[]) => {
+              try {
+                await listener.run(messages);
+                if (listener.autoAck) {
+                  await this.mq.batchAck(queue, messages.map((m) => m.id));
+                }
+              } catch (e: any) {
+                console.error(
+                  "Execution of mqSubscription for queue",
+                  queue,
+                  "with messages",
+                  messages,
+                  "failed:",
+                  e,
+                );
+              }
+            },
+          ),
+        );
+      }
+    }
+  }
+
+  validateManifest(manifest: Manifest<MQHookT>): string[] {
+    const errors: string[] = [];
+    for (const functionDef of Object.values(manifest.functions)) {
+      if (!functionDef.mqSubscriptions) {
+        continue;
+      }
+      for (const subscriptionDef of functionDef.mqSubscriptions) {
+        if (!subscriptionDef.queue) {
+          errors.push("Missing queue name for mqSubscription");
+        }
+      }
+    }
+    return errors;
+  }
+}

package/client/plugos/hooks/plug_namespace.ts

@@ -0,0 +1,85 @@
+import type { NamespaceOperation } from "@silverbulletmd/silverbullet/type/namespace";
+import type { PlugNamespaceHookT } from "@silverbulletmd/silverbullet/type/manifest";
+import type { Plug } from "../plug.ts";
+import type { System } from "../system.ts";
+import type { Hook, Manifest } from "../types.ts";
+
+type SpaceFunction = {
+  operation: NamespaceOperation;
+  pattern: RegExp;
+  plug: Plug<PlugNamespaceHookT>;
+  name: string;
+  env?: string;
+};
+
+export class PlugNamespaceHook implements Hook<PlugNamespaceHookT> {
+  spaceFunctions: SpaceFunction[] = [];
+
+  constructor() {
+  }
+
+  apply(system: System<PlugNamespaceHookT>): void {
+    system.on({
+      plugLoaded: () => {
+        this.updateCache(system);
+      },
+      plugUnloaded: () => {
+        this.updateCache(system);
+      },
+    });
+  }
+
+  updateCache(system: System<PlugNamespaceHookT>) {
+    this.spaceFunctions = [];
+    for (const plug of system.loadedPlugs.values()) {
+      if (plug.manifest?.functions) {
+        for (
+          const [funcName, funcDef] of Object.entries(
+            plug.manifest.functions,
+          )
+        ) {
+          if (funcDef.pageNamespace) {
+            this.spaceFunctions.push({
+              operation: funcDef.pageNamespace.operation,
+              pattern: new RegExp(funcDef.pageNamespace.pattern),
+              plug,
+              name: funcName,
+              env: funcDef.env,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  validateManifest(manifest: Manifest<PlugNamespaceHookT>): string[] {
+    const errors: string[] = [];
+    if (!manifest.functions) {
+      return [];
+    }
+    for (const [funcName, funcDef] of Object.entries(manifest.functions)) {
+      if (funcDef.pageNamespace) {
+        if (!funcDef.pageNamespace.pattern) {
+          errors.push(`Function ${funcName} has a namespace but no pattern`);
+        }
+        if (!funcDef.pageNamespace.operation) {
+          errors.push(`Function ${funcName} has a namespace but no operation`);
+        }
+        if (
+          ![
+            "readFile",
+            "writeFile",
+            "getFileMeta",
+            "listFiles",
+            "deleteFile",
+          ].includes(funcDef.pageNamespace.operation)
+        ) {
+          errors.push(
+            `Function ${funcName} has an invalid operation ${funcDef.pageNamespace.operation}`,
+          );
+        }
+      }
+    }
+    return errors;
+  }
+}

package/client/plugos/hooks/slash_command.ts

@@ -0,0 +1,192 @@
+import type { Hook, Manifest } from "../types.ts";
+import type { System } from "../system.ts";
+import type {
+  Completion,
+  CompletionContext,
+  CompletionResult,
+} from "@codemirror/autocomplete";
+import type { Client } from "../../client.ts";
+import { syntaxTree } from "@codemirror/language";
+import { safeRun, throttle } from "@silverbulletmd/silverbullet/lib/async";
+import type { SlashCommandHookT } from "@silverbulletmd/silverbullet/type/manifest";
+import type { SlashCommand } from "../../types/command.ts";
+import type {
+  SlashCompletionOption,
+  SlashCompletions,
+} from "@silverbulletmd/silverbullet/type/client";
+
+const slashCommandRegexp = /([^\w:]|^)\/[\w#\-]*/;
+
+export class SlashCommandHook implements Hook<SlashCommandHookT> {
+  slashCommands: SlashCommand[] = [];
+  throttledBuildAllCommands = throttle(() => {
+    this.buildAllCommands();
+  }, 200);
+
+  constructor(private client: Client) {
+  }
+
+  buildAllCommands() {
+    const clientSystem = this.client.clientSystem;
+    const system = clientSystem.system;
+
+    this.slashCommands = [];
+    for (const plug of system.loadedPlugs.values()) {
+      for (
+        const [name, functionDef] of Object.entries(
+          plug.manifest!.functions,
+        )
+      ) {
+        if (!functionDef.slashCommand) {
+          continue;
+        }
+        const cmd = functionDef.slashCommand;
+        this.slashCommands.push({
+          ...cmd,
+          run: () => {
+            return plug.invoke(name, [cmd]);
+          },
+        });
+      }
+    }
+    // Iterate over script defined slash commands
+    for (
+      const command of Object.values(
+        this.client.config.get<Record<string, SlashCommand>>(
+          "slashCommands",
+          {},
+        ),
+      )
+    ) {
+      this.slashCommands.push(command);
+    }
+  }
+
+  // Completer for CodeMirror
+  public async slashCommandCompleter(
+    ctx: CompletionContext,
+  ): Promise<CompletionResult | null> {
+    const prefix = ctx.matchBefore(slashCommandRegexp);
+    if (!prefix) {
+      return null;
+    }
+    const prefixText = prefix.text;
+    const options: Completion[] = [];
+
+    // No slash commands in comment blocks (queries and such) or links
+    const currentNode = syntaxTree(ctx.state).resolveInner(ctx.pos);
+    if (
+      currentNode.type.name === "CommentBlock" ||
+      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 && def.exceptContexts.some(
+          (context) => parentNodes.some((node) => node.startsWith(context)),
+        )
+      ) {
+        continue;
+      }
+      options.push({
+        label: def.name,
+        detail: def.description,
+        boost: def.priority,
+        apply: () => {
+          // Delete slash command part
+          this.client.editorView.dispatch({
+            changes: {
+              from: prefix!.from + prefixText.indexOf("/"),
+              to: ctx.pos,
+              insert: "",
+            },
+          });
+          // Replace with whatever the completion is
+          safeRun(async () => {
+            await def.run!();
+            this.client.focus();
+          });
+        },
+      });
+    }
+
+    const slashCompletions: CompletionResult | SlashCompletions | null =
+      await this.client
+        .completeWithEvent(
+          ctx,
+          "slash:complete",
+        );
+
+    if (slashCompletions) {
+      for (
+        const slashCompletion of slashCompletions
+          .options as SlashCompletionOption[]
+      ) {
+        options.push({
+          label: slashCompletion.label,
+          detail: slashCompletion.detail,
+          boost: slashCompletion.order && -slashCompletion.order,
+          apply: () => {
+            // Delete slash command part
+            this.client.editorView.dispatch({
+              changes: {
+                from: prefix!.from + prefixText.indexOf("/"),
+                to: ctx.pos,
+                insert: "",
+              },
+            });
+            // Replace with whatever the completion is
+            safeRun(async () => {
+              await this.client.clientSystem.system.invokeFunction(
+                slashCompletion.invoke,
+                [slashCompletion],
+              );
+              this.client.focus();
+            });
+          },
+        });
+      }
+    }
+
+    return {
+      // + 1 because of the '/'
+      from: prefix.from + prefixText.indexOf("/") + 1,
+      options: options,
+    };
+  }
+
+  apply(system: System<SlashCommandHookT>): void {
+    this.buildAllCommands();
+    system.on({
+      plugLoaded: () => {
+        this.buildAllCommands();
+      },
+    });
+  }
+
+  validateManifest(manifest: Manifest<SlashCommandHookT>): string[] {
+    const errors = [];
+    for (const [name, functionDef] of Object.entries(manifest.functions)) {
+      if (!functionDef.slashCommand) {
+        continue;
+      }
+      const cmd = functionDef.slashCommand;
+      if (!cmd.name) {
+        errors.push(`Function ${name} has a command but no name`);
+      }
+    }
+    return [];
+  }
+}

package/client/plugos/hooks/syscall.ts

@@ -0,0 +1,66 @@
+import type { Hook, Manifest } from "../types.ts";
+import type { SysCallMapping, System } from "../system.ts";
+import type { SyscallHookT } from "@silverbulletmd/silverbullet/type/manifest";
+
+export class SyscallHook implements Hook<SyscallHookT> {
+  apply(system: System<SyscallHookT>): void {
+    this.registerSyscalls(system);
+    system.on({
+      plugLoaded: () => {
+        this.registerSyscalls(system);
+      },
+    });
+  }
+
+  registerSyscalls(system: System<SyscallHookT>) {
+    // Register syscalls from all loaded plugs
+    for (const plug of system.loadedPlugs.values()) {
+      const syscalls: SysCallMapping = {};
+
+      for (
+        const [name, functionDef] of Object.entries(plug.manifest!.functions)
+      ) {
+        if (!functionDef.syscall) {
+          continue;
+        }
+
+        const syscallName = functionDef.syscall;
+
+        // Add the syscall to our mapping
+        syscalls[syscallName] = (ctx, ...args) => {
+          // Delegate to the system to invoke the function
+          return system.syscall(ctx, "system.invokeFunction", [
+            `${plug.manifest!.name}.${name}`,
+            ...args,
+          ]);
+        };
+
+        // Register the syscalls with no required permissions
+        system.registerSyscalls([], syscalls);
+      }
+    }
+  }
+
+  validateManifest(manifest: Manifest<SyscallHookT>): string[] {
+    const errors: string[] = [];
+    for (const [name, functionDef] of Object.entries(manifest.functions)) {
+      if (!functionDef.syscall) {
+        continue;
+      }
+
+      // Validate syscall name is provided
+      if (!functionDef.syscall) {
+        errors.push(`Function ${name} has a syscall but no name`);
+        continue;
+      }
+
+      // Validate syscall name format (should be namespaced)
+      if (!functionDef.syscall.includes(".")) {
+        errors.push(
+          `Function ${name} has invalid syscall name "${functionDef.syscall}" - must be in format "namespace.name"`,
+        );
+      }
+    }
+    return errors;
+  }
+}