@silverbulletmd/silverbullet 2.4.2 → 2.6.1

package/client/plugos/syscalls/editor.ts

@@ -18,10 +18,12 @@ import {
 } from "@codemirror/commands";
 import type { Transaction } from "@codemirror/state";
 import { EditorView } from "@codemirror/view";
-import { getCM as vimGetCm, Vim } from "@replit/codemirror-vim";
+import { getVimModule } from "../../vim_loader.ts";
 import type { SysCallMapping } from "../system.ts";
 import type {
   FilterOption,
+  NotificationAction,
+  NotificationType,
   UploadFile,
 } from "@silverbulletmd/silverbullet/type/client";
 import { openSearchPanel } from "@codemirror/search";
@@ -48,11 +50,11 @@ export function editorSyscalls(client: Client): SysCallMapping {
       return client.currentPath();
     },
     "editor.getCurrentEditor": (): string => {
-      return client.documentEditor?.name || "page";
+      return client.contentManager.documentEditor?.name || "page";
     },
     "editor.getRecentlyOpenedPages": (): PageMeta[] => {
-      return client.ui.viewState.allPages.sort((a, b) =>
-        (b.lastOpened || 0) - (a.lastOpened || 0)
+      return client.ui.viewState.allPages.sort(
+        (a, b) => (b.lastOpened || 0) - (a.lastOpened || 0),
       );
     },
     "editor.getText": () => {
@@ -68,12 +70,14 @@ export function editorSyscalls(client: Client): SysCallMapping {
       const line = client.editorView.state.doc.lineAt(pos);
       return {
         ...line,
-        textWithCursor: line.text.slice(0, pos - line.from) + "|^|" +
+        textWithCursor:
+          line.text.slice(0, pos - line.from) +
+          "|^|" +
           line.text.slice(pos - line.from),
       };
     },
     "editor.setText": (_ctx, newText: string, shouldIsolateHistory = false) => {
-      client.setEditorText(newText, shouldIsolateHistory);
+      client.contentManager.setEditorText(newText, shouldIsolateHistory);
     },
     "editor.getCursor": (): number => {
       return client.editorView.state.selection.main.from;
@@ -110,7 +114,7 @@ export function editorSyscalls(client: Client): SysCallMapping {
       }
 
       if (
-        // @ts-ignore: Legacy support
+        // @ts-expect-error: Legacy support
         ref.page !== undefined
       ) {
         console.warn(
@@ -127,7 +131,7 @@ export function editorSyscalls(client: Client): SysCallMapping {
 
         legacyRef.kind ??= "page";
 
-        let details: Ref["details"] = undefined;
+        let details: Ref["details"];
 
         if (typeof legacyRef.pos === "number") {
           details = {
@@ -160,13 +164,9 @@ export function editorSyscalls(client: Client): SysCallMapping {
       // some validation library. Didn't want to use jsonschemas here tho.
       // Ideally this would be moved into a function too
       if (!isValidPath(ref.path) && ref.path !== "") {
-        throw new Error(
-          "Path passed in ref to `editor.navigate` is invalid",
-        );
+        throw new Error("Path passed in ref to `editor.navigate` is invalid");
       } else if (typeof ref.meta !== "boolean" && ref.meta !== undefined) {
-        throw new Error(
-          "ref.meta has to be of type `boolean`",
-        );
+        throw new Error("ref.meta has to be of type `boolean`");
       } else if (ref.details !== undefined && typeof ref.details !== "object") {
         throw new Error(
           "ref.details has to be of type `object` or `undefined`",
@@ -181,17 +181,15 @@ export function editorSyscalls(client: Client): SysCallMapping {
       }
 
       if (
-        ref.details?.type === "position" && typeof ref.details.pos !== "number"
+        ref.details?.type === "position" &&
+        typeof ref.details.pos !== "number"
       ) {
-        throw new Error(
-          "ref.details.pos has to be of type `number`",
-        );
+        throw new Error("ref.details.pos has to be of type `number`");
       } else if (
-        ref.details?.type === "header" && typeof ref.details.header !== "string"
+        ref.details?.type === "header" &&
+        typeof ref.details.header !== "string"
       ) {
-        throw new Error(
-          "ref.details.header has to be of type `string`",
-        );
+        throw new Error("ref.details.header has to be of type `string`");
       } else if (
         ref.details?.type === "linecolumn" &&
         typeof ref.details.line !== "number" &&
@@ -214,14 +212,12 @@ export function editorSyscalls(client: Client): SysCallMapping {
       client.rebuildEditorState();
     },
     "editor.reloadConfigAndCommands": async () => {
-      await client.clientSystem.system.localSyscall(
-        "system.loadScripts",
-        [],
-      );
+      await client.clientSystem.system.localSyscall("system.loadScripts", []);
       await client.clientSystem.system.localSyscall(
         "system.loadSpaceStyles",
         [],
       );
+      client.reconfigureLanguage();
     },
     "editor.invokeCommand": (_ctx, name: string, args?: string[]) => {
       return client.runCommandByName(name, args);
@@ -232,7 +228,7 @@ export function editorSyscalls(client: Client): SysCallMapping {
     "editor.newWindow": () => {
       globalThis.open(
         location.href,
-        "rnd" + Math.random(),
+        `rnd${Math.random()}`,
         `width=${globalThis.innerWidth},heigh=${globalThis.innerHeight}`,
       );
     },
@@ -268,7 +264,7 @@ export function editorSyscalls(client: Client): SysCallMapping {
             const reader = new FileReader();
             reader.readAsArrayBuffer(file);
             reader.onloadend = async (evt) => {
-              if (evt.target?.readyState == FileReader.DONE) {
+              if (evt.target?.readyState === FileReader.DONE) {
                 resolve({
                   name: file.name,
                   contentType: file.type,
@@ -288,15 +284,19 @@ export function editorSyscalls(client: Client): SysCallMapping {
           reject(e);
         };
 
+        input.style.display = "none";
+        document.body.appendChild(input);
         input.click();
+        setTimeout(() => document.body.removeChild(input), 1000);
       });
     },
     "editor.flashNotification": (
       _ctx,
       message: string,
-      type: "error" | "info" = "info",
+      type: NotificationType = "info",
+      options?: { timeout?: number; actions?: NotificationAction[] },
     ) => {
-      client.flashNotification(message, type);
+      client.ui.flashNotification(message, type, options);
     },
     "editor.filterBox": (
       _ctx,
@@ -305,13 +305,13 @@ export function editorSyscalls(client: Client): SysCallMapping {
       helpText = "",
       placeHolder = "",
     ): Promise<FilterOption | undefined> => {
-      return client.filterBox(label, options, helpText, placeHolder);
+      return client.ui.filterBox(label, options, helpText, placeHolder);
     },
     "editor.showPanel": (
       _ctx,
       id: string,
       mode: number,
-      html: string,
+      html: HTMLElement | HTMLElement[] | string,
       script: string,
     ) => {
       client.ui.viewDispatch({
@@ -339,7 +339,7 @@ export function editorSyscalls(client: Client): SysCallMapping {
       progressPercentage?: number,
       progressType?: "sync" | "index",
     ) => {
-      client.showProgress(progressPercentage, progressType);
+      client.ui.showProgress(progressPercentage, progressType);
     },
     "editor.insertAtPos": (
       _ctx,
@@ -351,7 +351,8 @@ export function editorSyscalls(client: Client): SysCallMapping {
       if (cursorPlaceHolder) {
         cursorPlaceholderPos = text.indexOf("|^|");
         if (cursorPlaceholderPos !== -1) {
-          text = text.slice(0, cursorPlaceholderPos) +
+          text =
+            text.slice(0, cursorPlaceholderPos) +
             text.slice(cursorPlaceholderPos + 3);
         } else {
           cursorPlaceHolder = false;
@@ -369,9 +370,7 @@ export function editorSyscalls(client: Client): SysCallMapping {
           selection: {
             anchor: cursorPos,
           },
-          effects: [
-            EditorView.scrollIntoView(cursorPos),
-          ],
+          effects: [EditorView.scrollIntoView(cursorPos)],
         });
       }
     },
@@ -385,7 +384,8 @@ export function editorSyscalls(client: Client): SysCallMapping {
       let cursorPlaceholderPos = -1;
       if (cursorPlaceHolder) {
         cursorPlaceholderPos = text.indexOf("|^|");
-        text = text.slice(0, cursorPlaceholderPos) +
+        text =
+          text.slice(0, cursorPlaceholderPos) +
           text.slice(cursorPlaceholderPos + 3);
       }
       client.editorView.dispatch({
@@ -401,9 +401,7 @@ export function editorSyscalls(client: Client): SysCallMapping {
           selection: {
             anchor: cursorPos,
           },
-          effects: [
-            EditorView.scrollIntoView(cursorPos),
-          ],
+          effects: [EditorView.scrollIntoView(cursorPos)],
         });
       }
     },
@@ -416,12 +414,9 @@ export function editorSyscalls(client: Client): SysCallMapping {
       if (center) {
         client.editorView.dispatch({
           effects: [
-            EditorView.scrollIntoView(
-              pos,
-              {
-                y: "center",
-              },
-            ),
+            EditorView.scrollIntoView(pos, {
+              y: "center",
+            }),
           ],
         });
       }
@@ -459,7 +454,8 @@ export function editorSyscalls(client: Client): SysCallMapping {
       const from = editorView.state.selection.main.from;
       const cursorPlaceholderPos = text.indexOf("|^|");
       if (cursorPlaceHolder && cursorPlaceholderPos !== -1) {
-        text = text.slice(0, cursorPlaceholderPos) +
+        text =
+          text.slice(0, cursorPlaceholderPos) +
           text.slice(cursorPlaceholderPos + 3);
       } else {
         cursorPlaceHolder = false;
@@ -485,10 +481,10 @@ export function editorSyscalls(client: Client): SysCallMapping {
       message: string,
       defaultValue = "",
     ): Promise<string | undefined> => {
-      return client.prompt(message, defaultValue);
+      return client.ui.prompt(message, defaultValue);
     },
     "editor.confirm": (_ctx, message: string): Promise<boolean> => {
-      return client.confirm(message);
+      return client.ui.confirm(message);
     },
     "editor.alert": (_ctx, message: string) => {
       alert(message);
@@ -502,17 +498,26 @@ export function editorSyscalls(client: Client): SysCallMapping {
         key,
         value,
       });
-      client.reloadEditor();
+      void client.reloadEditor();
     },
     "editor.vimEx": (_ctx, exCommand: string) => {
-      const cm = vimGetCm(client.editorView);
-      if (cm && cm.state.vim) {
-        return Vim.handleEx(cm as any, exCommand);
+      const vimMod = getVimModule();
+      if (!vimMod) {
+        throw new Error("Vim module not loaded.");
+      }
+      const cm = vimMod.getCM(client.editorView);
+      if (cm?.state.vim) {
+        return vimMod.Vim.handleEx(cm as any, exCommand);
       } else {
         throw new Error("Vim mode not active or not initialized.");
       }
     },
     "editor.configureVimMode": () => {
+      const vimMod = getVimModule();
+      if (!vimMod) {
+        throw new Error("Vim module not loaded.");
+      }
+      const { Vim } = vimMod;
       // Override the default "o" binding to be more intelligent and follow the markdown editor's behavior
       Vim.mapCommand("o", "action", "newline-continue-markup", {}, {});
       Vim.mapCommand("O", "action", "back-newline-continue-markup", {}, {});
@@ -555,31 +560,29 @@ export function editorSyscalls(client: Client): SysCallMapping {
       if (config) {
         config.unmap?.forEach((binding) => {
           if (typeof binding === "string") {
-            console.log("Unmapping " + binding);
-            // @ts-ignore: unmap expects a string for the mode, this is problematic with Ex mappings which requires undefined or false
+            console.log(`Unmapping ${binding}`);
+            // @ts-expect-error: unmap expects a string for the mode, this is problematic with Ex mappings which requires undefined or false
             Vim.unmap(binding, undefined);
           } else if (binding.key) {
             console.log(
-              "Unmapping " + binding.key + " in " + (binding.mode ?? "normal"),
+              `Unmapping ${binding.key} in ${binding.mode ?? "normal"}`,
             );
             Vim.unmap(binding.key, binding.mode ?? "normal");
           }
         });
         config.map?.forEach(({ map, to, mode }) => {
-          console.log(
-            "Mapping " + map + " to " + to + " for " + (mode ?? "normal"),
-          );
+          console.log(`Mapping ${map} to ${to} for ${mode ?? "normal"}`);
           Vim.map(map, to, mode ?? "normal");
         });
         config.noremap?.forEach(({ map, to, mode }) => {
-          console.log(
-            "Noremapping " + map + " to " + to + " for " + (mode ?? "normal"),
-          );
+          console.log(`Noremapping ${map} to ${to} for ${mode ?? "normal"}`);
           Vim.noremap(map, to, mode ?? "normal");
         });
         config.commands?.forEach(({ ex, command }) => {
-          console.log("Mapping command '" + command + "' to Ex " + ex);
-          Vim.defineEx(ex, "", () => client.runCommandByName(command));
+          console.log(`Mapping command '${command}' to Ex ${ex}`);
+          Vim.defineEx(ex, "", (_, params) =>
+            client.runCommandByName(command, params.args),
+          );
         });
       } else {
         console.log("No vim config found");
@@ -592,7 +595,7 @@ export function editorSyscalls(client: Client): SysCallMapping {
       client.startPageNavigate(mode);
     },
     "editor.openCommandPalette": () => {
-      client.startCommandPalette();
+      void client.startCommandPalette();
     },
     "editor.deleteLine": () => {
       deleteLine(client.editorView);
@@ -651,13 +654,13 @@ export function editorSyscalls(client: Client): SysCallMapping {
         }
       } catch (e) {
         console.error(e);
-        client.flashNotification(`Could not copy to clipboard: ${e}`);
+        client.ui.flashNotification(`Could not copy to clipboard: ${e}`);
       }
     },
     "editor.sendMessage": (_ctx, type: string, data: any) => {
-      if (!client.isDocumentEditor()) return;
+      if (!client.contentManager.isDocumentEditor()) return;
 
-      client.documentEditor.sendPublicMessage({
+      client.contentManager.documentEditor.sendPublicMessage({
         type,
         data,
       });

package/client/plugos/syscalls/event.ts

@@ -18,19 +18,16 @@ export function eventSyscalls(
     /**
      * Define a Lua event listener
      */
-    "event.listen": (
-      _ctx,
-      def: EventSubscription,
-    ) => {
+    "event.listen": (_ctx, def: EventSubscription) => {
       // console.log("Registering Lua event listener: ", def.name);
-      client.config.insert([
-        "eventListeners",
-        def.name,
-      ], async (...args: any[]) => {
-        // Convert return value to JS
-        const val = await def.run(...args);
-        return luaValueToJS(val, LuaStackFrame.lostFrame);
-      });
+      client.config.insert(
+        ["eventListeners", def.name],
+        async (...args: any[]) => {
+          // Convert return value to JS
+          const val = await def.run(...args);
+          return luaValueToJS(val, LuaStackFrame.lostFrame);
+        },
+      );
     },
   };
 }

package/client/plugos/syscalls/fetch.ts

@@ -12,9 +12,7 @@ import {
 } from "@silverbulletmd/silverbullet/lib/crypto";
 import { fsEndpoint } from "../../spaces/constants.ts";
 
-export function sandboxFetchSyscalls(
-  client: Client,
-): SysCallMapping {
+export function sandboxFetchSyscalls(client: Client): SysCallMapping {
   return {
     // For use in Lua
     "http.request": async (
@@ -25,17 +23,18 @@ export function sandboxFetchSyscalls(
       console.warn("Deprecated: use net.proxyFetch() instead");
       // JSONify any non-serializable body
       if (
-        options?.body && typeof options.body !== "string" &&
+        options?.body &&
+        typeof options.body !== "string" &&
         !(options.body instanceof Uint8Array)
       ) {
         options.body = JSON.stringify(options.body);
       }
       const fetchOptions = options
         ? {
-          method: options.method,
-          headers: {} as Record<string, string>,
-          body: options.body,
-        }
+            method: options.method,
+            headers: {} as Record<string, string>,
+            body: options.body,
+          }
         : {};
 
       fetchOptions.headers = buildProxyHeaders(options?.headers);
@@ -45,19 +44,27 @@ export function sandboxFetchSyscalls(
         fetchOptions,
       );
       // Do sensible things with the body based on the content type
+      // Read as ArrayBuffer first to safely handle empty responses (e.g.
+      // PUT/DELETE returning 204 with Content-Type: application/json).
+      // resp.arrayBuffer() never throws on an empty body, whereas
+      // resp.json() would throw a SyntaxError.
+      const rawBytes = new Uint8Array(await resp.arrayBuffer());
       let body: any;
-      const contentTypeHeader = options.responseEncoding ||
+      const contentTypeHeader =
+        options.responseEncoding ||
         resp.headers.get("x-proxy-header-content-type");
       const statusCode = +(resp.headers.get("x-proxy-status-code") || "200");
-      if (contentTypeHeader?.startsWith("application/json")) {
-        body = await resp.json();
+      if (rawBytes.length === 0) {
+        body = null;
+      } else if (contentTypeHeader?.startsWith("application/json")) {
+        body = JSON.parse(new TextDecoder().decode(rawBytes));
       } else if (
         contentTypeHeader?.startsWith("application/xml") ||
         contentTypeHeader?.startsWith("text/")
       ) {
-        body = await resp.text();
+        body = new TextDecoder().decode(rawBytes);
       } else {
-        body = new Uint8Array(await resp.arrayBuffer());
+        body = rawBytes;
       }
       return {
         ok: resp.ok,
@@ -74,15 +81,15 @@ export function sandboxFetchSyscalls(
       // console.log("Got sandbox fetch ", url, op);
       const fetchOptions = options
         ? {
-          method: options.method,
-          headers: options.headers,
-          body: options.base64Body && base64Decode(options.base64Body),
-        }
+            method: options.method,
+            headers: options.headers,
+            body: options.base64Body && base64Decode(options.base64Body),
+          }
         : {};
       fetchOptions.headers = buildProxyHeaders(options?.headers);
       const resp = await client.httpSpacePrimitives.authenticatedFetch(
         buildProxyUrl(client, url),
-        // Casting this to any because of weird Deno typing
+        // Casting to any due to TypeScript fetch type limitations
         fetchOptions as any,
       );
       const statusCode = +(resp.headers.get("x-proxy-status-code") || "200");
@@ -100,8 +107,11 @@ export function sandboxFetchSyscalls(
 function buildProxyUrl(client: Client, url: string) {
   url = url.replace(/^https?:\/\//, "");
   // Strip off the /.fs and replace with /.proxy
-  return client.httpSpacePrimitives.url.slice(0, -fsEndpoint.length) +
-    "/.proxy/" + url;
+  return (
+    client.httpSpacePrimitives.url.slice(0, -fsEndpoint.length) +
+    "/.proxy/" +
+    url
+  );
 }
 
 function buildProxyHeaders(headers?: Record<string, any>): Record<string, any> {
@@ -115,9 +125,7 @@ function buildProxyHeaders(headers?: Record<string, any>): Record<string, any> {
   return newHeaders;
 }
 
-function extractProxyHeaders(
-  headers: Headers,
-): Record<string, any> {
+function extractProxyHeaders(headers: Headers): Record<string, any> {
   const newHeaders: Record<string, any> = {};
   for (const [key, value] of headers.entries()) {
     if (key.toLowerCase().startsWith("x-proxy-header-")) {

package/client/plugos/syscalls/index.ts

@@ -20,7 +20,16 @@ export function indexSyscalls(
     "index.tag": (_ctx, tagName: string): LuaQueryCollection => {
       return objectIndex.tag(tagName);
     },
-    "index.ensureFullIndex": (_ctx) => {
+    "index.contentPages": (): LuaQueryCollection => {
+      return objectIndex.contentPages();
+    },
+    "index.metaPages": (): LuaQueryCollection => {
+      return objectIndex.metaPages();
+    },
+    "index.aggregates": (): LuaQueryCollection => {
+      return objectIndex.aggregates();
+    },
+    "index.ensureFullIndex": () => {
       return objectIndex.ensureFullIndex(client.space);
     },
     "index.reindexSpace": () => {

package/client/plugos/syscalls/jsonschema.ts

@@ -1,40 +1,62 @@
 import type { SysCallMapping } from "../system.ts";
-import { Ajv, type ValidateFunction } from "ajv";
+import { type OutputUnit, Validator, format } from "@cfworker/json-schema";
 
-const ajv = new Ajv();
+// Register custom formats
+format.email = (data: string) => data.includes("@");
+format["page-ref"] = (data: string) =>
+  data.startsWith("[[") && data.endsWith("]]");
 
-ajv.addFormat("email", {
-  validate: (data: string) => {
-    // TODO: Implement email validation
-    return data.includes("@");
-  },
-  async: false,
-});
+const schemaCache = new Map<string, Validator>();
 
-ajv.addFormat("page-ref", {
-  validate: (data: string) => {
-    return data.startsWith("[[") && data.endsWith("]]");
-  },
-  async: false,
-});
+/**
+ * Deep-clone a value, replacing any functions with null.
+ * JSON schema can't validate functions, so we strip them before validation.
+ */
+function stripFunctions(value: any): any {
+  if (typeof value === "function") return null;
+  if (value === null || value === undefined || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(stripFunctions);
+  }
+  const result: Record<string, any> = {};
+  for (const key of Object.keys(value)) {
+    result[key] = stripFunctions(value[key]);
+  }
+  return result;
+}
 
-const schemaCache = new Map<string, ValidateFunction>();
+function formatErrors(errors: OutputUnit[]): string {
+  // Filter out "properties" wrapper errors, keep only the specific leaf errors
+  const leafErrors = errors.filter((e) => e.keyword !== "properties");
+  const errorsToUse = leafErrors.length > 0 ? leafErrors : errors;
+
+  return errorsToUse
+    .map((e) => {
+      // Convert instanceLocation from "#/foo/bar" to "foo.bar"
+      const path =
+        e.instanceLocation === "#"
+          ? ""
+          : e.instanceLocation.slice(2).replaceAll("/", ".");
+      return path ? `${path}: ${e.error}` : e.error;
+    })
+    .join(", ");
+}
 
 export function validateObject(schema: any, object: any): undefined | string {
   try {
     const schemaKey = JSON.stringify(schema);
     if (!schemaCache.has(schemaKey)) {
-      const validate = ajv.compile(schema);
-      schemaCache.set(schemaKey, validate);
+      const validator = new Validator(schema, "7");
+      schemaCache.set(schemaKey, validator);
     }
-    const validate = schemaCache.get(schemaKey)!;
-    if (validate(object)) {
+    const validator = schemaCache.get(schemaKey)!;
+    const result = validator.validate(stripFunctions(object));
+    if (result.valid) {
       return;
     } else {
-      let text = ajv.errorsText(validate.errors);
-      text = text.replaceAll("/", ".");
-      text = text.replace(/^data[\.\s]/, "");
-      return text;
+      return formatErrors(result.errors);
     }
   } catch (e: any) {
     return e.message;
@@ -42,12 +64,33 @@ export function validateObject(schema: any, object: any): undefined | string {
 }
 
 export function validateSchema(schema: any): undefined | string {
-  const valid = ajv.validateSchema(schema);
-  if (valid) {
+  if (schema === null || schema === undefined) {
+    return "schema must not be null or undefined";
+  }
+  if (typeof schema === "boolean") {
     return;
-  } else {
-    return ajv.errorsText(ajv.errors);
   }
+  if (typeof schema !== "object" || Array.isArray(schema)) {
+    return "schema must be an object or boolean";
+  }
+  if (schema.type !== undefined) {
+    const validTypes = [
+      "string",
+      "number",
+      "integer",
+      "boolean",
+      "object",
+      "array",
+      "null",
+    ];
+    const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    for (const t of types) {
+      if (!validTypes.includes(t)) {
+        return `schema.type must be one of ${validTypes.join(", ")}`;
+      }
+    }
+  }
+  return;
 }
 
 export function jsonschemaSyscalls(): SysCallMapping {
@@ -59,10 +102,7 @@ export function jsonschemaSyscalls(): SysCallMapping {
     ): undefined | string => {
       return validateObject(schema, object);
     },
-    "jsonschema.validateSchema": (
-      _ctx,
-      schema: any,
-    ): undefined | string => {
+    "jsonschema.validateSchema": (_ctx, schema: any): undefined | string => {
       return validateSchema(schema);
     },
   };