@scriptdb/vm 1.0.0

package/README.md

@@ -0,0 +1,96 @@
+# ScriptDB VM
+
+Virtual Machine package for executing TypeScript and JavaScript code in a secure sandboxed environment.
+
+## Installation
+
+```bash
+npm install @scriptdb/vm
+# or
+yarn add @scriptdb/vm
+# or
+bun add @scriptdb/vm
+```
+
+## Quick Start
+
+```typescript
+import { VM } from '@scriptdb/vm';
+
+// Create a VM instance
+const vm = new VM();
+
+// Execute TypeScript code
+const result = await vm.run(`
+  const greet = (name: string) => \`Hello, \${name}!\`;
+  greet("World");
+`);
+
+console.log(result); // "Hello, World!"
+```
+
+## API Reference
+
+### Constructor
+
+```typescript
+new VM(options?)
+```
+
+Creates a new VM instance with the specified options.
+
+#### Options
+
+```typescript
+interface VMOptions {
+  language?: 'ts' | 'js';           // Code language (default: 'ts')
+  registerModules?: { [key: string]: any };  // Modules to register in the VM context
+}
+```
+
+### Methods
+
+#### run(code, options?)
+
+Executes code in the VM context.
+
+```typescript
+await vm.run(code: string, options?: vm.RunningCodeOptions | string): Promise<any>
+```
+
+- `code` (string): The TypeScript or JavaScript code to execute
+- `options` (optional): Execution options or filename
+
+Returns a promise that resolves with the result of the code execution.
+
+#### register(context)
+
+Registers modules and values in the VM context.
+
+```typescript
+vm.register(context: { [key: string]: any }): void
+```
+
+- `context` (object): Object with keys that will be available in the VM context
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development mode
+bun run dev
+
+# Build the package
+bun run build:all
+
+# Run tests
+bun run test
+
+# Run linting
+bun run lint
+
+# Type checking
+bun run typecheck
+```

package/dist/index.js

@@ -0,0 +1,111 @@
+// @bun
+// src/index.ts
+var Bun = globalThis.Bun;
+import vm from "vm";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+class VM {
+  transpiler;
+  ctx;
+  registerModules;
+  DATABASE_DIR = path.join(os.homedir(), ".scriptdb", "databases");
+  PLUGIN_DIR = path.join(os.homedir(), ".scriptdb", "plugins");
+  pkgPlugin = {};
+  constructor(options) {
+    if (!fs.existsSync(this.DATABASE_DIR)) {
+      fs.mkdirSync(this.DATABASE_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(this.PLUGIN_DIR)) {
+      fs.mkdirSync(this.PLUGIN_DIR, { recursive: true });
+    }
+    const pkgPath = path.join(this.PLUGIN_DIR, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      this.pkgPlugin = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    }
+    this.transpiler = new Bun.Transpiler({
+      loader: options?.language || "ts"
+    });
+    this.registerModules = options?.registerModules || {};
+    this.ctx = vm.createContext(this.registerModules);
+  }
+  register(context) {
+    this.registerModules = { ...this.registerModules, ...context };
+    this.ctx = vm.createContext(this.registerModules);
+  }
+  resolvePath(fileList, query) {
+    const aliases = { "@db": this.DATABASE_DIR };
+    let resolvedPath = query;
+    for (const [alias, target] of Object.entries(aliases)) {
+      if (resolvedPath.startsWith(alias + "/")) {
+        resolvedPath = resolvedPath.replace(alias, target);
+        break;
+      }
+    }
+    resolvedPath = path.normalize(resolvedPath);
+    return fileList.find((file) => {
+      const normalizedFile = path.normalize(file);
+      const fileWithoutExt = normalizedFile.replace(/\.[^/.]+$/, "");
+      return normalizedFile === resolvedPath || fileWithoutExt === resolvedPath || normalizedFile === resolvedPath + ".ts" || normalizedFile === resolvedPath + ".js";
+    });
+  }
+  async moduleLinker(specifier, referencingModule) {
+    const dbFiles = fs.readdirSync(this.DATABASE_DIR).filter((f) => f.endsWith(".ts")).map((f) => path.join(this.DATABASE_DIR, f));
+    const dbResult = this.resolvePath(dbFiles, specifier);
+    if (dbResult) {
+      try {
+        const actualModule = await import(dbResult);
+        const exportNames = Object.keys(actualModule);
+        return new vm.SyntheticModule(exportNames, function() {
+          exportNames.forEach((key) => {
+            this.setExport(key, actualModule[key]);
+          });
+        }, { identifier: specifier, context: referencingModule.context });
+      } catch (err) {
+        console.error(`Failed to load database module ${specifier}:`, err);
+        throw err;
+      }
+    }
+    const allowedPackages = Object.keys(this.pkgPlugin.dependencies || {});
+    if (allowedPackages.includes(specifier)) {
+      try {
+        const modulePath = path.join(this.PLUGIN_DIR, "node_modules", specifier);
+        const actualModule = await import(modulePath);
+        const exportNames = Object.keys(actualModule);
+        return new vm.SyntheticModule(exportNames, function() {
+          exportNames.forEach((key) => {
+            this.setExport(key, actualModule[key]);
+          });
+        }, { identifier: specifier, context: referencingModule.context });
+      } catch (err) {
+        console.error(`Failed to load plugin module ${specifier}:`, err);
+        throw err;
+      }
+    }
+    throw new Error(`Module ${specifier} is not allowed or not found.`);
+  }
+  async run(code, options) {
+    const logs = [];
+    const customConsole = ["log", "error", "warn", "info", "debug", "trace"].reduce((acc, type) => {
+      acc[type] = (...args) => logs.push({ type, args });
+      return acc;
+    }, {});
+    this.register({
+      console: customConsole
+    });
+    const js = this.transpiler.transformSync(code);
+    const mod = new vm.SourceTextModule(js, { context: this.ctx, identifier: path.join(this.PLUGIN_DIR, "virtual-entry.js") });
+    await mod.link(this.moduleLinker.bind(this));
+    await mod.evaluate();
+    return {
+      namespace: mod.namespace,
+      logs
+    };
+  }
+}
+var src_default = VM;
+export {
+  src_default as default,
+  VM
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@scriptdb/vm",
+  "version": "1.0.0",
+  "description": "Virtual machine package for script database",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "bun --watch src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target bun --format esm --splitting",
+    "build:cjs": "bun build src/index.ts --outdir dist --target bun --format cjs --outfile dist/index.js",
+    "build:types": "tsc --emitDeclarationOnly --project tsconfig.build.json",
+    "build:all": "bun run build && bun run build:cjs && bun run build:types",
+    "test": "bun test",
+    "lint": "bun run lint:src",
+    "lint:src": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.2",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "bun-types": "latest",
+    "eslint": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}