@silverbulletmd/silverbullet 2.4.1

package/client/plugos/syscalls/space.ts

@@ -0,0 +1,139 @@
+import { parseToRef, type Ref } from "@silverbulletmd/silverbullet/lib/ref";
+import type { Client } from "../../client.ts";
+import type { SysCallMapping } from "../system.ts";
+
+import type {
+  DocumentMeta,
+  FileMeta,
+  PageMeta,
+} from "@silverbulletmd/silverbullet/type/index";
+
+export function spaceReadSyscalls(client: Client): SysCallMapping {
+  return {
+    "space.listPages": (): Promise<PageMeta[]> => {
+      return client.space.fetchPageList();
+    },
+    "space.readPage": async (_ctx, name: string): Promise<string> => {
+      return (await client.space.readPage(name)).text;
+    },
+    "space.readPageWithMeta": (
+      _ctx,
+      name: string,
+    ): Promise<{ text: string; meta: PageMeta }> => {
+      return client.space.readPage(name);
+    },
+    "space.readRef": async (_ctx, ref: string | Ref): Promise<string> => {
+      if (typeof ref === "string") {
+        ref = parseToRef(ref)!;
+        if (!ref) {
+          throw new Error(`Invalid ref: ${ref}`);
+        }
+      }
+      return (await client.space.readRef(ref)).text;
+    },
+    "space.pageExists": (_ctx, name: string): boolean => {
+      return client.clientSystem.allKnownFiles.has(name + ".md");
+    },
+    "space.getPageMeta": (_ctx, name: string): Promise<PageMeta> => {
+      return client.space.getPageMeta(name);
+    },
+    "space.listPlugs": (): Promise<FileMeta[]> => {
+      return client.space.listPlugs();
+    },
+    "space.listDocuments": async (): Promise<DocumentMeta[]> => {
+      return await client.space.fetchDocumentList();
+    },
+    "space.readDocument": async (_ctx, name: string): Promise<Uint8Array> => {
+      return (await client.space.readDocument(name)).data;
+    },
+    "space.getDocumentMeta": async (
+      _ctx,
+      name: string,
+    ): Promise<DocumentMeta> => {
+      return await client.space.getDocumentMeta(name);
+    },
+    // DEPRECATED, please use document versions instead, left here for backwards compatibility
+    "space.listAttachments": async (): Promise<DocumentMeta[]> => {
+      return await client.space.fetchDocumentList();
+    },
+    "space.readAttachment": async (_ctx, name: string): Promise<Uint8Array> => {
+      return (await client.space.readDocument(name)).data;
+    },
+    "space.getAttachmentMeta": async (
+      _ctx,
+      name: string,
+    ): Promise<DocumentMeta> => {
+      return await client.space.getDocumentMeta(name);
+    },
+    // FS
+    "space.listFiles": (): Promise<FileMeta[]> => {
+      return client.space.spacePrimitives.fetchFileList();
+    },
+    "space.getFileMeta": (_ctx, name: string): Promise<FileMeta> => {
+      return client.space.spacePrimitives.getFileMeta(name);
+    },
+    "space.readFile": async (_ctx, name: string): Promise<Uint8Array> => {
+      return (await client.space.spacePrimitives.readFile(name)).data;
+    },
+    "space.readFileWithMeta": async (
+      _ctx,
+      name: string,
+    ): Promise<{ data: Uint8Array; meta: FileMeta }> => {
+      return await client.space.spacePrimitives.readFile(name);
+    },
+    "space.fileExists": async (_ctx, name: string): Promise<boolean> => {
+      // If a full sync has successfully completed (so we know what files exist)
+      // and we have a snapshot, let's use the snapshot
+      if (
+        client.fullSyncCompleted &&
+        !client.eventedSpacePrimitives.isSnapshotEmpty()
+      ) {
+        return !!client.eventedSpacePrimitives.getSnapshot()[name];
+      }
+      try {
+        await client.space.spacePrimitives.getFileMeta(name);
+        // If this returned the file exists
+        return true;
+      } catch {
+        // Assumption: any error means the file does not exist
+        return false;
+      }
+    },
+  };
+}
+
+export function spaceWriteSyscalls(editor: Client): SysCallMapping {
+  return {
+    "space.writePage": (
+      _ctx,
+      name: string,
+      text: string,
+    ): Promise<PageMeta> => {
+      return editor.space.writePage(name, text);
+    },
+    "space.deletePage": async (_ctx, name: string) => {
+      console.log("Deleting page");
+      await editor.space.deletePage(name);
+    },
+    "space.writeDocument": (
+      _ctx,
+      name: string,
+      data: Uint8Array,
+    ): Promise<DocumentMeta> => {
+      return editor.space.writeDocument(name, data);
+    },
+    "space.deleteDocument": async (_ctx, name: string) => {
+      await editor.space.deleteDocument(name);
+    },
+    "space.writeFile": (
+      _ctx,
+      name: string,
+      data: Uint8Array,
+    ): Promise<FileMeta> => {
+      return editor.space.spacePrimitives.writeFile(name, data);
+    },
+    "space.deleteFile": (_ctx, name: string) => {
+      return editor.space.spacePrimitives.deleteFile(name);
+    },
+  };
+}

