@silverbulletmd/silverbullet 2.10.0 → 2.12.0

package/client/plugos/syscalls/index.ts

@@ -1,16 +1,16 @@
-import type { SysCallMapping } from "../system.ts";
-import type {
-  LuaCollectionQuery,
-  LuaQueryCollection,
-} from "../../space_lua/query_collection.ts";
+import type { ObjectValue } from "@silverbulletmd/silverbullet/type/index";
+import type { Client } from "../../client.ts";
 
 import {
   type ObjectIndex,
   ObjectValidationError,
 } from "../../data/object_index.ts";
-import type { ObjectValue } from "@silverbulletmd/silverbullet/type/index";
-import type { Client } from "../../client.ts";
+import type {
+  LuaCollectionQuery,
+  LuaQueryCollection,
+} from "../../space_lua/query_collection.ts";
 import type { LuaTable } from "../../space_lua/runtime.ts";
+import type { SysCallMapping } from "../system.ts";
 import { describeSchemas, tagSchema } from "./schema_introspection.ts";
 
 export function indexSyscalls(
@@ -18,7 +18,6 @@ export function indexSyscalls(
   client: Client,
 ): SysCallMapping {
   return {
-    // Query collection API
     "index.tag": {
       callback: (_ctx, tagName: string): LuaQueryCollection => {
         return objectIndex.objectsWithTag(tagName);
@@ -63,10 +62,12 @@ export function indexSyscalls(
       description: "Returns all indexed links as a query collection.",
     },
     "index.relations": {
-      callback: (): LuaQueryCollection => {
-        return objectIndex.objectsWithTag("relation");
+      callback: (_ctx, kind?: string): LuaQueryCollection => {
+        return objectIndex.relations(kind);
       },
-      description: "Returns all indexed relations as a query collection.",
+      description:
+        "Returns all indexed relations, optionally filtered by kind, as a query collection.",
+      signatures: ["index.relations(kind?)"],
     },
     "index.contentPages": {
       callback: (_ctx, tagName?: string): LuaQueryCollection => {
@@ -128,7 +129,6 @@ export function indexSyscalls(
       },
       description: "Returns all indexed tag objects as a query collection.",
     },
-    // Schema introspection: indexed object-type / tag schemas
     "index.describeSchema": {
       callback: (): Record<string, unknown> => {
         return describeSchemas(client.config.get(["tags"], {}));
@@ -144,6 +144,13 @@ export function indexSyscalls(
         "Returns the raw JSON Schema for a tag, or nil when none is declared.",
       signatures: ["index.tagSchema(tagName)"],
     },
+    "index.isAvailable": {
+      callback: (): Promise<boolean> => objectIndex.isIndexAvailable(),
+      description: `Whether a full indexing pass has ever completed for this space. False on a fresh client, and for as long as the first index takes on a large one: every object query answers with whatever has been indexed so far, which is nothing to begin with. Code that must work in that window reads the space directly instead.`,
+      returns: [
+        { type: "boolean", description: "Whether the index can be trusted." },
+      ],
+    },
     "index.aspiringPages": {
       callback: (): LuaQueryCollection => {
         return objectIndex.aspiringPages();
@@ -151,7 +158,13 @@ export function indexSyscalls(
       description:
         "Returns linked but not yet created pages as a query collection.",
     },
-    // Internals
+    "index.ambiguousLinks": {
+      callback: (): LuaQueryCollection => {
+        return objectIndex.ambiguousLinks();
+      },
+      description:
+        "Returns links whose page name matches more than one page as a query collection.",
+    },
     "index.aggregates": {
       callback: (): LuaQueryCollection => {
         return objectIndex.aggregates();
@@ -246,6 +259,13 @@ export function indexSyscalls(
       signatures: ["index.queryLuaObjects(tag, query, scopedVariables?)"],
     },
 
+    "index.clearFileIndex": {
+      callback: (_ctx, path: string): Promise<void> =>
+        objectIndex.clearFileIndex(path),
+      description:
+        "Drops every indexed object belonging to a file, so a re-index replaces them rather than merging on top.",
+      signatures: ["index.clearFileIndex(path)"],
+    },
     "index.deleteObject": {
       callback: (
         _ctx,

package/client/plugos/syscalls/jsonschema.ts

@@ -2,7 +2,6 @@ import type { SysCallMapping } from "../system.ts";
 import { type OutputUnit, Validator, format } from "@cfworker/json-schema";
 import { stripFunctions } from "../util.ts";
 
-// Register custom formats
 format.email = (data: string) => data.includes("@");
 format["page-ref"] = (data: string) =>
   data.startsWith("[[") && data.endsWith("]]");

package/client/plugos/syscalls/mq.ts

@@ -14,7 +14,6 @@ export function mqSyscalls(mq: DataStoreMQ): SysCallMapping {
     "mq.subscribe": {
       callback: (_ctx, def: MQListenerSpec) => {
         def.autoAck = def.autoAck !== false;
-        // console.log("Registering Lua event listener: ", def.name);
         client.config.insert(["mqSubscriptions", def.queue], def);
       },
       description: "Subscribes a Space Lua callback to a message queue.",

package/client/plugos/syscalls/navigator.ts

@@ -0,0 +1,138 @@
+import {
+  defineView,
+  focusPanel,
+  moveByRename,
+  openView,
+  pickView,
+} from "../../navigator/navigator.ts";
+import { newView } from "../../navigator/view_value.ts";
+import type { SysCallMapping } from "../system.ts";
+
+export function navigatorSyscalls(): SysCallMapping {
+  const viewSyscalls: SysCallMapping = {
+    "view.open": {
+      callback: (_ctx, name: string, opts?: any) => {
+        return openView(name, opts);
+      },
+      description: "Opens a navigator view by name.",
+      parameters: [
+        { name: "name", type: "string", description: "View name." },
+        {
+          name: "opts",
+          type: "table",
+          description:
+            "Optional segment, phrase, dropdown, focus and quiet flags.",
+          optional: true,
+        },
+      ],
+      returns: [
+        { type: "boolean", description: "Whether the view actually opened." },
+      ],
+      examples: [{ code: 'view.open("std.spaceTree")' }],
+    },
+    "view.focus": {
+      callback: (_ctx, slot?: string) => focusPanel(slot),
+      description:
+        "Returns focus to an open navigator panel's input, keeping its current selection.",
+      parameters: [
+        {
+          name: "slot",
+          type: "string",
+          description:
+            "Which panel: modal, lhs, rhs or bhs. Defaults to any open one.",
+          optional: true,
+        },
+      ],
+      returns: [
+        { type: "boolean", description: "Whether a panel was there to focus." },
+      ],
+      examples: [{ code: 'view.focus("rhs")' }],
+    },
+    "view.moveByRename": {
+      callback: (_ctx, obj: any, newName: string) => {
+        return moveByRename(obj, newName);
+      },
+      description:
+        "Renames the page, document or folder an object stands for -- the default `onMove` for space-backed views.",
+      parameters: [
+        { name: "obj", type: "table", description: "The row's object." },
+        { name: "newName", type: "string", description: "New name." },
+      ],
+      examples: [{ code: "onMove = view.moveByRename" }],
+    },
+    "lua:widget.newLive": {
+      callback: (_ctx, spec: any) => newView(spec),
+      description:
+        "Internal: builds a live widget for `widget.new` when its spec has `source` or `content`. Call `widget.new` instead.",
+      parameters: [
+        {
+          name: "spec",
+          type: "table",
+          description: "A `widget.new` spec with `source` or `content`.",
+        },
+      ],
+      returns: [{ type: "table", description: "The live widget value." }],
+    },
+    "lua:view.define": {
+      callback: (_ctx, spec: any) => {
+        return defineView(spec);
+      },
+      description:
+        "Registers a navigator view, and optionally a command that opens it. Rejects a bad spec at definition time.",
+      parameters: [
+        {
+          name: "spec",
+          type: "table",
+          description: "View definition; see the Navigator API docs.",
+        },
+      ],
+      examples: [
+        {
+          code: 'view.define {\n  name = "myView",\n  source = function() return {} end,\n  onSelect = function(obj) editor.navigate(obj.ref) end,\n}',
+        },
+      ],
+    },
+    "lua:view.pick": {
+      callback: (_ctx, spec: any) => {
+        return pickView(spec);
+      },
+      description:
+        "Opens a one-shot picker over the supplied source and returns the object picked (or nil).",
+      parameters: [
+        {
+          name: "spec",
+          type: "table",
+          description:
+            "Picker definition; a view.define spec minus its name and chrome.",
+        },
+      ],
+      returns: [{ description: "The picked object, or nil." }],
+      examples: [
+        {
+          code: 'local picked = view.pick { source = function() return { { name = "One" } } end }',
+        },
+      ],
+    },
+  };
+
+  return {
+    ...viewSyscalls,
+    ...aliasNamespace(viewSyscalls, "view", "navigator"),
+  };
+}
+
+function aliasNamespace(
+  mapping: SysCallMapping,
+  from: string,
+  to: string,
+): SysCallMapping {
+  const aliased: SysCallMapping = {};
+  for (const [name, definition] of Object.entries(mapping)) {
+    const isLuaNative = name.startsWith("lua:");
+    const cleanName = isLuaNative ? name.slice("lua:".length) : name;
+    if (!cleanName.startsWith(`${from}.`)) continue;
+    const aliasedName = `${to}.${cleanName.slice(from.length + 1)}`;
+    aliased[isLuaNative ? `lua:${aliasedName}` : aliasedName] = definition;
+  }
+  return aliased;
+}

package/client/plugos/syscalls/search.ts

@@ -0,0 +1,44 @@
+import type { SysCallMapping } from "../system.ts";
+import { rank, type RankOptions } from "../../../plug-api/lib/fuzzy.ts";
+
+export function searchSyscalls(): SysCallMapping {
+  return {
+    "search.rank": {
+      callback: (
+        _ctx,
+        objects: Record<string, any>[],
+        phrase: string,
+        options?: {
+          fields?: Record<
+            string,
+            number | { weight: number; segments?: boolean }
+          >;
+        },
+      ) => rank(objects, phrase, options as RankOptions<any>),
+      description:
+        "Fuzzy-ranks objects against a phrase, best match first. The same ranker the navigator's own filtering uses.",
+      parameters: [
+        { name: "objects", type: "table", description: "Objects to rank." },
+        {
+          name: "phrase",
+          type: "string",
+          description:
+            "Phrase to match against. An empty phrase returns every object, in the order given.",
+        },
+        {
+          name: "options",
+          type: "table",
+          description:
+            "Ranking options. `fields` maps a field name to its weight, or to `{ weight, segments = true }` to also score the parts of a `/`-separated value.",
+          optional: true,
+        },
+      ],
+      returns: [
+        {
+          type: "table",
+          description: "The matching objects, best match first.",
+        },
+      ],
+    },
+  };
+}

package/client/plugos/syscalls/shell.ts

@@ -62,6 +62,5 @@ export function shellSyscalls(client: Client): SysCallMapping {
 }
 
 function buildShellUrl(client: Client) {
-  // Strip off the /.fs and replace with /.shell
   return `${client.httpSpacePrimitives.url.slice(0, -fsEndpoint.length)}/.shell`;
 }

package/client/plugos/syscalls/space.ts

@@ -1,15 +1,120 @@
-import { parseToRef, type Ref } from "@silverbulletmd/silverbullet/lib/ref";
-import type { Client } from "../../client.ts";
-import type { SysCallMapping } from "../system.ts";
-
+import {
+  encodePageURI,
+  type Path,
+  parseToRef,
+  type Ref,
+} from "@silverbulletmd/silverbullet/lib/ref";
+import { fileName } from "@silverbulletmd/silverbullet/lib/resolve";
+import {
+  BasenameIndex,
+  type PathLookup,
+  resolvePath,
+} from "@silverbulletmd/silverbullet/lib/resolve_path";
 import type {
   DocumentMeta,
   FileMeta,
   PageMeta,
 } from "@silverbulletmd/silverbullet/type/index";
+import type {
+  FileRevisions,
+  GitSyncSnapshot,
+  GitConflicts,
+  GitConflictAction,
+  SpaceLog,
+} from "@silverbulletmd/silverbullet/type/revisions";
+import type { Client } from "../../client.ts";
+import { fsEndpoint } from "../../spaces/constants.ts";
+import type { SysCallMapping } from "../system.ts";
+
+function revisionsUrl(client: Client, suffix: string): string {
+  return `${client.httpSpacePrimitives.url.slice(0, -fsEndpoint.length)}/.revisions/${suffix}`;
+}
+
+async function fetchRevisionsJson(
+  client: Client,
+  suffix: string,
+  body?: unknown,
+): Promise<any> {
+  const resp = await client.httpSpacePrimitives.authenticatedFetch(
+    revisionsUrl(client, suffix),
+    {
+      method: body === undefined ? "GET" : "POST",
+      headers: {
+        Accept: "application/json",
+        ...(body === undefined ? {} : { "Content-Type": "application/json" }),
+      },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    },
+  );
+  if (resp.status === 404) {
+    throw Object.assign(
+      new Error("Revisions are not available for this space"),
+      { status: resp.status },
+    );
+  }
+  if (!resp.ok) {
+    throw Object.assign(new Error(`Revisions request failed: ${resp.status}`), {
+      status: resp.status,
+    });
+  }
+  return resp.json();
+}
+
+/**
+ * The index resolution syscalls answer from. The client's own index is only
+ * trustworthy once the file list has loaded; before that, ask the space
+ * directly rather than reporting everything as missing.
+ */
+async function resolutionIndex(client: Client): Promise<BasenameIndex> {
+  if (client.clientSystem.knownFilesLoaded) {
+    return client.clientSystem.allKnownFiles;
+  }
+  const listing = new BasenameIndex();
+  listing.rebuild(
+    (await client.space.spacePrimitives.fetchFileList()).map((f) => f.name),
+  );
+  return listing;
+}
 
 export function spaceReadSyscalls(client: Client): SysCallMapping {
   return {
+    "space.getGitSyncStatus": {
+      callback: (): Promise<GitSyncSnapshot> =>
+        fetchRevisionsJson(client, "_sync"),
+      description: "Reads Git sync status and its last successful check.",
+    },
+    "space.getGitConflictVersion": {
+      callback: async (
+        _ctx,
+        id: string,
+        generation: string,
+        side: "local" | "remote",
+      ): Promise<Uint8Array> => {
+        if (side !== "local" && side !== "remote")
+          throw new Error("Unknown conflict side");
+        const response = await client.httpSpacePrimitives.authenticatedFetch(
+          revisionsUrl(
+            client,
+            `_conflicts/${encodeURIComponent(id)}/${side}?generation=${encodeURIComponent(generation)}`,
+          ),
+          { method: "GET" },
+        );
+        if (!response.ok)
+          throw Object.assign(
+            new Error("Could not read this conflict version"),
+            { status: response.status },
+          );
+        return new Uint8Array(await response.arrayBuffer());
+      },
+      description: "Downloads one original side of an unresolved Git conflict.",
+      signatures: ["space.getGitConflictVersion(id, generation, side)"],
+    },
+    "space.getGitConflicts": {
+      callback: (): Promise<GitConflicts> =>
+        fetchRevisionsJson(client, "_conflicts"),
+      description:
+        "Lists unresolved Git conflicts with saved content versions.",
+    },
     "space.listPages": {
       callback: (): Promise<PageMeta[]> => client.space.fetchPageList(),
       description: "Lists all pages in the space.",
@@ -46,7 +151,7 @@ export function spaceReadSyscalls(client: Client): SysCallMapping {
     },
     "space.pageExists": {
       callback: (_ctx, name: string): boolean =>
-        client.clientSystem.allKnownFiles.has(`${name}.md`),
+        resolvePath(`${name}.md`, "", client.clientSystem.allKnownFiles).exists,
       description: "Checks whether a page exists in the space.",
       signatures: ["space.pageExists(name)"],
     },
@@ -98,7 +203,6 @@ export function spaceReadSyscalls(client: Client): SysCallMapping {
       deprecated: "Use space.getDocumentMeta instead.",
       signatures: ["space.getAttachmentMeta(name)"],
     },
-    // FS
     "space.listFiles": {
       callback: (): Promise<FileMeta[]> =>
         client.space.spacePrimitives.fetchFileList(),
@@ -125,6 +229,33 @@ export function spaceReadSyscalls(client: Client): SysCallMapping {
       description: "Reads an arbitrary space file together with its metadata.",
       signatures: ["space.readFileWithMeta(name)"],
     },
+    "space.collidingBasenames": {
+      callback: async (): Promise<Record<string, Path[]>> =>
+        (await resolutionIndex(client)).collidingBuckets(),
+      description:
+        "Returns every basename carried by more than one file, with the files carrying it.",
+      signatures: ["space.collidingBasenames()"],
+    },
+    "space.lookupPaths": {
+      callback: async (
+        _ctx,
+        paths: string[],
+      ): Promise<Record<string, PathLookup>> => {
+        const index = await resolutionIndex(client);
+
+        const result: Record<string, PathLookup> = {};
+        for (const path of paths) {
+          result[path] = {
+            exact: index.has(path),
+            candidates: index.candidates(fileName(path)),
+          };
+        }
+        return result;
+      },
+      description:
+        "Looks up, for each path, whether it exists exactly and which files share its basename.",
+      signatures: ["space.lookupPaths(paths)"],
+    },
     "space.fileExists": {
       callback: async (_ctx, name: string): Promise<boolean> => {
         // If a full sync has successfully completed (so we know what files exist)
@@ -137,7 +268,6 @@ export function spaceReadSyscalls(client: Client): SysCallMapping {
         }
         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
@@ -147,11 +277,103 @@ export function spaceReadSyscalls(client: Client): SysCallMapping {
       description: "Checks whether an arbitrary file exists in the space.",
       signatures: ["space.fileExists(name)"],
     },
+    "space.listRevisions": {
+      callback: (_ctx, path: string, before?: string): Promise<FileRevisions> =>
+        fetchRevisionsJson(
+          client,
+          `${encodePageURI(path)}${before ? `?before=${before}` : ""}`,
+        ),
+      description: "Lists the revision history of a file.",
+      signatures: ["space.listRevisions(path, before?)"],
+    },
+    "space.getRevision": {
+      callback: async (
+        _ctx,
+        path: string,
+        rev: string,
+        parent?: boolean,
+      ): Promise<string> => {
+        const resp = await client.httpSpacePrimitives.authenticatedFetch(
+          revisionsUrl(
+            client,
+            `${encodePageURI(path)}?rev=${rev}${parent ? "&parent=1" : ""}`,
+          ),
+          { method: "GET" },
+        );
+        if (!resp.ok) {
+          throw Object.assign(
+            new Error(`Could not load revision: ${resp.status}`),
+            { status: resp.status },
+          );
+        }
+        return resp.text();
+      },
+      description:
+        "Reads the text of a file as it was at a given revision, or at that revision's parent.",
+      signatures: ["space.getRevision(path, rev, parent?)"],
+    },
+    "space.getRevisionDiff": {
+      callback: async (_ctx, path: string, rev?: string): Promise<string> => {
+        const resp = await client.httpSpacePrimitives.authenticatedFetch(
+          revisionsUrl(
+            client,
+            `${encodePageURI(path)}?${rev ? `rev=${rev}&` : ""}format=diff`,
+          ),
+          { method: "GET" },
+        );
+        if (!resp.ok) {
+          throw Object.assign(
+            new Error(`Could not load revision diff: ${resp.status}`),
+            { status: resp.status },
+          );
+        }
+        return resp.text();
+      },
+      description:
+        "Reads a unified diff of a revision's own change (vs its parent), or of the uncommitted change when no revision is given.",
+      signatures: ["space.getRevisionDiff(path, rev?)"],
+    },
+    "space.getSpaceLog": {
+      callback: (_ctx, before?: string, q?: string): Promise<SpaceLog> => {
+        const params: string[] = [];
+        if (before) params.push(`before=${before}`);
+        if (q) params.push(`q=${encodeURIComponent(q)}`);
+        return fetchRevisionsJson(
+          client,
+          params.length ? `?${params.join("&")}` : "",
+        );
+      },
+      description: "Lists the space-wide commit log.",
+      signatures: ["space.getSpaceLog(before?, q?)"],
+    },
   };
 }
 
 export function spaceWriteSyscalls(editor: Client): SysCallMapping {
   return {
+    "space.syncGitNow": {
+      callback: () => fetchRevisionsJson(editor, "_sync", {}),
+      description: "Requests sync on the existing Git connection.",
+    },
+    "space.resolveGitConflict": {
+      callback: (
+        _ctx,
+        id: string,
+        generation: string,
+        contentRevision: string,
+        action: GitConflictAction,
+      ): Promise<GitConflicts> =>
+        fetchRevisionsJson(editor, `_conflicts/${encodeURIComponent(id)}`, {
+          generation,
+          contentRevision,
+          action,
+        }),
+      description:
+        "Resolves a Git conflict if the merge and saved content still match.",
+      signatures: [
+        "space.resolveGitConflict(id, generation, contentRevision, action)",
+      ],
+    },
     "space.writePage": {
       callback: (_ctx, name: string, text: string): Promise<PageMeta> =>
         editor.space.writePage(name, text),
@@ -191,5 +413,26 @@ export function spaceWriteSyscalls(editor: Client): SysCallMapping {
       description: "Deletes an arbitrary file from the space.",
       signatures: ["space.deleteFile(name)"],
     },
+    "space.createRevisionSnapshot": {
+      callback: async (): Promise<boolean> => {
+        const resp = await editor.httpSpacePrimitives.authenticatedFetch(
+          revisionsUrl(editor, ""),
+          { method: "POST", headers: { Accept: "application/json" } },
+        );
+        if (resp.status === 404) {
+          throw new Error("Revisions are not available for this space");
+        }
+        if (resp.status === 409) {
+          throw new Error("Revisions are not managed for this space");
+        }
+        if (!resp.ok) {
+          throw new Error(`Snapshot request failed: ${resp.status}`);
+        }
+        return (await resp.json()).committed === true;
+      },
+      description:
+        "Commits everything outstanding as a revision now, rather than waiting for the automatic commit. False if there was nothing to commit.",
+      signatures: ["space.createRevisionSnapshot()"],
+    },
   };
 }