@silverbulletmd/silverbullet 2.5.3 → 2.7.0

package/README.md

@@ -2,6 +2,7 @@
 ![Docker Pulls](https://img.shields.io/docker/pulls/zefhemel/silverbullet)
 ![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/silverbulletmd/silverbullet/total)
 ![GitHub contributors](https://img.shields.io/github/contributors/silverbulletmd/silverbullet)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/silverbulletmd/silverbullet)
 
 # SilverBullet
 SilverBullet is a Programmable, Private, Browser-based, Open Source, Self Hosted, Personal Knowledge Management Platform.
@@ -62,10 +63,10 @@ Make sure your `$GOPATH/bin` is in your $PATH.
 First, install dependencies:
 
 ```shell
-npm install
+make setup
 ```
 
-To build everything and run the server:
+To build everything and run the server (which automatically restarts upon file changing):
 
 ```shell
 air <PATH-TO-YOUR-SPACE>
@@ -74,9 +75,7 @@ air <PATH-TO-YOUR-SPACE>
 Alternatively, to build:
 
 ```shell
-make build
-# or
-npm run build
+make
 ```
 
 To run the resulting server:
@@ -108,7 +107,6 @@ docker build -t silverbullet .
 ```
 
 To run:
-
 ```shell
 docker run -p 3000:3000 -v <PATH-TO-YOUR-SPACE>:/space silverbullet
 ```

package/client/asset_bundle/bundle.ts

@@ -23,9 +23,7 @@ export class AssetBundle {
     return Object.keys(this.bundle);
   }
 
-  readFileSync(
-    path: string,
-  ): Uint8Array {
+  readFileSync(path: string): Uint8Array {
     const content = this.bundle[path];
     if (!content) {
       throw new Error(`No such file ${path}`);
@@ -42,15 +40,11 @@ export class AssetBundle {
     return content.data;
   }
 
-  readTextFileSync(
-    path: string,
-  ): string {
+  readTextFileSync(path: string): string {
     return new TextDecoder().decode(this.readFileSync(path));
   }
 
-  getMimeType(
-    path: string,
-  ): string {
+  getMimeType(path: string): string {
     const entry = this.bundle[path];
     if (!entry) {
       throw new Error(`No such file ${path}`);

package/client/data/datastore.ts

@@ -4,6 +4,7 @@ import {
 } from "../space_lua/query_collection.ts";
 import { LuaEnv, LuaStackFrame } from "../space_lua/runtime.ts";
 import type { KvPrimitives, KvQueryOptions } from "./kv_primitives.ts";
+import type { Config } from "../config.ts";
 
 import type { KV, KvKey } from "../../plug-api/types/datastore.ts";
 
@@ -12,10 +13,7 @@ import type { KV, KvKey } from "../../plug-api/types/datastore.ts";
  * in a more user-friendly way
  */
 export class DataStore {
-  constructor(
-    readonly kv: KvPrimitives,
-  ) {
-  }
+  constructor(readonly kv: KvPrimitives) {}
 
   async get<T = any>(key: KvKey): Promise<T | null> {
     return (await this.batchGet([key]))[0];
@@ -79,7 +77,8 @@ export class DataStore {
     env: LuaEnv = new LuaEnv(),
     sf: LuaStackFrame = LuaStackFrame.lostFrame,
     enricher?: (key: KvKey, item: any) => any,
+    config?: Config,
   ): Promise<T[]> {
-    return queryLua(this.kv, prefix, query, env, sf, enricher);
+    return queryLua(this.kv, prefix, query, env, sf, enricher, config);
   }
 }

package/client/markdown_parser/constants.ts

@@ -1,6 +1,7 @@
 export const wikiLinkRegex =
   /(?<leadingTrivia>!?\[\[)(?<stringRef>.*?)(?:\|(?<alias>.*?))?(?<trailingTrivia>\]\])/g;
-export const mdLinkRegex = /!?\[(?<title>[^\]]*)\]\((?<url>.+)\)/g;
+export const mdLinkRegex =
+  /!?\[(?<title>[^\]\\]*(?:\\.[^\]\\]*)*)\]\((?<url>.+)\)/g;
 export const tagRegex =
   /#(?:(?:\d*[^\d\s!@#$%^&*(),.?":{}|<>\\][^\s!@#$%^&*(),.?":{}|<>\\]*)|(?:<[^>\n]+>))/;
 export const nakedUrlRegex =
@@ -9,5 +10,6 @@ export const frontmatterQuotesRegex = /["'].*["']/g;
 export const frontmatterUrlRegex = /([a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^\s"']+)/g;
 export const frontmatterWikiLinkRegex =
   /(?<leadingTrivia>!?\[\[)(?<stringRef>.*?)(?:\|(?<alias>.*?))?(?<trailingTrivia>\]\])/g;
-export const frontmatterMailtoRegex = /(mailto:[^@\s]+@[^@\s"']+)/ig;
+export const frontmatterMailtoRegex = /(mailto:[^@\s]+@[^@\s"']+)/gi;
 export const pWikiLinkRegex = new RegExp(`^${wikiLinkRegex.source}`); // Modified regex used only in parser
+export const anchorRegex = /\$[A-Za-z_][A-Za-z0-9_/:-]*/;

package/client/plugos/hooks/code_widget.ts

@@ -10,11 +10,9 @@ export class CodeWidgetHook implements Hook<CodeWidgetT> {
   collectAllCodeWidgets(system: System<CodeWidgetT>) {
     this.codeWidgetCallbacks.clear();
     for (const plug of system.loadedPlugs.values()) {
-      for (
-        const [name, functionDef] of Object.entries(
-          plug.manifest!.functions,
-        )
-      ) {
+      for (const [name, functionDef] of Object.entries(
+        plug.manifest!.functions,
+      )) {
         if (!functionDef.codeWidget) {
           continue;
         }

package/client/plugos/hooks/command.ts

@@ -5,13 +5,17 @@ import { throttle } from "@silverbulletmd/silverbullet/lib/async";
 import type { Command, CommandHookEvents } from "../../types/command.ts";
 import type { CommandHookT } from "@silverbulletmd/silverbullet/type/manifest";
 
-export class CommandHook extends EventEmitter<CommandHookEvents>
-  implements Hook<CommandHookT> {
+export class CommandHook
+  extends EventEmitter<CommandHookEvents>
+  implements Hook<CommandHookT>
+{
   system?: System<CommandHookT>;
   public throttledBuildAllCommandsAndEmit = throttle(() => {
     this.buildAllCommandsAndEmit();
   }, 200);
 
+  private registeredCommands = new Map<string, Command>();
+
   constructor(
     private readOnly: boolean,
     private additionalCommands: Map<string, Command>,
@@ -19,22 +23,60 @@ export class CommandHook extends EventEmitter<CommandHookEvents>
     super();
   }
 
+  /**
+   * Register a command directly with the hook. Intended for client-side code
+   * that wants to define commands without going through a plug manifest.
+   * Overwrites any previously-registered command with the same name.
+   */
+  registerCommand(command: Command): void {
+    this.registeredCommands.set(command.name, command);
+    this.throttledBuildAllCommandsAndEmit();
+  }
+
+  private mergeCommand(
+    commands: Map<string, Command>,
+    name: string,
+    cmd: Command,
+  ) {
+    if (commands.has(name)) {
+      // Existing command, let's do some inline patching
+      const existingCommand = commands.get(name)!;
+      const command: Command = {
+        ...existingCommand,
+        ...cmd,
+      };
+      if (cmd.run) {
+        command.run = cmd.run;
+      }
+      commands.set(name, command);
+    } else {
+      commands.set(name, cmd);
+    }
+  }
+
   /**
    * Build the command map
    */
   buildAllCommands(): Map<string, Command> {
     const commands = new Map<string, Command>();
+    // Start with directly-registered commands (built-in client commands).
+    // These form the base layer and can be overridden by plug commands or
+    // script commands further down.
+    for (const [name, cmd] of this.registeredCommands) {
+      if (cmd.requireMode === "rw" && this.readOnly) {
+        continue;
+      }
+      commands.set(name, cmd);
+    }
     // Add commands from plugs
     if (!this.system) {
       // Not initialized yet
       return commands;
     }
     for (const plug of this.system.loadedPlugs.values()) {
-      for (
-        const [name, functionDef] of Object.entries(
-          plug.manifest!.functions,
-        )
-      ) {
+      for (const [name, functionDef] of Object.entries(
+        plug.manifest!.functions,
+      )) {
         if (!functionDef.command) {
           continue;
         }
@@ -43,30 +85,18 @@ export class CommandHook extends EventEmitter<CommandHookEvents>
           // Bit hacky, but don't expose commands that require write mode in read-only mode
           continue;
         }
-        commands.set(cmd.name, {
+        this.mergeCommand(commands, cmd.name, {
           ...cmd,
           run: (args?: string[]) => {
-            return plug.invoke(name, [cmd, ...args ?? []]);
+            return plug.invoke(name, [cmd, ...(args ?? [])]);
           },
         });
       }
     }
+    // Script commands come last — they always win over built-ins and plugs,
+    // so users can rebind keys / replace run bodies from Lua.
     for (const [name, cmd] of this.additionalCommands) {
-      if (commands.has(name)) {
-        // Existing command, let's do some inline patching
-        const existingCommand = commands.get(name)!;
-        const command: Command = {
-          ...existingCommand,
-          ...cmd,
-        };
-        if (cmd.run) {
-          command.run = cmd.run;
-        }
-        commands.set(name, command);
-      } else {
-        // New command, let's just set
-        commands.set(name, cmd);
-      }
+      this.mergeCommand(commands, name, cmd);
     }
     return commands;
   }

package/client/plugos/hooks/document_editor.ts

@@ -12,11 +12,9 @@ export class DocumentEditorHook implements Hook<DocumentEditorT> {
   collectAllDocumentEditors(system: System<DocumentEditorT>) {
     this.documentEditors.clear();
     for (const plug of system.loadedPlugs.values()) {
-      for (
-        const [name, functionDef] of Object.entries(
-          plug.manifest!.functions,
-        )
-      ) {
+      for (const [name, functionDef] of Object.entries(
+        plug.manifest!.functions,
+      )) {
         if (!functionDef.editor) {
           continue;
         }
@@ -25,9 +23,9 @@ export class DocumentEditorHook implements Hook<DocumentEditorT> {
           ? functionDef.editor
           : [functionDef.editor];
 
-        const conflict = Array.from(this.documentEditors.entries()).find((
-          [_, { extensions }],
-        ) => keys.some((key) => extensions.includes(key)));
+        const conflict = Array.from(this.documentEditors.entries()).find(
+          ([_, { extensions }]) => keys.some((key) => extensions.includes(key)),
+        );
 
         if (conflict) {
           console.log(
@@ -37,10 +35,10 @@ export class DocumentEditorHook implements Hook<DocumentEditorT> {
           );
         }
 
-        this.documentEditors.set(
-          name,
-          { extensions: keys, callback: () => plug.invoke(name, []) },
-        );
+        this.documentEditors.set(name, {
+          extensions: keys,
+          callback: () => plug.invoke(name, []),
+        });
       }
     }
   }

package/client/plugos/hooks/event.ts

@@ -1,4 +1,3 @@
-
 import type { Manifest } from "../types.ts";
 import type { System } from "../system.ts";
 import type { EventHookI } from "../eventhook.ts";
@@ -12,8 +11,7 @@ export class EventHook implements EventHookI {
   private system?: System<EventHookT>;
   private localListeners: Map<string, ((...args: any[]) => any)[]> = new Map();
 
-  constructor(readonly config?: Config) {
-  }
+  constructor(readonly config?: Config) {}
 
   addLocalListener(eventName: string, callback: (...args: any[]) => any) {
     if (!this.localListeners.has(eventName)) {
@@ -74,29 +72,28 @@ export class EventHook implements EventHookI {
     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,
-        )
-      ) {
+      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)
+              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;
-                  }
-                })());
+                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;
+                    }
+                  })(),
+                );
               }
             }
           }
@@ -109,9 +106,11 @@ export class EventHook implements EventHookI {
       if (eventNameToRegex(name).test(eventName)) {
         for (const localListener of localListeners) {
           // Queue the promise
-          promises.push((async () => {
-            return await Promise.resolve(localListener(...args));
-          })());
+          promises.push(
+            (async () => {
+              return await Promise.resolve(localListener(...args));
+            })(),
+          );
         }
       }
     }
@@ -125,15 +124,17 @@ export class EventHook implements EventHookI {
       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,
-                }),
-              );
-            })());
+            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,
+                  }),
+                );
+              })(),
+            );
           }
         }
       }
@@ -167,11 +168,7 @@ export class EventHook implements EventHookI {
 
   validateManifest(manifest: Manifest<EventHookT>): string[] {
     const errors = [];
-    for (
-      const [_, functionDef] of Object.entries(
-        manifest.functions || {},
-      )
-    ) {
+    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");
       }

package/client/plugos/hooks/mq.ts

@@ -1,4 +1,3 @@
-
 import type { Hook, Manifest } from "../types.ts";
 import type { System } from "../system.ts";
 import { throttle } from "@silverbulletmd/silverbullet/lib/async";
@@ -10,13 +9,11 @@ import type {
 } from "@silverbulletmd/silverbullet/type/datastore";
 import type { Config } from "../../config.ts";
 
-export type MQListenerSpec =
-  & MQSubscribeOptions
-  & {
-    queue: string;
-    autoAck?: boolean;
-    run: Function;
-  };
+export type MQListenerSpec = MQSubscribeOptions & {
+  queue: string;
+  autoAck?: boolean;
+  run: Function;
+};
 
 export class MQHook implements Hook<MQHookT> {
   subscriptions: QueueWorker[] = [];
@@ -28,8 +25,7 @@ export class MQHook implements Hook<MQHookT> {
     private system: System<MQHookT>,
     readonly mq: DataStoreMQ,
     readonly config: Config,
-  ) {
-  }
+  ) {}
 
   apply(system: System<MQHookT>): void {
     this.system = system;
@@ -57,11 +53,9 @@ export class MQHook implements Hook<MQHookT> {
       if (!plug.manifest) {
         continue;
       }
-      for (
-        const [name, functionDef] of Object.entries(
-          plug.manifest.functions,
-        )
-      ) {
+      for (const [name, functionDef] of Object.entries(
+        plug.manifest.functions,
+      )) {
         if (!functionDef.mqSubscriptions) {
           continue;
         }
@@ -79,7 +73,10 @@ export class MQHook implements Hook<MQHookT> {
                 try {
                   await plug.invoke(name, [messages]);
                   if (subscriptionDef.autoAck) {
-                    await this.mq.batchAck(queue, messages.map((m) => m.id));
+                    await this.mq.batchAck(
+                      queue,
+                      messages.map((m) => m.id),
+                    );
                   }
                 } catch (e: any) {
                   console.error(
@@ -118,7 +115,10 @@ export class MQHook implements Hook<MQHookT> {
               try {
                 await listener.run(messages);
                 if (listener.autoAck) {
-                  await this.mq.batchAck(queue, messages.map((m) => m.id));
+                  await this.mq.batchAck(
+                    queue,
+                    messages.map((m) => m.id),
+                  );
                 }
               } catch (e: any) {
                 console.error(

package/client/plugos/hooks/plug_namespace.ts

@@ -30,11 +30,9 @@ export class PlugNamespaceHook implements Hook<PlugNamespaceHookT> {
     this.spaceFunctions = [];
     for (const plug of system.loadedPlugs.values()) {
       if (plug.manifest?.functions) {
-        for (
-          const [funcName, funcDef] of Object.entries(
-            plug.manifest.functions,
-          )
-        ) {
+        for (const [funcName, funcDef] of Object.entries(
+          plug.manifest.functions,
+        )) {
           if (funcDef.pageNamespace) {
             this.spaceFunctions.push({
               operation: funcDef.pageNamespace.operation,

package/client/plugos/hooks/slash_command.ts

@@ -23,8 +23,7 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
     this.buildAllCommands();
   }, 200);
 
-  constructor(private client: Client) {
-  }
+  constructor(private client: Client) {}
 
   buildAllCommands() {
     const clientSystem = this.client.clientSystem;
@@ -32,11 +31,9 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
 
     this.slashCommands = [];
     for (const plug of system.loadedPlugs.values()) {
-      for (
-        const [name, functionDef] of Object.entries(
-          plug.manifest!.functions,
-        )
-      ) {
+      for (const [name, functionDef] of Object.entries(
+        plug.manifest!.functions,
+      )) {
         if (!functionDef.slashCommand) {
           continue;
         }
@@ -50,14 +47,9 @@ 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",
-          {},
-        ),
-      )
-    ) {
+    for (const command of Object.values(
+      this.client.config.get<Record<string, SlashCommand>>("slashCommands", {}),
+    )) {
       this.slashCommands.push(command);
     }
   }
@@ -74,7 +66,9 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
     const options: Completion[] = [];
 
     // No slash commands in comment blocks (queries and such) or links
-    const currentNode = syntaxTree(ctx.state).resolveInner(ctx.pos);
+    // Pass -1 so we resolve into the node ending at the cursor: when typing,
+    // 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 === "Link"
@@ -88,14 +82,14 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
       if (
         def.onlyContexts &&
         !def.onlyContexts.some((context) =>
-          parentNodes.some((node) => node.startsWith(context))
+          parentNodes.some((node) => node.startsWith(context)),
         )
       ) {
         continue;
       }
       if (
-        def.exceptContexts?.some(
-          (context) => parentNodes.some((node) => node.startsWith(context)),
+        def.exceptContexts?.some((context) =>
+          parentNodes.some((node) => node.startsWith(context)),
         )
       ) {
         continue;
@@ -123,17 +117,10 @@ export class SlashCommandHook implements Hook<SlashCommandHookT> {
     }
 
     const slashCompletions: CompletionResult | SlashCompletions | null =
-      await this.client
-        .completeWithEvent(
-          ctx,
-          "slash:complete",
-        );
+      await this.client.completeWithEvent(ctx, "slash:complete");
 
     if (slashCompletions) {
-      for (
-        const slashCompletion of slashCompletions
-          .options as SlashCompletionOption[]
-      ) {
+      for (const slashCompletion of slashCompletions.options as SlashCompletionOption[]) {
         options.push({
           label: slashCompletion.label,
           detail: slashCompletion.detail,

package/client/plugos/hooks/syscall.ts

@@ -17,9 +17,9 @@ export class SyscallHook implements Hook<SyscallHookT> {
     for (const plug of system.loadedPlugs.values()) {
       const syscalls: SysCallMapping = {};
 
-      for (
-        const [name, functionDef] of Object.entries(plug.manifest!.functions)
-      ) {
+      for (const [name, functionDef] of Object.entries(
+        plug.manifest!.functions,
+      )) {
         if (!functionDef.syscall) {
           continue;
         }

package/client/plugos/manifest_cache.ts

@@ -11,38 +11,45 @@ export interface ManifestCache<T> {
 }
 
 export class KVPrimitivesManifestCache<T> implements ManifestCache<T> {
-  constructor(private kv: KvPrimitives, private manifestPrefix: string) {
-  }
+  constructor(
+    private kv: KvPrimitives,
+    private manifestPrefix: string,
+  ) {}
 
   async getManifest(
     plug: Plug<T>,
     cacheKey: string,
     cacheHash: number,
   ): Promise<Manifest<T>> {
-    const [cached] = await this.kv.batchGet([[
-      this.manifestPrefix,
-      cacheKey,
-    ]]);
+    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();
     const manifest = plug.sandbox.manifest!;
-    await this.kv.batchSet([{
-      key: [this.manifestPrefix, cacheKey],
-      // Deliverately removing the assets from the manifest to preserve space, will be re-added upon load of actual worker
-      value: { manifest: { ...manifest, assets: undefined }, hash: cacheHash },
-    }]);
+    await this.kv.batchSet([
+      {
+        key: [this.manifestPrefix, cacheKey],
+        // Deliverately removing the assets from the manifest to preserve space, will be re-added upon load of actual worker
+        value: {
+          manifest: { ...manifest, assets: undefined },
+          hash: cacheHash,
+        },
+      },
+    ]);
     return manifest;
   }
 }
 
 export class InMemoryManifestCache<T> implements ManifestCache<T> {
-  private cache = new Map<string, {
-    manifest: Manifest<T>;
-    hash: number;
-  }>();
+  private cache = new Map<
+    string,
+    {
+      manifest: Manifest<T>;
+      hash: number;
+    }
+  >();
 
   async getManifest(
     plug: Plug<T>,