Cleanup

packages/plugs/plugmanager/plugmanager.plug.yaml

@@ -0,0 +1,25 @@
+name: plugmanager
+functions:
+  updatePlugsCommand:
+    path: ./plugmanager.ts:updatePlugsCommand
+    command:
+      name: "Plugs: Update"
+      key: "Ctrl-Shift-p"
+      mac: "Cmd-Shift-p"
+  updatePlugs:
+    path: ./plugmanager.ts:updatePlugs
+    env: server
+  compile:
+    path: "./plugmanager.ts:compileCommand"
+    command:
+      name: "Plug: Compile"
+      mac: "Cmd-Shift-c"
+      key: "Ctrl-Shift-c"
+  compileJS:
+    path: "./plugmanager.ts:compileJS"
+    env: server
+
+  getPlugPlugMd:
+    path: "./plugmanager.ts:getPlugPlugMd"
+    events:
+    - get-plug:plugmd

packages/plugs/plugmanager/plugmanager.ts

@@ -0,0 +1,175 @@
+import { dispatch } from "@plugos/plugos-syscall/event";
+import {
+  addParentPointers,
+  collectNodesOfType,
+  findNodeOfType,
+} from "@silverbulletmd/common/tree";
+import {
+  getText,
+  hideBhs,
+  showBhs,
+} from "@silverbulletmd/plugos-silverbullet-syscall/editor";
+import { parseMarkdown } from "@silverbulletmd/plugos-silverbullet-syscall/markdown";
+import {
+  deletePage,
+  listPages,
+  readPage,
+  writePage,
+} from "@silverbulletmd/plugos-silverbullet-syscall/space";
+import {
+  invokeFunction,
+  reloadPlugs,
+} from "@silverbulletmd/plugos-silverbullet-syscall/system";
+import YAML from "yaml";
+
+import { extractMeta } from "../query/data";
+
+import type { Manifest } from "@silverbulletmd/common/manifest";
+
+export async function compileCommand() {
+  let text = await getText();
+  try {
+    let manifest = await compileDefinition(text);
+    await writePage(
+      `_plug/${manifest.name}`,
+      JSON.stringify(manifest, null, 2)
+    );
+    console.log("Wrote this plug", manifest);
+    await hideBhs();
+    // Important not to await!
+    reloadPlugs();
+  } catch (e: any) {
+    await showBhs(e.message);
+    // console.error("Got this error from compiler", e.message);
+  }
+}
+
+async function compileDefinition(text: string): Promise<Manifest> {
+  let tree = await parseMarkdown(text);
+
+  let pageMeta = extractMeta(tree);
+
+  if (!pageMeta.name) {
+    throw new Error("No 'name' specified in page meta");
+  }
+
+  addParentPointers(tree);
+  let allHeaders = collectNodesOfType(tree, "ATXHeading2");
+  let manifest: Manifest = {
+    name: pageMeta.name,
+    functions: {},
+  };
+  for (let t of allHeaders) {
+    let parent = t.parent!;
+    let headerIdx = parent.children!.indexOf(t);
+    let headerTitle = t.children![1].text!.trim();
+    if (!headerTitle.startsWith("function ")) {
+      continue;
+    }
+    let functionName = headerTitle
+      .substring("function ".length)
+      .replace(/[^\w]/g, "_");
+    let meta: any;
+    let code: string | undefined;
+    let language = "js";
+    for (let i = headerIdx + 1; i < parent.children!.length; i++) {
+      let child = parent.children![i];
+      if (child.type === "FencedCode") {
+        let codeInfo = findNodeOfType(child, "CodeInfo")!.children![0].text!;
+        let codeText = findNodeOfType(child, "CodeText")!.children![0].text!;
+        if (codeInfo === "yaml") {
+          meta = YAML.parse(codeText);
+          continue;
+        }
+        if (codeInfo === "typescript" || codeInfo === "ts") {
+          language = "ts";
+        }
+        code = codeText;
+      }
+
+      if (child.type?.startsWith("ATXHeading")) {
+        break;
+      }
+    }
+    if (code) {
+      let compiled = await invokeFunction(
+        "server",
+        "compileJS",
+        `file.${language}`,
+        code
+      );
+      manifest.functions[functionName] = meta;
+      manifest.functions[functionName].code = compiled;
+    }
+  }
+  return manifest;
+}
+
+export async function compileJS(
+  filename: string,
+  code: string
+): Promise<string> {
+  return self.syscall("esbuild.compile", filename, code);
+}
+
+async function listPlugs(): Promise<string[]> {
+  let unfilteredPages = await listPages(true);
+  return unfilteredPages
+    .filter((p) => p.name.startsWith("_plug/"))
+    .map((p) => p.name.substring("_plug/".length));
+}
+
+export async function listCommand() {
+  console.log(await listPlugs());
+}
+
+export async function updatePlugsCommand() {
+  await invokeFunction("server", "updatePlugs");
+  await reloadPlugs();
+}
+
+export async function updatePlugs() {
+  let { text: plugPageText } = await readPage("PLUGS");
+
+  let tree = await parseMarkdown(plugPageText);
+
+  let codeTextNode = findNodeOfType(tree, "CodeText");
+  if (!codeTextNode) {
+    console.error("Could not find yaml block in PLUGS");
+    return;
+  }
+  let plugYaml = codeTextNode.children![0].text;
+  let plugList = YAML.parse(plugYaml!);
+  // console.log("Plug YAML", plugList);
+  let allPlugNames: string[] = [];
+  for (let plugUri of plugList) {
+    let [protocol, ...rest] = plugUri.split(":");
+    let manifests = await dispatch(`get-plug:${protocol}`, rest.join(":"));
+    if (manifests.length === 0) {
+      console.error("Could not resolve plug", plugUri);
+    }
+    // console.log("Got manifests", plugUri, protocol, manifests);
+    let manifest = manifests[0];
+    allPlugNames.push(manifest.name);
+    // console.log("Writing", `_plug/${manifest.name}`);
+    await writePage(
+      `_plug/${manifest.name}`,
+      JSON.stringify(manifest, null, 2)
+    );
+  }
+
+  // And delete extra ones
+  for (let existingPlug of await listPlugs()) {
+    if (!allPlugNames.includes(existingPlug)) {
+      console.log("Removing plug", existingPlug);
+      await deletePage(`_plug/${existingPlug}`);
+    }
+  }
+  await reloadPlugs();
+}
+
+export async function getPlugPlugMd(pageName: string): Promise<Manifest> {
+  let { text } = await readPage(pageName);
+  console.log("Compiling", pageName);
+  return compileDefinition(text);
+}