@silverbulletmd/silverbullet 2.10.0 → 2.11.0

package/client/plugos/syscalls/sync.ts

@@ -1,8 +1,13 @@
-import type { SysCallMapping } from "../system.ts";
 import type { Client } from "../../client.ts";
+import type { SysCallMapping } from "../system.ts";
 
 export function syncSyscalls(client: Client): SysCallMapping {
   const syncTimeoutMs = 30000;
+  // Deferring indexing only pays off while the sync engine is actually
+  // delivering files. Once it has gone this long without reporting progress
+  // there is nothing left to yield to, and continuing to defer would stall
+  // the initial index forever.
+  const syncStallMs = 5000;
 
   function waitForServiceWorkerActivation(path?: string): Promise<any> {
     return new Promise<any>((resolve, reject) => {
@@ -70,14 +75,47 @@ export function syncSyscalls(client: Client): SysCallMapping {
         { type: "boolean", description: "Whether initial sync is complete." },
       ],
     },
+    "sync.areFilesReadyToIndex": {
+      callback: (_ctx, paths: string[]): boolean[] => {
+        const allReady =
+          !!client.bootConfig.disableServiceWorker ||
+          client.fullSyncCompleted ||
+          client.fullIndexCompleted ||
+          (client.serverPingMs !== undefined && client.serverPingMs < 25) ||
+          Date.now() - client.lastSyncProgressAt > syncStallMs;
+        return paths.map((path) => allReady || client.syncedPaths.has(path));
+      },
+      description:
+        "For each file, whether indexing it now would read it locally or cheaply (true), or race the initial sync and expensively re-download it (false).",
+      parameters: [
+        {
+          name: "paths",
+          type: "string[]",
+          description: "Space-relative file paths.",
+        },
+      ],
+      returns: [
+        {
+          type: "boolean[]",
+          description: "Per-path readiness, in input order.",
+        },
+      ],
+    },
     "sync.performFileSync": {
-      callback: async (_ctx, path: string): Promise<void> => {
+      callback: async (
+        _ctx,
+        path: string,
+        remoteLastModified?: number,
+        remoteRevisionHash?: string,
+      ): Promise<void> => {
         await client.postServiceWorkerMessage({
           type: "perform-file-sync",
           path,
+          remoteLastModified,
+          remoteRevisionHash,
         });
         // postServiceWorkerMessage returns silently if no SW, so only wait if SW is active
-        const registration = await navigator.serviceWorker.getRegistration();
+        const registration = await navigator.serviceWorker?.getRegistration();
         if (registration?.active) {
           return waitForServiceWorkerActivation(path);
         }
@@ -90,13 +128,27 @@ export function syncSyscalls(client: Client): SysCallMapping {
           type: "string",
           description: "Space-relative file path.",
         },
+        {
+          name: "remoteLastModified",
+          type: "number",
+          optional: true,
+          description:
+            "lastModified of the remote change event, used for echo suppression.",
+        },
+        {
+          name: "remoteRevisionHash",
+          type: "string",
+          optional: true,
+          description:
+            "Content revision the remote change event reported, which tells a same-millisecond change from an echo.",
+        },
       ],
       examples: [{ code: 'sync.performFileSync("notes/important.md")' }],
     },
     "sync.performSpaceSync": {
       callback: async (): Promise<number> => {
         await client.postServiceWorkerMessage({ type: "perform-space-sync" });
-        const registration = await navigator.serviceWorker.getRegistration();
+        const registration = await navigator.serviceWorker?.getRegistration();
         if (registration?.active) {
           return waitForServiceWorkerActivation();
         }

package/client/plugos/syscalls/system.ts

@@ -3,6 +3,11 @@ import type { Client } from "../../client.ts";
 import { version as publicVersion } from "../../../version.json";
 import type { CommandDef } from "@silverbulletmd/silverbullet/type/manifest";
 import type { SyscallMeta } from "@silverbulletmd/silverbullet/type/index";
+import { loadAccounts, loadProfile } from "../../accounts.ts";
+import type {
+  Account,
+  ClientProfile,
+} from "../../../plug-api/types/profile.ts";
 
 export function systemSyscalls(
   client: Client,
@@ -97,6 +102,27 @@ export function systemSyscalls(
       description:
         "Returns a map of every currently available command definition.",
     },
+    "system.listPaletteCommands": {
+      callback: () => client.listPaletteCommands(),
+      description: `Returns the commands the command palette would show right now: context- and mode-filtered, hidden ones dropped, each with its prettified key hint and the time it was last run on this client.`,
+      signatures: ["system.listPaletteCommands()"],
+    },
+    "system.runPaletteCommand": {
+      callback: async (_ctx, name: string) => {
+        await client.registerCommandRun(name);
+        try {
+          return await client.runCommandByName(name);
+        } catch (e: any) {
+          client.reportError(e, "Command invocation");
+          return false;
+        }
+      },
+      description: `Runs a command as if it had been picked from the command palette: records it as the most recently run, then invokes it and returns its result. A command that throws is reported to the user and answered as false, which in this protocol means "do not move focus on my behalf".`,
+      parameters: [
+        { name: "name", type: "string", description: "Command name." },
+      ],
+      returns: [{ description: "Whatever the command returned." }],
+    },
     "system.listSyscalls": {
       callback: (): SyscallMeta[] => {
         const syscalls: SyscallMeta[] = [];
@@ -226,6 +252,18 @@ export function systemSyscalls(
       callback: () => publicVersion,
       description: "Returns the running SilverBullet version.",
     },
+    "system.getProfile": {
+      callback: (): Promise<ClientProfile> => loadProfile(client),
+      description:
+        'The current user\'s identity. `username` is "me" when the server has no account for this session.',
+      signatures: ["system.getProfile()"],
+    },
+    "system.listAccounts": {
+      callback: (): Promise<Account[]> => loadAccounts(client),
+      description:
+        "Every account with access to this space, with the current user marked.",
+      signatures: ["system.listAccounts()"],
+    },
     "system.getConfig": {
       callback: (_ctx, key: string, defaultValue: any = undefined) =>
         client.config.get(key, defaultValue),

package/client/plugos/system.ts

@@ -2,7 +2,7 @@ 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 type { ManifestCache } from "./manifest_cache.ts";
 import {
   builtinPlugNames,
   builtinPlugPaths,
@@ -55,7 +55,12 @@ export class System<HookT> extends EventEmitter<SystemEvents<HookT>> {
   ) {
     super();
     if (!options.manifestCache) {
-      options.manifestCache = new InMemoryManifestCache();
+      options.manifestCache = {
+        async getManifest(plug) {
+          await plug.sandbox.init();
+          return plug.sandbox.manifest!;
+        },
+      };
     }
   }
 
@@ -99,7 +104,6 @@ export class System<HookT> extends EventEmitter<SystemEvents<HookT>> {
    * @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}`,
@@ -112,7 +116,6 @@ export class System<HookT> extends EventEmitter<SystemEvents<HookT>> {
     }
     const [plugName, functionName] = name.split(".");
     if (!functionName) {
-      // Sanity check
       throw new Error(`Missing function name: ${name}`);
     }
     const plug = this.loadedPlugs.get(plugName);
@@ -169,7 +172,6 @@ export class System<HookT> extends EventEmitter<SystemEvents<HookT>> {
       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)];

package/client/plugos/worker_runtime.ts

@@ -112,7 +112,6 @@ export function setupMessageListener(
       }
     })().catch(console.error);
   });
-  // Signal initialization with manifest
   workerPostMessage({
     type: "manifest",
     manifest,
@@ -139,7 +138,6 @@ export async function sandboxFetch(
 
 globalThis.nativeFetch = globalThis.fetch;
 
-// Monkey patch fetch()
 export function monkeyPatchFetch() {
   // @ts-expect-error: monkey patching fetch
   globalThis.fetch = async (

package/client/space_lua/aggregates.ts

@@ -112,7 +112,6 @@ function covarIterate(state: CovarState, x: any, y: any): CovarState {
   return state;
 }
 
-// Quantile interpolation methods
 type QuantileMethod =
   | "linear" // percentile_cont
   | "lower" // percentile_disc
@@ -126,7 +125,6 @@ interface QuantileState {
   method: QuantileMethod;
 }
 
-// Default method based on aggregate invocation name
 const quantileNameDefaults: Record<string, QuantileMethod> = {
   percentile_cont: "linear",
   percentile_disc: "lower",
@@ -159,7 +157,6 @@ function quantileFinish(state: QuantileState): number | null {
   }
 }
 
-// Shared spec — branching on `ctx.name` for the default method
 function makeQuantileSpec(name: string, description: string): AggregateSpec {
   return {
     name,
@@ -187,9 +184,7 @@ function makeQuantileSpec(name: string, description: string): AggregateSpec {
   };
 }
 
-// Built-in aggregate specs
 const builtinAggregates: Record<string, AggregateSpec> = {
-  // General purpose
   count: {
     name: "count",
     description:
@@ -299,7 +294,6 @@ const builtinAggregates: Record<string, AggregateSpec> = {
       return value;
     }),
   },
-  // Collection and format
   array_agg: {
     name: "array_agg",
     description: "Input values concatenated into an array",
@@ -365,7 +359,6 @@ const builtinAggregates: Record<string, AggregateSpec> = {
       return JSON.stringify(state);
     }),
   },
-  // Bitwise and boolean
   bit_and: {
     name: "bit_and",
     description: "Bitwise AND of all non-null input values",
@@ -447,7 +440,6 @@ const builtinAggregates: Record<string, AggregateSpec> = {
       return state.hasValue ? state.result : null;
     }),
   },
-  // Statistical
   stddev_pop: {
     name: "stddev_pop",
     description: "Population standard deviation of non-null inputs",
@@ -558,7 +550,6 @@ const builtinAggregates: Record<string, AggregateSpec> = {
       return state.bestCount > 0 ? state.best : null;
     }),
   },
-  // Quantile and percentile
   quantile: makeQuantileSpec(
     "quantile",
     "Quantile of ordered set of non-null inputs; arguments: value, quantile (0-1), interpolation ('lower', 'higher', 'nearest', 'midpoint' and default: 'linear')",
@@ -617,14 +608,12 @@ export function getAggregateSpec(
     const spec: any = config.get(`aggregates.${current}`, null);
     if (!spec) break;
 
-    // Check for alias redirect
     const alias = spec instanceof LuaTable ? spec.rawGet("alias") : spec.alias;
     if (typeof alias === "string") {
       current = alias;
       continue;
     }
 
-    // Full definition in config
     let candidate: AggregateSpec | null = null;
     if (spec instanceof LuaTable) {
       const init = spec.rawGet("initialize");
@@ -700,16 +689,13 @@ export async function executeAggregate(
     }
   }
 
-  // Initialize
   let state = await luaCall(spec.initialize, [ctx, ...extraArgs], noCtx, sf);
 
-  // Collect filtered items
   const filteredItems: LuaValue[] = [];
   const len = items.length;
   for (let i = 1; i <= len; i++) {
     const item = items.rawGet(i);
 
-    // Filter
     if (filterExpr) {
       const filterEnv = buildItemEnv(objectVariable, item, env, sf);
       const filterResult = await evalExprFn(filterExpr, filterEnv, sf);
@@ -747,7 +733,6 @@ export async function executeAggregate(
     });
   }
 
-  // Iterate
   for (const item of filteredItems) {
     const itemEnv = buildItemEnv(objectVariable, item, env, sf);
     let value: LuaValue;
@@ -773,7 +758,6 @@ export async function executeAggregate(
     );
   }
 
-  // Finish
   if (spec.finish) {
     state = await luaCall(spec.finish, [state, ctx, ...extraArgs], noCtx, sf);
   }

package/client/space_lua/ast.ts

@@ -38,7 +38,6 @@ export type LuaComment = {
   ctx: ASTCtx;
 };
 
-// STATEMENTS
 export type LuaReturnStatement = {
   type: "Return";
   expressions: LuaExpression[];
@@ -177,7 +176,6 @@ export type LuaFunctionCallStatement = {
   call: LuaFunctionCallExpression;
 } & ASTContext;
 
-// EXPRESSIONS
 export type LuaExpression =
   | LuaNilLiteral
   | LuaBooleanLiteral
@@ -294,21 +292,18 @@ export type LuaFunctionDefinition = {
   body: LuaFunctionBody;
 } & ASTContext;
 
-// Aggregate with per-row filter
 export type LuaFilteredCallExpression = {
   type: "FilteredCall";
   call: LuaFunctionCallExpression;
   filter: LuaExpression;
 } & ASTContext;
 
-// Aggregate call with intra-aggregate order by
 export type LuaAggregateCallExpression = {
   type: "AggregateCall";
   call: LuaFunctionCallExpression;
   orderBy: LuaOrderBy[];
 } & ASTContext;
 
-// Query stuff
 export type LuaQueryExpression = {
   type: "Query";
   clauses: LuaQueryClause[];

package/client/space_lua/ast_narrow.ts

@@ -2,13 +2,11 @@
 
 import type { ASTCtx, LuaExpression, LuaLValue, LuaStatement } from "./ast.ts";
 
-// Extract by `type` discriminant
 type NarrowByType<
   U,
   K extends U extends { type: infer T } ? T : never,
 > = Extract<U, { type: K }>;
 
-// Expressions
 export const asStringExpr = (e: LuaExpression) =>
   e as NarrowByType<LuaExpression, "String">;
 export const asNumberExpr = (e: LuaExpression) =>
@@ -38,7 +36,6 @@ export const asFunctionDef = (e: LuaExpression) =>
 export const asQueryExpr = (e: LuaExpression) =>
   e as NarrowByType<LuaExpression, "Query">;
 
-// L-values
 export const asLValueVariable = (l: LuaLValue) =>
   l as Extract<LuaLValue, { type: "Variable" }>;
 export const asLValueTableAccess = (l: LuaLValue) =>
@@ -46,7 +43,6 @@ export const asLValueTableAccess = (l: LuaLValue) =>
 export const asLValuePropertyAccess = (l: LuaLValue) =>
   l as Extract<LuaLValue, { type: "PropertyAccess" }>;
 
-// Statements
 export const asAssignment = (s: LuaStatement) =>
   s as NarrowByType<LuaStatement, "Assignment">;
 export const asLocal = (s: LuaStatement) =>
@@ -79,5 +75,4 @@ export const asGoto = (s: LuaStatement) =>
 export const asSemicolon = (s: LuaStatement) =>
   s as NarrowByType<LuaStatement, "Semicolon">;
 
-// Pull ctx with a single shape
 export const ctxOf = (node: { ctx: ASTCtx }): ASTCtx => node.ctx;

package/client/space_lua/budget.ts

@@ -0,0 +1,113 @@
+export const BUDGET_TICKS = 5000;
+export const YIELD_AFTER_MS = 500;
+export const YIELD_EVERY_MS = 50;
+export const YIELD_COUNT_LIMIT = 200;
+export const BUSY_LIMIT_DEFAULT_MS = 2000;
+export const BUSY_LIMIT_COMMAND_MS = 10000;
+export const KEEP_GOING_MS = 10000;
+
+export class LuaBudgetStopped extends Error {
+  constructor() {
+    super("Script stopped by the user");
+    this.name = "LuaBudgetStopped";
+  }
+}
+
+export type LuaBudget = {
+  ticks: number;
+  lastCheck: number;
+  lastYield: number;
+  busyMs: number;
+  yieldCount: number;
+  awaited: boolean;
+  stopped: boolean;
+  /** Set once the invocation this budget was created for has completed. */
+  finished: boolean;
+  limitReported: boolean;
+  busyLimitMs: number;
+  yieldAfterMs: number;
+  onLimit: ((b: LuaBudget) => void) | undefined;
+  now: () => number;
+  doYield: () => Promise<void>;
+};
+
+export function macrotaskYield(): Promise<void> {
+  // Do NOT use scheduler.yield() here: it resumes at a *higher* priority than
+  // ordinary tasks, so it never lets timers/input/rendering run and defeats
+  // the whole point of yielding. MessageChannel posts a genuine macrotask.
+  if (typeof MessageChannel === "function") {
+    return new Promise<void>((resolve) => {
+      const ch = new MessageChannel();
+      ch.port1.onmessage = () => {
+        ch.port1.close();
+        resolve();
+      };
+      ch.port2.postMessage(undefined);
+    });
+  }
+  return new Promise<void>((resolve) => setTimeout(resolve, 0));
+}
+
+export function makeLuaBudget(
+  opts: Partial<
+    Pick<
+      LuaBudget,
+      "busyLimitMs" | "yieldAfterMs" | "onLimit" | "now" | "doYield"
+    >
+  > = {},
+): LuaBudget {
+  const now = opts.now ?? (() => performance.now());
+  return {
+    ticks: BUDGET_TICKS,
+    lastCheck: now(),
+    lastYield: now(),
+    busyMs: 0,
+    yieldCount: 0,
+    awaited: false,
+    stopped: false,
+    finished: false,
+    limitReported: false,
+    busyLimitMs: opts.busyLimitMs ?? BUSY_LIMIT_DEFAULT_MS,
+    yieldAfterMs: opts.yieldAfterMs ?? YIELD_AFTER_MS,
+    onLimit: opts.onLimit,
+    now,
+    doYield: opts.doYield ?? macrotaskYield,
+  };
+}
+
+export function budgetTick(b: LuaBudget): Promise<void> | undefined {
+  if (b.stopped) {
+    throw new LuaBudgetStopped();
+  }
+  b.ticks = BUDGET_TICKS;
+
+  const now = b.now();
+  const sinceCheck = now - b.lastCheck;
+  b.lastCheck = now;
+  if (b.awaited) {
+    b.awaited = false;
+  } else {
+    b.busyMs += sinceCheck;
+  }
+
+  if (
+    !b.limitReported &&
+    (b.busyMs >= b.busyLimitMs || b.yieldCount >= YIELD_COUNT_LIMIT)
+  ) {
+    b.limitReported = true;
+    b.onLimit?.(b);
+  }
+
+  const threshold = b.yieldCount === 0 ? b.yieldAfterMs : YIELD_EVERY_MS;
+  if (now - b.lastYield < threshold) {
+    return undefined;
+  }
+  b.lastYield = now;
+  b.yieldCount++;
+  // The event-loop turn spent yielding (rendering, sync, other scripts) must
+  // not be billed to this script's busyMs at the next tick, so re-read the
+  // clock on resume rather than trusting the pre-yield lastCheck.
+  return b.doYield().then(() => {
+    b.lastCheck = b.now();
+  });
+}

package/client/space_lua/budget_ui.ts

@@ -0,0 +1,49 @@
+import { KEEP_GOING_MS, type LuaBudget } from "./budget.ts";
+
+export type BudgetNotifier = {
+  flashNotification(
+    message: string,
+    type?: string,
+    options?: {
+      timeout?: number;
+      actions?: { name: string; run: () => void }[];
+    },
+  ): void;
+};
+
+export function offerStopNotification(
+  ui: BudgetNotifier,
+  message: string,
+  budget: LuaBudget,
+  onStop?: () => void,
+): void {
+  ui.flashNotification(message, "warning", {
+    timeout: 0,
+    actions: [
+      {
+        name: "Stop",
+        run: () => {
+          // The script may have finished running (this toast is persistent)
+          // between the limit tripping and the user clicking Stop; don't
+          // quarantine a script that isn't running anymore.
+          if (budget.finished) {
+            return;
+          }
+          budget.stopped = true;
+          onStop?.();
+        },
+      },
+      {
+        name: "Keep going",
+        run: () => {
+          budget.busyLimitMs = budget.busyMs + KEEP_GOING_MS;
+          // Resetting to 0 would restore the 500ms first-yield threshold,
+          // making the tab unresponsive again right after the user asked
+          // to continue.
+          budget.yieldCount = 1;
+          budget.limitReported = false;
+        },
+      },
+    ],
+  });
+}