@silverbulletmd/silverbullet 2.4.1

package/client/plugos/worker_runtime.ts

@@ -0,0 +1,195 @@
+// This is the runtime imported from the compiled plug worker code
+import type { ControllerMessage, WorkerMessage } from "./protocol.ts";
+import type {
+  ProxyFetchRequest64,
+  ProxyFetchResponse64,
+} from "./proxy_fetch.ts";
+import { base64Decode, base64Encode } from "../../plug-api/lib/crypto.ts";
+import { initLogger } from "../lib/logger.ts";
+
+declare global {
+  function syscall(name: string, ...args: any[]): Promise<any>;
+}
+
+let workerPostMessage = (_msg: ControllerMessage): void => {
+  throw new Error("Not initialized yet");
+};
+
+// Are we running in a (web) worker?
+
+// Determines if we're running in a web worker environment (Deno or browser)
+// - in a browser's main threads, typeof window is "object"
+// - in a browser's worker threads, typeof window === "undefined"
+// - in Deno's main thread typeof window === "object"
+// - in Deno's workers typeof window === "undefined
+// - in Cloudflare workers typeof window === "undefined", but typeof globalThis.WebSocketPair is defined
+const runningAsWebWorker = typeof window === "undefined" &&
+  // @ts-ignore: globalThis
+  typeof globalThis.WebSocketPair === "undefined";
+
+if (typeof Deno === "undefined") {
+  // @ts-ignore: Deno hack
+  self.Deno = {
+    args: [],
+    // @ts-ignore: Deno hack
+    build: {
+      arch: "x86_64",
+    },
+    env: {
+      // @ts-ignore: Deno hack
+      get() {
+      },
+    },
+  };
+}
+
+const pendingRequests = new Map<
+  number,
+  {
+    resolve: (result: unknown) => void;
+    reject: (e: any) => void;
+  }
+>();
+
+let syscallReqId = 0;
+
+if (runningAsWebWorker) {
+  globalThis.syscall = async (name: string, ...args: any[]) => {
+    return await new Promise((resolve, reject) => {
+      syscallReqId++;
+      pendingRequests.set(syscallReqId, { resolve, reject });
+      workerPostMessage({
+        type: "sys",
+        id: syscallReqId,
+        name,
+        args,
+      });
+    });
+  };
+}
+
+export function setupMessageListener(
+  // deno-lint-ignore ban-types
+  functionMapping: Record<string, Function>,
+  manifest: any,
+  postMessageFn: (msg: ControllerMessage) => void,
+) {
+  if (!runningAsWebWorker) {
+    // Don't do any of this stuff if this is not a web worker
+    // This caters to the NoSandbox run mode
+    return;
+  }
+  workerPostMessage = postMessageFn;
+  self.addEventListener("message", (event: { data: WorkerMessage }) => {
+    (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: result,
+              } as ControllerMessage);
+            } catch (e: any) {
+              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);
+  });
+  // Signal initialization with manifest
+  workerPostMessage({
+    type: "manifest",
+    manifest,
+  });
+  initLogger(`[${manifest.name} plug]`);
+}
+
+export async function sandboxFetch(
+  reqInfo: RequestInfo,
+  options?: ProxyFetchRequest64,
+): Promise<ProxyFetchResponse64> {
+  if (typeof reqInfo !== "string") {
+    const body = new Uint8Array(await reqInfo.arrayBuffer());
+    const encodedBody = body.length > 0 ? base64Encode(body) : undefined;
+    options = {
+      method: reqInfo.method,
+      headers: Object.fromEntries(reqInfo.headers.entries()),
+      base64Body: encodedBody,
+    };
+    reqInfo = reqInfo.url;
+  }
+  return syscall("sandboxFetch.fetch", reqInfo, options);
+}
+
+// @ts-ignore: monkey patching fetch
+globalThis.nativeFetch = globalThis.fetch;
+
+// Monkey patch fetch()
+export function monkeyPatchFetch() {
+  // @ts-ignore: monkey patching fetch
+  globalThis.fetch = async function (
+    reqInfo: RequestInfo,
+    init?: RequestInit,
+  ): Promise<Response> {
+    const encodedBody = init && init.body
+      ? base64Encode(
+        new Uint8Array(await (new Response(init.body)).arrayBuffer()),
+      )
+      : undefined;
+    const r = await sandboxFetch(
+      reqInfo,
+      init && {
+        method: init.method,
+        headers: init.headers as Record<string, string>,
+        base64Body: encodedBody,
+      },
+    );
+    // Casting the response to "any" for now, since of weird Deno typing
+    return new Response(
+      (r.base64Body ? base64Decode(r.base64Body) : null) as any,
+      {
+        status: r.status,
+        headers: r.headers,
+      },
+    );
+  };
+}
+
+if (runningAsWebWorker) {
+  monkeyPatchFetch();
+}

