Tons of refactoring, moving commands and slash commands into hooks

plugos/syscalls/event.ts

@@ -0,0 +1,10 @@
+import { SysCallMapping } from "../system";
+import { EventHook } from "../hooks/event";
+
+export function eventSyscalls(eventHook: EventHook): SysCallMapping {
+  return {
+    async dispatch(ctx, eventName: string, data: any) {
+      return eventHook.dispatchEvent(eventName, data);
+    },
+  };
+}

plugos/syscalls/fetch.node.ts

@@ -0,0 +1,15 @@
+import fetch, { RequestInfo, RequestInit } from "node-fetch";
+import { SysCallMapping } from "../system";
+
+export function fetchSyscalls(): SysCallMapping {
+  return {
+    async json(ctx, url: RequestInfo, init: RequestInit) {
+      let resp = await fetch(url, init);
+      return resp.json();
+    },
+    async text(ctx, url: RequestInfo, init: RequestInit) {
+      let resp = await fetch(url, init);
+      return resp.text();
+    },
+  };
+}

plugos/syscalls/shell.node.ts

@@ -0,0 +1,20 @@
+import { promisify } from "util";
+import { execFile } from "child_process";
+import type { SysCallMapping } from "../system";
+
+const execFilePromise = promisify(execFile);
+
+export default function (cwd: string): SysCallMapping {
+  return {
+    run: async (
+      ctx,
+      cmd: string,
+      args: string[]
+    ): Promise<{ stdout: string; stderr: string }> => {
+      let { stdout, stderr } = await execFilePromise(cmd, args, {
+        cwd: cwd,
+      });
+      return { stdout, stderr };
+    },
+  };
+}

plugos/syscalls/store.dexie_browser.test.ts

@@ -0,0 +1,49 @@
+import { createSandbox } from "../environments/node_sandbox";
+import { expect, test } from "@jest/globals";
+import { System } from "../system";
+import { storeSyscalls } from "./store.dexie_browser";
+
+// For testing in node.js
+require("fake-indexeddb/auto");
+
+test("Test store", async () => {
+  let system = new System("server");
+  system.registerSyscalls("store", [], storeSyscalls("test", "test"));
+  let plug = await system.load(
+    "test",
+    {
+      functions: {
+        test1: {
+          code: `(() => {
+          return {
+            default: async () => {
+              await self.syscall("store.set", "name", "Pete");
+              return await self.syscall("store.get", "name");
+            }
+          };
+        })()`,
+        },
+        test2: {
+          code: `(() => {
+          return {
+            default: async () => {
+              await self.syscall("store.set", "page1:bl:page2:10", {title: "Something", meta: 20});
+              await self.syscall("store.batchSet", [
+                 {key: "page2:bl:page3", value: {title: "Something2", meta: 10}},
+                 {key: "page2:bl:page4", value: {title: "Something3", meta: 10}},
+              ]);
+              return await self.syscall("store.queryPrefix", "page2:");
+            }
+          };
+        })()`,
+        },
+      },
+    },
+    createSandbox
+  );
+  expect(await plug.invoke("test1", [])).toBe("Pete");
+  let queryResults = await plug.invoke("test2", []);
+  expect(queryResults.length).toBe(2);
+  expect(queryResults[0].value.meta).toBe(10);
+  await system.unloadAll();
+});

plugos/syscalls/store.dexie_browser.ts

@@ -0,0 +1,66 @@
+import Dexie from "dexie";
+import { SysCallMapping } from "../system";
+
+export type KV = {
+  key: string;
+  value: any;
+};
+
+export function storeSyscalls(
+  dbName: string,
+  tableName: string
+): SysCallMapping {
+  const db = new Dexie(dbName);
+  db.version(1).stores({
+    test: "key",
+  });
+  const items = db.table(tableName);
+
+  return {
+    async delete(ctx, key: string) {
+      await items.delete(key);
+    },
+
+    async deletePrefix(ctx, prefix: string) {
+      await items.where("key").startsWith(prefix).delete();
+    },
+
+    async deleteAll() {
+      await items.clear();
+    },
+
+    async set(ctx, key: string, value: any) {
+      await items.put({
+        key,
+        value,
+      });
+    },
+
+    async batchSet(ctx, kvs: KV[]) {
+      await items.bulkPut(
+        kvs.map(({ key, value }) => ({
+          key,
+          value,
+        }))
+      );
+    },
+
+    async get(ctx, key: string): Promise<any | null> {
+      let result = await items.get({
+        key,
+      });
+      return result ? result.value : null;
+    },
+
+    async queryPrefix(
+      ctx,
+      keyPrefix: string
+    ): Promise<{ key: string; value: any }[]> {
+      let results = await items.where("key").startsWith(keyPrefix).toArray();
+      return results.map((result) => ({
+        key: result.key,
+        value: result.value,
+      }));
+    },
+  };
+}