package/client/plugos/syscalls/sync.ts

@@ -0,0 +1,77 @@
+import type { SysCallMapping } from "../system.ts";
+import type { Client } from "../../client.ts";
+
+// TODO: Reimplement this
+export function syncSyscalls(client: Client): SysCallMapping {
+  return {
+    "sync.hasInitialSyncCompleted": (): boolean => {
+      return client.fullSyncCompleted;
+    },
+    "sync.performFileSync": (_ctx, path: string): Promise<void> => {
+      client.postServiceWorkerMessage({ type: "perform-file-sync", path });
+      return waitForServiceWorkerActivation(path);
+    },
+    "sync.performSpaceSync": (): Promise<number> => {
+      client.postServiceWorkerMessage({ type: "perform-space-sync" });
+      return waitForServiceWorkerActivation();
+    },
+  };
+}
+
+function waitForServiceWorkerActivation(path?: string): Promise<any> {
+  return new Promise<any>((resolve, reject) => {
+    client.eventHook.addLocalListener(
+      "service-worker:file-sync-complete",
+      eventHandler,
+    );
+    client.eventHook.addLocalListener(
+      "service-worker:space-sync-complete",
+      eventHandler,
+    );
+    client.eventHook.addLocalListener(
+      "service-worker:sync-error",
+      errorHandler,
+    );
+    function eventHandler(data: any) {
+      // If data.path is set, we are notified about a specific file sync -> all good, even for an individual file sync
+      // If data.path is not set, we are notified about a full space sync
+      // If we were waiting for a specific path, ignore other paths
+      if (data.path && path && data.path !== path) {
+        // Event for other file sync
+        return;
+      }
+      // If we were waiting for a specific path, ignore other paths
+      resolve(data);
+
+      // Unsubscribe from all these events
+      client.eventHook.removeLocalListener(
+        "service-worker:file-sync-complete",
+        eventHandler,
+      );
+      client.eventHook.removeLocalListener(
+        "service-worker:space-sync-complete",
+        eventHandler,
+      );
+      client.eventHook.removeLocalListener(
+        "service-worker:sync-error",
+        errorHandler,
+      );
+    }
+    function errorHandler(e: any) {
+      reject(e);
+      // Unsubscribe from all these events
+      client.eventHook.removeLocalListener(
+        "service-worker:file-sync-complete",
+        eventHandler,
+      );
+      client.eventHook.removeLocalListener(
+        "service-worker:space-sync-complete",
+        eventHandler,
+      );
+      client.eventHook.removeLocalListener(
+        "service-worker:sync-error",
+        errorHandler,
+      );
+    }
+  });
+}

package/client/plugos/syscalls/system.ts