package/client/space_lua/ast.ts

@@ -0,0 +1,328 @@
+type ASTContext = {
+  ctx: ASTCtx;
+};
+
+export type NumericType = "int" | "float";
+
+export type ASTCtx = {
+  from?: number;
+  to?: number;
+} & Record<string, any>;
+
+export type LuaBlock = {
+  type: "Block";
+  statements: LuaStatement[];
+  hasLabel?: boolean;
+  hasGoto?: boolean;
+  // the first duplicated label is recorded here for later eval
+  dupLabelError?: { name: string; ctx: ASTCtx };
+  // this block declares top-level locals and therefore needs a new env
+  needsEnv?: boolean;
+  // true if this block itself (not nested ones) defines at least one label
+  hasLabelHere?: boolean;
+  // true if this block itself (not nested ones) may create to-be-closed values
+  hasCloseHere?: boolean;
+  // true if this block's subtree contains any function definition
+  hasFunctionDef?: boolean;
+} & ASTContext;
+
+// STATEMENTS
+export type LuaReturnStatement = {
+  type: "Return";
+  expressions: LuaExpression[];
+} & ASTContext;
+
+export type LuaStatement =
+  | LuaSemicolonStatement
+  | LuaLabelStatement
+  | LuaBreakStatement
+  | LuaGotoStatement
+  | LuaReturnStatement
+  | LuaBlock
+  | LuaWhileStatement
+  | LuaRepeatStatement
+  | LuaIfStatement
+  | LuaForStatement
+  | LuaForInStatement
+  | LuaFunctionStatement
+  | LuaLocalFunctionStatement
+  | LuaAssignmentStatement
+  | LuaLocalStatement
+  | LuaFunctionCallStatement;
+
+export type LuaSemicolonStatement = {
+  type: "Semicolon";
+} & ASTContext;
+
+export type LuaLabelStatement = {
+  type: "Label";
+  name: string;
+} & ASTContext;
+
+export type LuaBreakStatement = {
+  type: "Break";
+} & ASTContext;
+
+export type LuaGotoStatement = {
+  type: "Goto";
+  name: string;
+} & ASTContext;
+
+export type LuaWhileStatement = {
+  type: "While";
+  condition: LuaExpression;
+  block: LuaBlock;
+} & ASTContext;
+
+export type LuaRepeatStatement = {
+  type: "Repeat";
+  block: LuaBlock;
+  condition: LuaExpression;
+} & ASTContext;
+
+export type LuaIfStatement = {
+  type: "If";
+  conditions: { condition: LuaExpression; block: LuaBlock }[];
+  elseBlock?: LuaBlock;
+} & ASTContext;
+
+export type LuaForStatement = {
+  type: "For";
+  name: string;
+  start: LuaExpression;
+  end: LuaExpression;
+  step?: LuaExpression;
+  block: LuaBlock;
+  // function definition in the block captures the loop variable
+  capturesLoopVar?: boolean;
+} & ASTContext;
+
+export type LuaForInStatement = {
+  type: "ForIn";
+  names: string[];
+  expressions: LuaExpression[];
+  block: LuaBlock;
+  // function definition in the block captures any loop variable
+  capturesLoopVar?: boolean;
+} & ASTContext;
+
+export type LuaFunctionStatement = {
+  type: "Function";
+  name: LuaFunctionName;
+  body: LuaFunctionBody;
+} & ASTContext;
+
+export type LuaLocalFunctionStatement = {
+  type: "LocalFunction";
+  name: string;
+  body: LuaFunctionBody;
+} & ASTContext;
+
+export type LuaFunctionName = {
+  type: "FunctionName";
+  propNames: string[];
+  colonName?: string;
+} & ASTContext;
+
+export type LuaFunctionBody = {
+  type: "FunctionBody";
+  parameters: string[];
+  block: LuaBlock;
+} & ASTContext;
+
+export type LuaAssignmentStatement = {
+  type: "Assignment";
+  variables: LuaLValue[];
+  expressions: LuaExpression[];
+} & ASTContext;
+
+export type LuaLValue =
+  | LuaVariable
+  | LuaPropertyAccessExpression
+  | LuaTableAccessExpression;
+
+export type LuaLocalStatement = {
+  type: "Local";
+  names: LuaAttName[];
+  expressions?: LuaExpression[];
+} & ASTContext;
+
+export enum LuaAttribute {
+  Const = "const",
+  Close = "close",
+}
+
+export type LuaAttName = {
+  type: "AttName";
+  name: string;
+  attribute?: string;
+  attributes?: LuaAttribute[];
+} & ASTContext;
+
+export type LuaFunctionCallStatement = {
+  type: "FunctionCallStatement";
+  call: LuaFunctionCallExpression;
+} & ASTContext;
+
+// EXPRESSIONS
+export type LuaExpression =
+  | LuaNilLiteral
+  | LuaBooleanLiteral
+  | LuaNumberLiteral
+  | LuaStringLiteral
+  | LuaPrefixExpression
+  | LuaBinaryExpression
+  | LuaUnaryExpression
+  | LuaTableConstructor
+  | LuaFunctionDefinition
+  | LuaQueryExpression;
+
+export type LuaNilLiteral = {
+  type: "Nil";
+} & ASTContext;
+
+export type LuaBooleanLiteral = {
+  type: "Boolean";
+  value: boolean;
+} & ASTContext;
+
+export type LuaNumberLiteral = {
+  type: "Number";
+  value: number;
+  numericType: NumericType;
+} & ASTContext;
+
+export type LuaStringLiteral = {
+  type: "String";
+  value: string;
+} & ASTContext;
+
+export type LuaPrefixExpression =
+  | LuaVariableExpression
+  | LuaParenthesizedExpression
+  | LuaFunctionCallExpression;
+
+export type LuaParenthesizedExpression = {
+  type: "Parenthesized";
+  expression: LuaExpression;
+} & ASTContext;
+
+export type LuaVariableExpression =
+  | LuaVariable
+  | LuaPropertyAccessExpression
+  | LuaTableAccessExpression;
+
+export type LuaVariable = {
+  type: "Variable";
+  name: string;
+} & ASTContext;
+
+export type LuaPropertyAccessExpression = {
+  type: "PropertyAccess";
+  object: LuaPrefixExpression;
+  property: string;
+} & ASTContext;
+
+export type LuaTableAccessExpression = {
+  type: "TableAccess";
+  object: LuaPrefixExpression;
+  key: LuaExpression;
+} & ASTContext;
+
+export type LuaFunctionCallExpression = {
+  type: "FunctionCall";
+  prefix: LuaPrefixExpression;
+  name?: string;
+  args: LuaExpression[];
+} & ASTContext;
+
+export type LuaBinaryExpression = {
+  type: "Binary";
+  operator: string;
+  left: LuaExpression;
+  right: LuaExpression;
+} & ASTContext;
+
+export type LuaUnaryExpression = {
+  type: "Unary";
+  operator: string;
+  argument: LuaExpression;
+} & ASTContext;
+
+export type LuaTableConstructor = {
+  type: "TableConstructor";
+  fields: LuaTableField[];
+} & ASTContext;
+
+export type LuaTableField =
+  | LuaDynamicField
+  | LuaPropField
+  | LuaExpressionField;
+
+export type LuaDynamicField = {
+  type: "DynamicField";
+  key: LuaExpression;
+  value: LuaExpression;
+} & ASTContext;
+
+export type LuaPropField = {
+  type: "PropField";
+  key: string;
+  value: LuaExpression;
+} & ASTContext;
+
+export type LuaExpressionField = {
+  type: "ExpressionField";
+  value: LuaExpression;
+} & ASTContext;
+
+export type LuaFunctionDefinition = {
+  type: "FunctionDefinition";
+  body: LuaFunctionBody;
+} & ASTContext;
+
+// Query stuff
+export type LuaQueryExpression = {
+  type: "Query";
+  clauses: LuaQueryClause[];
+} & ASTContext;
+
+export type LuaQueryClause =
+  | LuaFromClause
+  | LuaWhereClause
+  | LuaLimitClause
+  | LuaOrderByClause
+  | LuaSelectClause;
+
+export type LuaFromClause = {
+  type: "From";
+  name?: string;
+  expression: LuaExpression;
+} & ASTContext;
+
+export type LuaWhereClause = {
+  type: "Where";
+  expression: LuaExpression;
+} & ASTContext;
+
+export type LuaLimitClause = {
+  type: "Limit";
+  limit: LuaExpression;
+  offset?: LuaExpression;
+} & ASTContext;
+
+export type LuaOrderByClause = {
+  type: "OrderBy";
+  orderBy: LuaOrderBy[];
+} & ASTContext;
+
+export type LuaOrderBy = {
+  type: "Order";
+  expression: LuaExpression;
+  direction: "asc" | "desc";
+} & ASTContext;
+
+export type LuaSelectClause = {
+  type: "Select";
+  expression: LuaExpression;
+} & ASTContext;