plugos/syscalls/store.knex_node.test.ts

@@ -0,0 +1,49 @@
+import { createSandbox } from "../environments/node_sandbox";
+import { expect, test } from "@jest/globals";
+import { System } from "../system";
+import {
+  ensureTable,
+  storeReadSyscalls,
+  storeWriteSyscalls,
+} from "./store.knex_node";
+import knex from "knex";
+import fs from "fs/promises";
+
+test("Test store", async () => {
+  const db = knex({
+    client: "better-sqlite3",
+    connection: {
+      filename: "test.db",
+    },
+    useNullAsDefault: true,
+  });
+  await ensureTable(db, "test_table");
+  let system = new System("server");
+  system.registerSyscalls(
+    "store",
+    [],
+    storeWriteSyscalls(db, "test_table"),
+    storeReadSyscalls(db, "test_table")
+  );
+  let plug = await system.load(
+    "test",
+    {
+      functions: {
+        test1: {
+          code: `(() => {
+          return {
+            default: async () => {
+              await self.syscall("store.set", "name", "Pete");
+              return await self.syscall("store.get", "name");
+            }
+          };
+        })()`,
+        },
+      },
+    },
+    createSandbox
+  );
+  expect(await plug.invoke("test1", [])).toBe("Pete");
+  await system.unloadAll();
+  await fs.unlink("test.db");
+});

plugos/syscalls/store.knex_node.ts

@@ -0,0 +1,90 @@
+import { Knex } from "knex";
+import { SysCallMapping } from "../system";
+
+type Item = {
+  page: string;
+  key: string;
+  value: any;
+};
+
+export type KV = {
+  key: string;
+  value: any;
+};
+
+export async function ensureTable(db: Knex<any, unknown>, tableName: string) {
+  if (!(await db.schema.hasTable(tableName))) {
+    await db.schema.createTable(tableName, (table) => {
+      table.string("key");
+      table.text("value");
+      table.primary(["key"]);
+    });
+    console.log(`Created table ${tableName}`);
+  }
+}
+
+export function storeWriteSyscalls(
+  db: Knex<any, unknown>,
+  tableName: string
+): SysCallMapping {
+  const apiObj: SysCallMapping = {
+    delete: async (ctx, key: string) => {
+      await db<Item>(tableName).where({ key }).del();
+    },
+    deletePrefix: async (ctx, prefix: string) => {
+      return db<Item>(tableName).andWhereLike("key", `${prefix}%`).del();
+    },
+    deleteAll: async (ctx) => {
+      await db<Item>(tableName).del();
+    },
+    set: async (ctx, key: string, value: any) => {
+      let changed = await db<Item>(tableName)
+        .where({ key })
+        .update("value", JSON.stringify(value));
+      if (changed === 0) {
+        await db<Item>(tableName).insert({
+          key,
+          value: JSON.stringify(value),
+        });
+      }
+    },
+    // TODO: Optimize
+    batchSet: async (ctx, kvs: KV[]) => {
+      for (let { key, value } of kvs) {
+        await apiObj.set(ctx, key, value);
+      }
+    },
+    batchDelete: async (ctx, keys: string[]) => {
+      for (let key of keys) {
+        await apiObj.delete(ctx, key);
+      }
+    },
+  };
+  return apiObj;
+}
+
+export function storeReadSyscalls(
+  db: Knex<any, unknown>,
+  tableName: string
+): SysCallMapping {
+  return {
+    get: async (ctx, key: string): Promise<any | null> => {
+      let result = await db<Item>(tableName).where({ key }).select("value");
+      if (result.length) {
+        return JSON.parse(result[0].value);
+      } else {
+        return null;
+      }
+    },
+    queryPrefix: async (ctx, prefix: string) => {
+      return (
+        await db<Item>(tableName)
+          .andWhereLike("key", `${prefix}%`)
+          .select("key", "value")
+      ).map(({ key, value }) => ({
+        key,
+        value: JSON.parse(value),
+      }));
+    },
+  };
+}

plugos/syscalls/transport.ts

@@ -0,0 +1,16 @@
+import { SysCallMapping } from "../system";
+
+export function transportSyscalls(
+  names: string[],
+  transportCall: (name: string, ...args: any[]) => Promise<any>
+): SysCallMapping {
+  let syscalls: SysCallMapping = {};
+
+  for (let name of names) {
+    syscalls[name] = (ctx, ...args: any[]) => {
+      return transportCall(name, ...args);
+    };
+  }
+
+  return syscalls;
+}