@@ -0,0 +1,150 @@
+import type { SysCallMapping } from "../system.ts";
+import type { Client } from "../../client.ts";
+import { publicVersion } from "../../../public_version.ts";
+import type { CommandDef } from "@silverbulletmd/silverbullet/type/manifest";
+import type { SyscallMeta } from "@silverbulletmd/silverbullet/type/index";
+
+export function systemSyscalls(
+  client: Client,
+  readOnlyMode: boolean,
+): SysCallMapping {
+  const api: SysCallMapping = {
+    "system.invokeFunction": (
+      _ctx,
+      fullName: string, // plug.function
+      ...args: any[]
+    ) => {
+      const [plugName, functionName] = fullName.split(".");
+      if (!plugName || !functionName) {
+        throw Error(`Invalid function name ${fullName}`);
+      }
+      const plug = client.clientSystem.system.loadedPlugs.get(plugName);
+      if (!plug) {
+        throw Error(`Plug ${plugName} not found`);
+      }
+      const functionDef = plug.manifest!.functions[functionName];
+      if (!functionDef) {
+        throw Error(`Function ${functionName} not found`);
+      }
+      return plug.invoke(functionName, args);
+    },
+    "system.invokeFunctionOnServer": (
+      ctx,
+      fullName: string, // plug.function
+      ...args: any[]
+    ) => {
+      console.warn(
+        "Calling deprecated system.invokeFunctionOnServer, use system.invokeFunction instead",
+      );
+      return api["system.invokeFunction"](ctx, fullName, ...args);
+    },
+    "system.serverSyscall": (_ctx, name: string, ...args: any[]) => {
+      console.warn(
+        "Calling deprecated system.serverSyscall, use syscall instead",
+      );
+      return client.clientSystem.localSyscall(name, args);
+    },
+    "system.invokeCommand": (_ctx, name: string, args?: string[]) => {
+      console.warn("Deprecated, use editor.invokeCommand instead");
+      return client.runCommandByName(name, args);
+    },
+    "system.listCommands": (): { [key: string]: CommandDef } => {
+      const commandHook = client.clientSystem.commandHook;
+      const allCommands: { [key: string]: CommandDef } = {};
+      for (const [cmd, def] of commandHook.buildAllCommands()) {
+        allCommands[cmd] = {
+          name: def.name,
+          contexts: def.contexts,
+          priority: def.priority,
+          key: def.key,
+          mac: def.mac,
+          hide: def.hide,
+          requireMode: def.requireMode,
+        };
+      }
+      return allCommands;
+    },
+    "system.listSyscalls": (): SyscallMeta[] => {
+      const syscalls: SyscallMeta[] = [];
+      for (
+        const [name, info] of client.clientSystem.system.registeredSyscalls
+      ) {
+        syscalls.push({
+          name,
+          requiredPermissions: info.requiredPermissions,
+          argCount: Math.max(0, info.callback.length - 1),
+        });
+      }
+      return syscalls;
+    },
+    "system.reloadPlugs": () => {
+      if (!client) {
+        throw new Error("Not supported");
+      }
+      return client.loadPlugs();
+    },
+    "system.reloadConfig": (): Record<string, any> => {
+      console.warn("system.reloadConfig is deprecated, it's now a no-op");
+      return client.config.values;
+    },
+    "system.loadSpaceScripts": async () => {
+      console.warn("DEPRECATED: used system.loadScripts instead");
+      await client.clientSystem.loadLuaScripts();
+    },
+    "system.loadScripts": async () => {
+      await client.clientSystem.loadLuaScripts();
+    },
+    "system.loadSpaceStyles": async () => {
+      if (!client) {
+        throw new Error("Not supported on server");
+      }
+      await client.loadCustomStyles();
+    },
+    "system.wipeClient": async (_ctx, logout = false) => {
+      await client.wipeClient();
+      if (logout) {
+        location.href = ".logout";
+      } else {
+        alert("Client wiped, feel free to navigate elsewhere");
+      }
+    },
+    // DEPRECATED
+    "system.cleanDatabases": (): boolean => {
+      console.warn(
+        "system.cleanDatabses is deprecated, use Client: Wipe instead",
+      );
+      return false;
+    },
+    "system.getMode": () => {
+      return readOnlyMode ? "ro" : "rw";
+    },
+    "system.getURLPrefix": () => {
+      const url = new URL(document.baseURI);
+
+      return url.pathname;
+    },
+    "system.getBaseURI": () => {
+      return document.baseURI;
+    },
+    "system.getVersion": () => {
+      return publicVersion;
+    },
+    "system.getConfig": (_ctx, key: string, defaultValue: any = undefined) => {
+      return client.config.get(key, defaultValue);
+    },
+    // DEPRECATED
+    "system.getEnv": () => {
+      console.warn(
+        "system.getEnv is deprecated, you can assume the env to always be the client",
+      );
+      return null;
+    },
+    "system.getSpaceConfig": (_ctx, key, defaultValue?) => {
+      console.warn(
+        "system.getSpaceConfig is deprecated, use system.getConfig instead",
+      );
+      return client.config.get(key, defaultValue);
+    },
+  };
+  return api;
+}

package/client/plugos/system.ts