package/client/space_lua/ast_narrow.ts

@@ -0,0 +1,81 @@
+// Typed narrowers for AST nodes to avoid `(node as any)` in consumers.
+
+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) =>
+  e as NarrowByType<LuaExpression, "Number">;
+export const asBooleanExpr = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "Boolean">;
+export const asNilExpr = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "Nil">;
+export const asUnary = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "Unary">;
+export const asBinary = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "Binary">;
+export const asVariable = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "Variable">;
+export const asFunctionCall = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "FunctionCall">;
+export const asTableAccess = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "TableAccess">;
+export const asPropertyAccess = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "PropertyAccess">;
+export const asParenthesized = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "Parenthesized">;
+export const asTableConstructor = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "TableConstructor">;
+export const asFunctionDef = (e: LuaExpression) =>
+  e as NarrowByType<LuaExpression, "FunctionDefinition">;
+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) =>
+  l as Extract<LuaLValue, { type: "TableAccess" }>;
+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) =>
+  s as NarrowByType<LuaStatement, "Local">;
+export const asBlock = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "Block">;
+export const asIf = (s: LuaStatement) => s as NarrowByType<LuaStatement, "If">;
+export const asWhile = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "While">;
+export const asRepeat = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "Repeat">;
+export const asBreak = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "Break">;
+export const asFunctionStmt = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "Function">;
+export const asLocalFunction = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "LocalFunction">;
+export const asFunctionCallStmt = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "FunctionCallStatement">;
+export const asReturn = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "Return">;
+export const asFor = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "For">;
+export const asForIn = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "ForIn">;
+export const asLabel = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "Label">;
+export const asGoto = (s: LuaStatement) =>
+  s as NarrowByType<LuaStatement, "Goto">;
+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;