aimyapi 0.2.1 → 1.0.3

package/src/sandbox.ts

@@ -1,5 +1,6 @@
 import "quickjs-emscripten";
 
+import { QuickJSWASMModule } from "quickjs-emscripten";
 import * as ts from "typescript";
 import {
   injectTimingFunctions,
@@ -11,10 +12,10 @@ import {
 // Should we use "noEmitOnError": true ?
 function tsCompile(
   source: string,
-  options: ts.TranspileOptions = null
+  options?: ts.TranspileOptions
 ): string {
   // Default options -- you could also perform a merge, or use the project tsconfig.json
-  if (null === options) {
+  if (!options) {
     options = {
       compilerOptions: {
         target: ts.ScriptTarget.ES2020,
@@ -34,13 +35,59 @@ export interface Globals {
   [key: string]: GlobalOption;
 }
 
+export type SandboxLog = { 
+  type: "log" | "error"; 
+  args: any[]; 
+  source: string 
+};
+export type CodeRunResult = {
+  success: boolean;
+  logs: SandboxLog[];
+}
+type LogSource = "sandbox" | "compiler" | "runner";
+class Logger {
+  logs: SandboxLog[] = [];
+  debug: boolean = false;
+
+  constructor(debug: boolean = false) {
+    this.debug = debug;
+  }
+  
+  log(args: any, source: LogSource) {
+    if(Array.isArray(args)) {
+      this.logs.push({ type: "log", args, source });
+    } else {      
+      this.logs.push({ type: "log", args: [args], source });
+    }
+    if (this.debug) {
+      console.log(`[${source}]:`, ...args);
+    }
+  }
+
+  error(args: any, source: LogSource) {
+    if(Array.isArray(args)) {
+      this.logs.push({ type: "error", args, source });
+    } else {
+      this.logs.push({ type: "error", args: [args], source });
+    }
+    
+    console.error(`[${source}]:`, ...args);
+  }
+
+  clear() {
+    this.logs = [];
+  }
+}
+
+
+
 // function whitelist can be produced using something like:
 // const assistantFunctions =  Object.getOwnPropertyNames(Object.getPrototypeOf(apiObject))
 //   .filter((f) => f !== "constructor" && !f.startsWith("_"));
 
 // Is there some way we can treat the API and globals the same?
 // We could just provide an object for all globals (including the API) and also have the whitelist as a parameter..
-export default async function createSandbox(QuickJS, requireLookup:any = {}, globals: Globals = {}, debug:boolean = false) {
+export default async function createSandbox(QuickJS: QuickJSWASMModule, requireLookup:any = {}, globals: Globals = {}, debug:boolean = false) {
   const vm = QuickJS.newContext();
 
   let errorState = false;
@@ -63,27 +110,31 @@ export default async function createSandbox(QuickJS, requireLookup:any = {}, glo
     return asyncProcessesRunning > 0;
   };
 
+  const logger = new Logger(debug);
+
+
+
   // const assistantHandle = wrapObjectWhitelist(vm, apiObject, functionWhitelist, beginAsyncProcess, endAsyncProcess);
   // vm.setProp(vm.global, apiGlobalName, assistantHandle)
 
   // assistantHandle.dispose();
 
-  const logHandle = vm.newFunction("log", (...args) => {
+  const logHandle = vm.newFunction("log", (...args:any) => {
     const nativeArgs = args.map(vm.dump);
-    console.log("QuickJS Log:", ...nativeArgs);
+    logger.log(nativeArgs, "sandbox");
   });
   const consoleHandle = vm.newObject();
   const exportsHandle = vm.newObject();
 
-  const errorHandle = vm.newFunction("error", (...args) => {
+  const errorHandle = vm.newFunction("error", (...args:any) => {
     try {
       const nativeArgs = args.map(vm.dump);
 
-      console.log("QuickJS console.error:", ...nativeArgs);
+      logger.error(nativeArgs, "sandbox");
       lastError = JSON.stringify(nativeArgs);
       errorState = true;
     } catch (e) {
-      console.log("Error in error:", e);
+      logger.error(["? Error in error:", e], "sandbox");
     }
   });
 
@@ -134,13 +185,42 @@ export default async function createSandbox(QuickJS, requireLookup:any = {}, glo
       return lastError;
     },
     isAsyncProcessRunning,
-    runTask: (task: string): boolean => {
+    // make sure code passes the typescript compilation
+    checkCode: (code: string) => {
+      logger.clear();
       try {
-        const compiled = tsCompile(task);
+        const compiled = tsCompile(code);
+        if (!compiled || compiled.length === 0) {
+          logger.error(["Could not compile:", code], "compiler");
+          return {
+            success: false,
+            logs: logger.logs,
+          };
+        }        
+      } catch (e) {
+        logger.error(["Error testing code:", e], "compiler");
+        return {
+          success: false,
+          logs: logger.logs,
+        };
+      }
+
+      return {
+        success: true,
+        logs: logger.logs,
+      }
+    },
+    runCode: (code: string): CodeRunResult => {
+      try {
+        logger.clear();
+        const compiled = tsCompile(code);
 
         if (!compiled || compiled.length === 0) {
-          console.error("Could not compile", task);
-          return false;
+          logger.error(["Could not compile:", code], "compiler");
+          return {
+            success: false,
+            logs: logger.logs,
+          };
         }
 
         // View compiled typescript code for debugging
@@ -152,33 +232,46 @@ export default async function createSandbox(QuickJS, requireLookup:any = {}, glo
 
         if (result.error) {
           // log out the compiled program with line numbers
-          const lines = compiled.split("\n");
-          for (let i = 0; i < lines.length; i++) {
-            console.log(`${i + 1}: ${lines[i]}`);
-          }
+          const lines = compiled.split("\n").map((line, index) => `${index + 1}: ${line}`);
+
 
-          console.log("Execution failed:", vm.dump(result.error));
+          logger.error(["Execution failed:", lines.join("\n"), vm.dump(result.error)], "runner");
 
           result.error.dispose();
-          return false;
-        } else {
+          return {
+            success: false,
+            logs: logger.logs,
+          };
+        } else if("value" in result){
           //console.log("Task Result:", vm.dump(result.value));
+
           result.value.dispose();
 
+          
           if (errorState) {
-            const lines = compiled.split("\n");
-            for (let i = 0; i < lines.length; i++) {
-              console.log(`${i + 1}: ${lines[i]}`);
-            }
+            const lines = compiled.split("\n").map((line, index) => `${index + 1}: ${line}`);
+            logger.error(["An error was reported during execution. Compiled code with line numbers:", lines.join("\n")], "runner");
           }
 
-          return !errorState;
+          return {
+            success: !errorState,
+            logs: logger.logs,
+          };
+        } else {
+          logger.error(["Unknown execution result:", result], "runner");
+          return {
+            success: false,
+            logs: logger.logs,
+          };
         }
       } catch (e) {
-        console.log(e);
+        logger.error(["Error running code:", e], "runner");
       }
 
-      return false;
+      return {
+        success: false,
+        logs: logger.logs,
+      };
     },
   };
 }

package/tsconfig.json

@@ -1,5 +1,6 @@
 {
     "compilerOptions": {
+        "rootDir": "./src",
         "target": "ES2021" /* Node 16+ per https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping */,
         "module": "nodenext" /* Some imports are really imports: https://www.typescriptlang.org/docs/handbook/esm-node.html */,
         "moduleResolution": "nodenext" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,