@@ -0,0 +1,201 @@
+import type { Hook } from "./types.ts";
+import { EventEmitter } from "./event.ts";
+import type { SandboxFactory } from "./sandboxes/sandbox.ts";
+import { Plug } from "./plug.ts";
+import { InMemoryManifestCache, type ManifestCache } from "./manifest_cache.ts";
+import {
+  builtinPlugNames,
+  builtinPlugPaths,
+} from "../../plugs/builtin_plugs.ts";
+
+export interface SysCallMapping {
+  [key: string]: (ctx: SyscallContext, ...args: any) => Promise<any> | any;
+}
+
+export type SystemEvents<HookT> = {
+  plugLoaded: (plug: Plug<HookT>) => void | Promise<void>;
+  plugUnloaded: (name: string) => void | Promise<void>;
+};
+
+// Passed to every syscall, allows to pass in additional context that the syscall may use
+export type SyscallContext = {
+  // This is the plug that is invoking the syscall,
+  // which may be undefined where this cannot be determined (e.g. when running in a NoSandbox)
+  plug?: string;
+};
+
+type SyscallSignature = (
+  ...args: any[]
+) => Promise<any> | any;
+
+type Syscall = {
+  requiredPermissions: string[];
+  callback: SyscallSignature;
+};
+
+export type SystemOptions = {
+  manifestCache?: ManifestCache<any>;
+  plugFlushTimeout?: number;
+};
+
+export class System<HookT> extends EventEmitter<SystemEvents<HookT>> {
+  registeredSyscalls = new Map<string, Syscall>();
+  protected plugs = new Map<string, Plug<HookT>>();
+  protected enabledHooks = new Set<Hook<HookT>>();
+
+  /**
+   * @param env either an environment or undefined for hybrid mode
+   */
+  constructor(
+    readonly env: string | undefined = undefined,
+    readonly options: SystemOptions = {},
+  ) {
+    super();
+    if (!options.manifestCache) {
+      options.manifestCache = new InMemoryManifestCache();
+    }
+  }
+
+  get loadedPlugs(): Map<string, Plug<HookT>> {
+    return this.plugs;
+  }
+
+  addHook(feature: Hook<HookT>) {
+    this.enabledHooks.add(feature);
+    feature.apply(this);
+  }
+
+  registerSyscalls(
+    requiredCapabilities: string[],
+    ...registrationObjects: SysCallMapping[]
+  ) {
+    for (const registrationObject of registrationObjects) {
+      for (const [name, callback] of Object.entries(registrationObject)) {
+        this.registeredSyscalls.set(name, {
+          requiredPermissions: requiredCapabilities,
+          callback,
+        });
+      }
+    }
+  }
+
+  /**
+   * Invokes a function named using the "plug.functionName" pattern, for convenience
+   * @param name name of the function (e.g. plug.doSomething)
+   * @param args an array of arguments to pass to the function
+   */
+  invokeFunction(name: string, args: any[]): Promise<any> {
+    // Some sanity type checks
+    if (typeof name !== "string") {
+      throw new Error(
+        `invokeFunction: function name should be a string, got ${typeof name}`,
+      );
+    }
+    if (!Array.isArray(args)) {
+      throw new Error(
+        `invokeFunction: args should be an array, got ${typeof args}`,
+      );
+    }
+    const [plugName, functionName] = name.split(".");
+    if (!functionName) {
+      // Sanity check
+      throw new Error(`Missing function name: ${name}`);
+    }
+    const plug = this.loadedPlugs.get(plugName);
+    if (!plug) {
+      throw new Error(`Plug ${plugName} not found invoking ${name}`);
+    }
+    return plug.invoke(functionName, args);
+  }
+
+  localSyscall(name: string, args: any[]): Promise<any> {
+    return this.syscall({}, name, args);
+  }
+
+  syscall(
+    ctx: SyscallContext,
+    name: string,
+    args: any[],
+  ): Promise<any> {
+    const syscall = this.registeredSyscalls.get(name);
+    if (!syscall) {
+      throw Error(`Unregistered syscall ${name}`);
+    }
+    if (ctx.plug) {
+      // Only when running in a plug context do we check permissions
+      const plug = this.loadedPlugs.get(ctx.plug);
+      if (!plug) {
+        throw new Error(
+          `Plug ${ctx.plug} not found while attempting to invoke ${name}}`,
+        );
+      }
+      for (const permission of syscall.requiredPermissions) {
+        if (!plug.grantedPermissions.includes(permission)) {
+          throw Error(`Missing permission '${permission}' for syscall ${name}`);
+        }
+      }
+    }
+    return Promise.resolve(syscall.callback(ctx, ...args));
+  }
+
+  /**
+   * @param cacheKey Used to cache the manifest of the worker. Should be equal to the filepath
+   * @param cacheHash Used to determine if the manifest is up to date. Should be `lastModified`
+   */
+  async loadPlug(
+    sandboxFactory: SandboxFactory<HookT>,
+    cacheKey: string,
+    cacheHash: number = -1,
+  ): Promise<Plug<HookT>> {
+    const plug = await Plug.createLazily(
+      this,
+      cacheKey,
+      cacheHash,
+      sandboxFactory,
+    );
+
+    const manifest = plug.manifest;
+
+    // This depends on cacheKey being the file path
+    if (
+      !builtinPlugPaths.includes(cacheKey) &&
+      builtinPlugNames.includes(manifest.name)
+    ) {
+      plug.stop();
+      throw new Error("Plug tried to overwrite internal plug");
+    }
+
+    // Validate the manifest
+    let errors: string[] = [];
+    for (const feature of this.enabledHooks) {
+      errors = [...errors, ...feature.validateManifest(manifest)];
+    }
+    if (errors.length > 0) {
+      throw new Error(`Invalid manifest: ${errors.join(", ")}`);
+    }
+    if (this.plugs.has(manifest.name)) {
+      this.unload(manifest.name);
+    }
+    console.log("Activated plug", manifest.name);
+    this.plugs.set(manifest.name, plug);
+
+    await this.emit("plugLoaded", plug);
+    return plug;
+  }
+
+  unload(name: string) {
+    const plug = this.plugs.get(name);
+    if (!plug) {
+      return;
+    }
+    plug.stop();
+    this.emit("plugUnloaded", name);
+    this.plugs.delete(name);
+  }
+
+  unloadAll(): Promise<void[]> {
+    return Promise.all(
+      Array.from(this.plugs.keys()).map(this.unload.bind(this)),
+    );
+  }
+}

