@silverbulletmd/silverbullet 2.5.3 → 2.7.0

package/plug-api/syscalls/jsonschema.ts

@@ -18,8 +18,6 @@ export function validateObject(
  * @param schema the JSON schema to validate
  * @returns an error message if the schema is invalid, or undefined if it is valid
  */
-export function validateSchema(
-  schema: any,
-): Promise<string | undefined> {
+export function validateSchema(schema: any): Promise<string | undefined> {
   return syscall("jsonschema.validateSchema", schema);
 }

package/plug-api/syscalls/lua.ts

@@ -1,20 +1,14 @@
 import { syscall } from "../syscall.ts";
 import type { LuaBlock, LuaExpression } from "../../client/space_lua/ast.ts";
 
-export function parse(
-  code: string,
-): Promise<LuaBlock> {
+export function parse(code: string): Promise<LuaBlock> {
   return syscall("lua.parse", code);
 }
 
-export function parseExpression(
-  expression: string,
-): Promise<LuaExpression> {
+export function parseExpression(expression: string): Promise<LuaExpression> {
   return syscall("lua.parseExpression", expression);
 }
 
-export function evalExpression(
-  expression: string,
-): Promise<any> {
+export function evalExpression(expression: string): Promise<any> {
   return syscall("lua.evalExpression", expression);
 }

package/plug-api/syscalls/mq.ts

@@ -21,10 +21,7 @@ export function send(queue: string, body: any): Promise<void> {
  * @param queue the name of the queue
  * @param bodies the bodies of the messages to send
  */
-export function batchSend(
-  queue: string,
-  bodies: any[],
-): Promise<void> {
+export function batchSend(queue: string, bodies: any[]): Promise<void> {
   return syscall("mq.batchSend", queue, bodies);
 }
 

package/plug-api/syscalls/shell.ts

@@ -4,11 +4,14 @@ import { syscall } from "../syscall.ts";
  * Runs a shell command.
  * @param cmd the command to run
  * @param args the arguments to pass to the command
+ * @param stdin optional string to pass as stdin to the command
  * @returns the stdout, stderr, and exit code of the command
  */
 export function run(
   cmd: string,
   args: string[],
+  stdin?: string,
 ): Promise<{ stdout: string; stderr: string; code: number }> {
-  return syscall("shell.run", cmd, args);
+  return syscall("shell.run", cmd, args, stdin);
 }
+

package/plug-api/syscalls/space.ts

@@ -44,9 +44,7 @@ export function pageExists(name: string): Promise<boolean> {
  * @param name the name of the page to read
  * @returns the text of the page
  */
-export function readPage(
-  name: string,
-): Promise<string> {
+export function readPage(name: string): Promise<string> {
   return syscall("space.readPage", name);
 }
 
@@ -111,9 +109,7 @@ export function getDocumentMeta(name: string): Promise<DocumentMeta> {
  * @param name path of the document to read
  * @returns the document data as a UInt8Array
  */
-export function readDocument(
-  name: string,
-): Promise<Uint8Array> {
+export function readDocument(name: string): Promise<Uint8Array> {
   return syscall("space.readDocument", name);
 }
 
@@ -192,10 +188,7 @@ export function getFileMeta(name: string): Promise<FileMeta> {
  * @param data the data of the file to write
  * @returns the metadata for the written file
  */
-export function writeFile(
-  name: string,
-  data: Uint8Array,
-): Promise<FileMeta> {
+export function writeFile(name: string, data: Uint8Array): Promise<FileMeta> {
   return syscall("space.writeFile", name, data);
 }
 

package/plug-api/syscalls/system.ts

@@ -13,10 +13,7 @@ import type { SyscallMeta } from "@silverbulletmd/silverbullet/type/index";
  * @param args arguments to pass to the function
  * @returns
  */
-export function invokeFunction(
-  name: string,
-  ...args: any[]
-): Promise<any> {
+export function invokeFunction(name: string, ...args: any[]): Promise<any> {
   return syscall("system.invokeFunction", name, ...args);
 }
 
@@ -54,6 +51,21 @@ export function reloadPlugs(): Promise<void> {
   return syscall("system.reloadPlugs");
 }
 
+/**
+ * Load (or reload) a single plug from a space file path.
+ */
+export function loadPlug(path: string): Promise<void> {
+  return syscall("system.loadPlug", path);
+}
+
+/**
+ * Unload a plug previously loaded from the given space file path.
+ * Returns true if a plug was unloaded.
+ */
+export function unloadPlug(path: string): Promise<boolean> {
+  return syscall("system.unloadPlug", path);
+}
+
 /**
  * Returns the current mode of the system, either "ro" (read-only) or "rw" (read-write)
  */

package/plug-api/syscalls/yaml.ts

@@ -10,9 +10,7 @@ import { syscall } from "../syscall.ts";
  * @param text the YAML text to parse
  * @returns a JavaScript object representation of the YAML text
  */
-export function parse(
-  text: string,
-): Promise<any> {
+export function parse(text: string): Promise<any> {
   return syscall("yaml.parse", text);
 }
 
@@ -21,8 +19,6 @@ export function parse(
  * @param obj the object to stringify
  * @returns a YAML string representation of the object
  */
-export function stringify(
-  obj: any,
-): Promise<string> {
+export function stringify(obj: any): Promise<string> {
   return syscall("yaml.stringify", obj);
 }

package/plug-api/types/client.ts

@@ -11,11 +11,26 @@ export type FilterOption = {
   prefix?: string;
 } & Record<string, any>;
 
+export type NotificationType = "info" | "error" | "warning";
+
+export const notificationDismissTimeouts: Record<NotificationType, number> = {
+  info: 4000,
+  error: 5000,
+  warning: 8000,
+};
+
+export type NotificationAction = {
+  name: string;
+  run: () => void;
+};
+
 export type Notification = {
   id: number;
   message: string;
-  type: "info" | "error";
+  type: NotificationType;
   date: Date;
+  actions?: NotificationAction[];
+  persistent?: boolean;
 };
 
 export type PanelMode = number;

package/plug-api/types/event.ts

@@ -21,7 +21,9 @@ export type EventSubscription = EventSubscriptionDef & {
   run: (...args: any[]) => Promise<any>;
 };
 
-export type ResolvedPlug = {
-  code: string;
-  name?: string; // This will only dictate the filename
-} | string;
+export type ResolvedPlug =
+  | {
+      code: string;
+      name?: string; // This will only dictate the filename
+    }
+  | string;

package/plug-api/types/manifest.ts

@@ -6,6 +6,48 @@ export type CodeWidgetT = {
   renderMode?: "iframe";
 };
 
+/**
+ * Predefined native menu items. Ignored in PWA builds; used by the
+ * SilverBullet desktop app to emit OS-native menu items (Cut/Copy/Paste,
+ * Quit, About, etc.) instead of a command-dispatching item.
+ */
+export type PredefinedMenuKind =
+  | "quit" | "about" | "services" | "hide" | "hideOthers" | "showAll"
+  | "closeWindow" | "minimize" | "maximize" | "fullscreen"
+  | "separator"
+  | "undo" | "redo" | "cut" | "copy" | "paste" | "selectAll";
+
+/**
+ * A single native-menu placement for a command or submenu.
+ * Desktop-app only; ignored in PWA builds.
+ *
+ * - `location`: id of the target menu or submenu (e.g. "file",
+ *   "edit.format").
+ * - `group`: sort-prefix convention "1_new", "2_dashboard", "9_close". Items
+ *   are partitioned by group within a location; groups sort alphabetically
+ *   with separators auto-inserted between them.
+ * - `order`: ascending within a group; tiebreak by label.
+ * - `label`: overrides the command's display label in the menu only.
+ * - `predefined`: emit an OS-native predefined item instead of a
+ *   command-dispatching item.
+ * - `icon`: optional icon identifier; platform support varies.
+ */
+export type MenuContribution = {
+  location: string;
+  group?: string;
+  order?: number;
+  label?: string;
+  predefined?: PredefinedMenuKind;
+  icon?: string;
+};
+
+/**
+ * A menu placement value: a single contribution, an array (multiple
+ * placements), or `null` (hide this entry on the matching platform).
+ * Desktop-app only.
+ */
+export type MenuPlacement = MenuContribution | MenuContribution[] | null;
+
 export type CommandDef = {
   name: string;
 
@@ -21,6 +63,27 @@ export type CommandDef = {
   hide?: boolean;
   requireMode?: "rw" | "ro";
   requireEditor?: "any" | "page" | "notpage" | string;
+
+  // When true, this binding is NOT registered while vim mode is active,
+  // so the key falls through to vim.
+  disableInVim?: boolean;
+
+  /**
+   * Desktop-app only. Native menu placement for this command.
+   *
+   * Naming note: the existing `key`/`mac` pair uses a bare platform name
+   * for the override. That pattern doesn't extend cleanly here — bare
+   * `mac` is already taken by the keybinding override, and `windows` /
+   * `linux` as top-level fields would be ambiguous. The `menu` + capital
+   * platform suffix pattern keeps overrides unambiguous.
+   */
+  menu?: MenuPlacement;
+  /** Platform-specific override: replaces `menu` on macOS. */
+  menuMac?: MenuPlacement;
+  /** Platform-specific override: replaces `menu` on Windows. */
+  menuWindows?: MenuPlacement;
+  /** Platform-specific override: replaces `menu` on Linux. */
+  menuLinux?: MenuPlacement;
 };
 export type CommandHookT = {
   command?: CommandDef;
@@ -81,15 +144,14 @@ export type DocumentEditorT = {
  *
  * related: plugos/ui_types.ts#FunctionDef
  */
-export type SilverBulletHooks =
-  & CommandHookT
-  & SlashCommandHookT
-  & MQHookT
-  & EventHookT
-  & CodeWidgetT
-  & PlugNamespaceHookT
-  & DocumentEditorT
-  & SyscallHookT;
+export type SilverBulletHooks = CommandHookT &
+  SlashCommandHookT &
+  MQHookT &
+  EventHookT &
+  CodeWidgetT &
+  PlugNamespaceHookT &
+  DocumentEditorT &
+  SyscallHookT;
 
 /** A plug manifest configures hooks, declares syntax extensions, and describes plug metadata.
  *

package/plugs/builtin_plugs.ts

@@ -4,11 +4,11 @@ export const builtinPlugNames = [
   "editor",
   "index",
   "sync",
-  "plug-manager",
   "emoji",
   "image-viewer",
+  "configuration-manager",
 ];
 
-export const builtinPlugPaths = builtinPlugNames.map((name) =>
-  `Library/Std/Plugs/${name}.plug.js`
+export const builtinPlugPaths = builtinPlugNames.map(
+  (name) => `Library/Std/Plugs/${name}.plug.js`,
 );

package/client/plugos/sandboxes/web_worker_sandbox.ts

@@ -1,17 +0,0 @@
-import { WorkerSandbox } from "./worker_sandbox.ts";
-import type { Plug } from "../plug.ts";
-import type { SandboxFactory } from "./sandbox.ts";
-import { fsEndpoint } from "../../spaces/constants.ts";
-
-export function createWorkerSandboxFromLocalPath<HookT>(
-  name: string,
-): SandboxFactory<HookT> {
-  return (plug: Plug<HookT>) =>
-    new WorkerSandbox(
-      plug,
-      new URL(
-        name,
-        `${document.baseURI.slice(0, -1) + fsEndpoint}/`, // We're NOT striping trailing '/', this used to be `location.origin`
-      ),
-    );
-}

package/dist/worker_runtime_bundle.js

@@ -1,233 +0,0 @@
-// plug-api/lib/crypto.ts
-function base64Decode(s) {
-  const binString = atob(s);
-  const len = binString.length;
-  const bytes = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    bytes[i] = binString.charCodeAt(i);
-  }
-  return bytes;
-}
-function base64Encode(buffer) {
-  if (typeof buffer === "string") {
-    buffer = new TextEncoder().encode(buffer);
-  }
-  let binary = "";
-  const len = buffer.byteLength;
-  for (let i = 0; i < len; i++) {
-    binary += String.fromCharCode(buffer[i]);
-  }
-  return btoa(binary);
-}
-var fixedCounter = new Uint8Array(16);
-
-// client/lib/logger.ts
-var Logger = class {
-  constructor(prefix = "", maxCaptureSize = 1e3) {
-    this.prefix = prefix;
-    this.maxCaptureSize = maxCaptureSize;
-    this.prefix = prefix;
-    this.originalConsole = {
-      log: console.log.bind(console),
-      info: console.info.bind(console),
-      warn: console.warn.bind(console),
-      error: console.error.bind(console),
-      debug: console.debug.bind(console)
-    };
-    this.patchConsole();
-  }
-  originalConsole;
-  logBuffer = [];
-  patchConsole() {
-    const createPatchedMethod = (level) => {
-      return (...args) => {
-        const prefixedArgs = this.prefix ? [this.prefix, ...args] : args;
-        this.originalConsole[level](...prefixedArgs);
-        this.captureLog(level, args);
-      };
-    };
-    console.log = createPatchedMethod("log");
-    console.info = createPatchedMethod("info");
-    console.warn = createPatchedMethod("warn");
-    console.error = createPatchedMethod("error");
-    console.debug = createPatchedMethod("debug");
-  }
-  captureLog(level, args) {
-    const entry = {
-      level,
-      timestamp: Date.now(),
-      message: args.map((arg) => {
-        if (typeof arg === "string") {
-          return arg;
-        }
-        try {
-          return JSON.stringify(arg);
-        } catch {
-          return String(arg);
-        }
-      }).join(" ")
-    };
-    this.logBuffer.push(entry);
-    if (this.logBuffer.length > this.maxCaptureSize) {
-      this.logBuffer.shift();
-    }
-  }
-  /**
-   * Posts all buffered logs to a server endpoint
-   */
-  async postToServer(logEndpoint, source) {
-    const logs = this.logBuffer;
-    if (logs.length > 0) {
-      const logCopy = [...this.logBuffer];
-      this.logBuffer = [];
-      try {
-        const resp = await fetch(logEndpoint, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(logCopy.map((entry) => ({ ...entry, source })))
-        });
-        if (!resp.ok) {
-          throw new Error("Failed to post logs to server");
-        }
-      } catch (e) {
-        console.warn("Could not post logs to server", e.message);
-        this.logBuffer.unshift(...logCopy);
-      }
-    }
-  }
-};
-var globalLogger;
-function initLogger(prefix = "") {
-  globalLogger = new Logger(prefix);
-  return globalLogger;
-}
-
-// client/plugos/worker_runtime.ts
-var workerPostMessage = (_msg) => {
-  throw new Error("Not initialized yet");
-};
-var runningAsWebWorker = typeof window === "undefined" && // @ts-expect-error: globalThis
-typeof globalThis.WebSocketPair === "undefined";
-var pendingRequests = /* @__PURE__ */ new Map();
-var syscallReqId = 0;
-if (runningAsWebWorker) {
-  globalThis.syscall = async (name, ...args) => {
-    return await new Promise((resolve, reject) => {
-      syscallReqId++;
-      pendingRequests.set(syscallReqId, { resolve, reject });
-      workerPostMessage({
-        type: "sys",
-        id: syscallReqId,
-        name,
-        args
-      });
-    });
-  };
-}
-function setupMessageListener(functionMapping, manifest, postMessageFn) {
-  if (!runningAsWebWorker) {
-    return;
-  }
-  workerPostMessage = postMessageFn;
-  self.addEventListener("message", (event) => {
-    (async () => {
-      const data = event.data;
-      switch (data.type) {
-        case "inv":
-          {
-            const fn = functionMapping[data.name];
-            if (!fn) {
-              throw new Error(`Function not loaded: ${data.name}`);
-            }
-            try {
-              const result = await Promise.resolve(fn(...data.args || []));
-              workerPostMessage({
-                type: "invr",
-                id: data.id,
-                result
-              });
-            } catch (e) {
-              console.error(
-                "An exception was thrown as a result of invoking function",
-                data.name,
-                "error:",
-                e.message
-              );
-              workerPostMessage({
-                type: "invr",
-                id: data.id,
-                error: e.message
-              });
-            }
-          }
-          break;
-        case "sysr":
-          {
-            const syscallId = data.id;
-            const lookup = pendingRequests.get(syscallId);
-            if (!lookup) {
-              throw Error("Invalid request id");
-            }
-            pendingRequests.delete(syscallId);
-            if (data.error) {
-              lookup.reject(new Error(data.error));
-            } else {
-              lookup.resolve(data.result);
-            }
-          }
-          break;
-      }
-    })().catch(console.error);
-  });
-  workerPostMessage({
-    type: "manifest",
-    manifest
-  });
-  initLogger(`[${manifest.name} plug]`);
-}
-async function sandboxFetch(reqInfo, options) {
-  if (typeof reqInfo !== "string") {
-    const body = new Uint8Array(await reqInfo.arrayBuffer());
-    const encodedBody = body.length > 0 ? base64Encode(body) : void 0;
-    options = {
-      method: reqInfo.method,
-      headers: Object.fromEntries(reqInfo.headers.entries()),
-      base64Body: encodedBody
-    };
-    reqInfo = reqInfo.url;
-  }
-  return syscall("sandboxFetch.fetch", reqInfo, options);
-}
-globalThis.nativeFetch = globalThis.fetch;
-function monkeyPatchFetch() {
-  globalThis.fetch = async (reqInfo, init) => {
-    const encodedBody = init?.body ? base64Encode(
-      new Uint8Array(await new Response(init.body).arrayBuffer())
-    ) : void 0;
-    const r = await sandboxFetch(
-      reqInfo,
-      init && {
-        method: init.method,
-        headers: init.headers,
-        base64Body: encodedBody
-      }
-    );
-    return new Response(
-      r.base64Body ? base64Decode(r.base64Body) : null,
-      {
-        status: r.status,
-        headers: r.headers
-      }
-    );
-  };
-}
-if (runningAsWebWorker) {
-  monkeyPatchFetch();
-}
-export {
-  monkeyPatchFetch,
-  sandboxFetch,
-  setupMessageListener
-};