package/client/plugos/types.ts

@@ -0,0 +1,60 @@
+import type { System } from "./system.ts";
+import type { AssetJson } from "../asset_bundle/bundle.ts";
+
+/** The generic top level of a plug manifest file.
+ * Defines plug metadata and functions.
+ */
+export interface Manifest<HookT> {
+  /** The plug's name. Typically this is the name of the manifest file, without the file extension. */
+  name: string;
+
+  /** A list of syscall permissions required for this plug to function.
+   *
+   * Possible values:
+   * - `fetch`: enables `fetch` function. (see: plug-api/plugos-syscall/fetch.ts, and plug-api/lib/fetch.ts)
+   * - `shell`: enables the `shell.run` syscall. (see: plug-api/plugos-syscall/shell.ts)
+   */
+  requiredPermissions?: string[];
+
+  /** A list of files or glob patterns that should be bundled with the plug.
+   *
+   * These files will be accessible through the `asset.readAsset` function.
+   *
+   * see: plug-api/plugos-syscall/asset.ts#readAsset
+   */
+  assets?: string[] | AssetJson;
+
+  /** A map of function names to definitions. Declared functions are public, and may be associated with various hooks
+   *
+   * see: common/manifest.ts#SilverBulletHooks
+   */
+  functions: Record<string, FunctionDef<HookT>>;
+
+  /**
+   * A map of configuration options for the plug (to be merged with the system configuration).
+   */
+  config?: any;
+}
+
+/** Associates hooks with a function. This is the generic base structure, that identifies the function. Hooks are defined by the type parameter. */
+export type FunctionDef<HookT> = {
+  /** A function path, in the form `${relativeFilename}:${functionName}`.
+   *
+   * During compilation (see `../build_plugs.ts`) the function is read from the file and inlined into the plug bundle.
+   *
+   * This field and `FunctionDef.redirect` are mutually exclusive.
+   */
+  path?: string;
+
+  /** A function from another plug, in the form `${plugName}.${functionName}` that will be attached to the given hooks. */
+  redirect?: string;
+
+  /** Environments where this plug is allowed to run, current may be one of "cli", "server", or "client". */
+  env?: string;
+} & HookT;
+
+export interface Hook<HookT> {
+  validateManifest(manifest: Manifest<HookT>): string[];
+
+  apply(system: System<HookT>): void;
+}

package/client/plugos/util.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks if an object is sendable across the plugos worker boundary.
+ *
+ * @param o - The object to check.
+ * @returns `true` if the object is sendable, `false` otherwise.
+ */
+export function isSendable(o: any): boolean {
+  try {
+    structuredClone(o);
+    return true;
+  } catch {
+    return false;
+  }
+}