@ebowwa/sandbox 0.1.1

package/src/compilers/python.ts

@@ -0,0 +1,785 @@
+/**
+ * Python Compiler
+ *
+ * Compiles Python code to WASM or validates Python syntax.
+ *
+ * Note: True Python-to-WASM compilation is complex. Current options:
+ * - Pyodide: Full Python runtime compiled to WASM (heavy, ~10MB+)
+ * - RustPython: Python interpreter in Rust, WASM-ready
+ * - Wasmer Python: Wasmer's Python distribution
+ *
+ * This implementation provides:
+ * 1. Syntax validation (always available)
+ * 2. Stub WASM compilation for isolated execution
+ * 3. Ready for integration with Pyodide/RustPython when available
+ */
+
+import {
+  BaseCompiler,
+  type CompileResult,
+  type CompilerOptions,
+  type LanguageCapabilities,
+} from "../core/compiler.js";
+import type { Permissions, Limits } from "../core/types.js";
+
+/**
+ * Python syntax validation result
+ */
+export interface PythonValidationResult {
+  valid: boolean;
+  error?: string;
+  line?: number;
+  column?: number;
+}
+
+/**
+ * Python AST node types for basic validation
+ */
+type PythonNodeType =
+  | "Module"
+  | "FunctionDef"
+  | "AsyncFunctionDef"
+  | "ClassDef"
+  | "Return"
+  | "Delete"
+  | "Assign"
+  | "AugAssign"
+  | "AnnAssign"
+  | "For"
+  | "AsyncFor"
+  | "While"
+  | "If"
+  | "With"
+  | "AsyncWith"
+  | "Raise"
+  | "Try"
+  | "Assert"
+  | "Import"
+  | "ImportFrom"
+  | "Global"
+  | "Nonlocal"
+  | "Expr"
+  | "Pass"
+  | "Break"
+  | "Continue";
+
+/**
+ * Python Compiler
+ *
+ * Provides Python syntax validation and stub WASM compilation.
+ * Designed to be extended with Pyodide or RustPython integration.
+ */
+export class PythonCompiler extends BaseCompiler {
+  readonly language = "python" as const;
+
+  /**
+   * Python keywords for validation
+   */
+  private static readonly KEYWORDS = new Set([
+    "False", "None", "True", "and", "as", "assert", "async", "await",
+    "break", "class", "continue", "def", "del", "elif", "else", "except",
+    "finally", "for", "from", "global", "if", "import", "in", "is",
+    "lambda", "nonlocal", "not", "or", "pass", "raise", "return", "try",
+    "while", "with", "yield",
+  ]);
+
+  /**
+   * Python operators for validation
+   */
+  private static readonly OPERATORS = new Set([
+    "+", "-", "*", "/", "//", "%", "**", "<<", ">>", "&", "|", "^",
+    "~", "<", ">", "<=", ">=", "==", "!=", "+=", "-=", "*=", "/=",
+    "//=", "%=", "**=", "<<=", ">>=", "&=", "|=", "^=", "->", ":=",
+  ]);
+
+  /**
+   * Check if a full Python runtime is available
+   */
+  private pyodideAvailable: boolean | null = null;
+
+  /**
+   * Check if Python compiler is available
+   *
+   * Always returns true since we provide syntax validation.
+   * Returns true for WASM compilation only if Pyodide is loaded.
+   */
+  async isAvailable(): Promise<boolean> {
+    // Basic validation is always available
+    return true;
+  }
+
+  /**
+   * Check if Pyodide runtime is available
+   */
+  async isPyodideAvailable(): Promise<boolean> {
+    if (this.pyodideAvailable !== null) {
+      return this.pyodideAvailable;
+    }
+
+    // Check if running in browser/worker with Pyodide
+    if (typeof globalThis !== "undefined") {
+      const g = globalThis as { loadPyodide?: unknown; pyodide?: unknown };
+      this.pyodideAvailable = !!(g.loadPyodide || g.pyodide);
+    } else {
+      this.pyodideAvailable = false;
+    }
+
+    return this.pyodideAvailable;
+  }
+
+  /**
+   * Validate Python source code syntax
+   */
+  async validate(source: string): Promise<PythonValidationResult> {
+    try {
+      // Empty source is valid
+      if (!source.trim()) {
+        return { valid: true };
+      }
+
+      // Run syntax checks
+      const errors: string[] = [];
+
+      // Check for common syntax errors
+      const bracketResult = this.checkBrackets(source);
+      if (!bracketResult.valid) {
+        return bracketResult;
+      }
+
+      const indentResult = this.checkIndentation(source);
+      if (!indentResult.valid) {
+        return indentResult;
+      }
+
+      const stringResult = this.checkStrings(source);
+      if (!stringResult.valid) {
+        return stringResult;
+      }
+
+      // Check for invalid syntax patterns
+      const syntaxResult = this.checkSyntaxPatterns(source);
+      if (!syntaxResult.valid) {
+        return syntaxResult;
+      }
+
+      // If we have access to Pyodide, use its parser for full validation
+      if (await this.isPyodideAvailable()) {
+        return this.validateWithPyodide(source);
+      }
+
+      // Basic validation passed
+      return { valid: true, error: errors.length > 0 ? errors.join("; ") : undefined };
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Validation error: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+
+  /**
+   * Compile Python source to WASM
+   *
+   * For now, creates a stub WASM module that wraps the Python code.
+   * When Pyodide is available, can use full Python-to-WASM execution.
+   */
+  async compile(
+    source: string,
+    permissions: Permissions,
+    limits: Limits,
+    options?: CompilerOptions
+  ): Promise<CompileResult> {
+    // Validate first
+    const validation = await this.validate(source);
+    if (!validation.valid) {
+      throw new Error(`Python syntax error: ${validation.error}`);
+    }
+
+    // Check permissions - Python needs filesystem and network for many operations
+    this.checkPermissions(permissions);
+
+    // If Pyodide is available, we could use it for actual execution
+    // For now, create a stub WASM module that stores the Python code
+    const wasmBytes = await this.createStubWasm(source, options);
+
+    return {
+      wasmBytes,
+      source, // Include original Python source for interpreted execution
+      exports: ["run", "get_output", "set_input"],
+      imports: [
+        { module: "env", name: "memory", type: "memory" },
+        { module: "env", name: "log", type: "function", signature: "(i32, i32) -> ()" },
+      ],
+      memoryRequirements: {
+        initial: this.calculateMemoryPages(source, limits),
+        maximum: limits.memory ? Math.ceil(this.parseMemoryLimit(limits.memory) / 65536) : 256,
+      },
+    };
+  }
+
+  /**
+   * Get Python language capabilities
+   */
+  getCapabilities(): LanguageCapabilities {
+    return {
+      repl: true,
+      stateful: true,
+      compiled: false,
+      gc: true,
+      imports: true,
+      async: true,
+    };
+  }
+
+  /**
+   * Check bracket matching
+   */
+  private checkBrackets(source: string): PythonValidationResult {
+    const stack: { char: string; line: number; col: number }[] = [];
+    const pairs: Record<string, string> = { "(": ")", "[": "]", "{": "}" };
+    const openBrackets = new Set(["(", "[", "{"]);
+    const closeBrackets = new Set([")", "]", "}"]);
+
+    let inString = false;
+    let stringChar = "";
+    let escaped = false;
+
+    const lines = source.split("\n");
+    for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+      for (let col = 0; col < line.length; col++) {
+        const char = line[col];
+
+        // Handle string literals
+        if (!escaped && (char === '"' || char === "'")) {
+          if (!inString) {
+            inString = true;
+            stringChar = char;
+            // Check for triple quotes
+            if (line.slice(col, col + 3) === char.repeat(3)) {
+              stringChar = char.repeat(3);
+              col += 2;
+            }
+          } else if (char === stringChar || (stringChar.length === 1 && char === stringChar)) {
+            inString = false;
+            stringChar = "";
+          }
+          continue;
+        }
+
+        // Handle escape sequences
+        if (inString && char === "\\" && !escaped) {
+          escaped = true;
+          continue;
+        }
+        escaped = false;
+
+        // Skip brackets inside strings
+        if (inString) continue;
+
+        if (openBrackets.has(char)) {
+          stack.push({ char, line: lineNum + 1, col: col + 1 });
+        } else if (closeBrackets.has(char)) {
+          if (stack.length === 0) {
+            return {
+              valid: false,
+              error: `Unmatched closing bracket '${char}'`,
+              line: lineNum + 1,
+              column: col + 1,
+            };
+          }
+          const last = stack.pop()!;
+          if (pairs[last.char] !== char) {
+            return {
+              valid: false,
+              error: `Mismatched brackets: '${last.char}' at line ${last.line} should close with '${pairs[last.char]}', found '${char}'`,
+              line: lineNum + 1,
+              column: col + 1,
+            };
+          }
+        }
+      }
+    }
+
+    if (stack.length > 0) {
+      const last = stack[stack.length - 1];
+      return {
+        valid: false,
+        error: `Unclosed bracket '${last.char}'`,
+        line: last.line,
+        column: last.col,
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Check Python indentation
+   */
+  private checkIndentation(source: string): PythonValidationResult {
+    const lines = source.split("\n");
+    const indentStack: number[] = [0];
+    const colonBlockStarts = new Set<number>();
+
+    for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+      const trimmed = line.trim();
+
+      // Skip empty lines and comments
+      if (!trimmed || trimmed.startsWith("#")) {
+        continue;
+      }
+
+      // Calculate current indentation
+      const currentIndent = line.length - line.trimStart().length;
+
+      // Check for tab/space mixing
+      const leadingChars = line.slice(0, currentIndent);
+      const hasTabs = leadingChars.includes("\t");
+      const hasSpaces = leadingChars.includes(" ") && !leadingChars.includes("\t");
+
+      if (hasTabs && hasSpaces) {
+        return {
+          valid: false,
+          error: "Mixed tabs and spaces in indentation",
+          line: lineNum + 1,
+          column: 1,
+        };
+      }
+
+      // Check indentation level
+      const expectedIndent = indentStack[indentStack.length - 1];
+
+      if (currentIndent > expectedIndent) {
+        // Must be after a colon
+        if (!colonBlockStarts.has(lineNum - 1) && currentIndent !== indentStack[indentStack.length - 1] + (hasTabs ? 1 : 4)) {
+          return {
+            valid: false,
+            error: `Unexpected indent (${currentIndent} spaces, expected ${expectedIndent})`,
+            line: lineNum + 1,
+            column: 1,
+          };
+        }
+        indentStack.push(currentIndent);
+      } else if (currentIndent < expectedIndent) {
+        // Dedent - must match a previous level
+        while (indentStack.length > 1 && indentStack[indentStack.length - 1] > currentIndent) {
+          indentStack.pop();
+        }
+        if (indentStack[indentStack.length - 1] !== currentIndent) {
+          return {
+            valid: false,
+            error: `Unindent does not match any outer indentation level`,
+            line: lineNum + 1,
+            column: 1,
+          };
+        }
+      }
+
+      // Mark if this line ends with a colon (starts a block)
+      if (trimmed.endsWith(":")) {
+        colonBlockStarts.add(lineNum);
+      }
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Check string literals
+   */
+  private checkStrings(source: string): PythonValidationResult {
+    const lines = source.split("\n");
+
+    for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+      let i = 0;
+
+      while (i < line.length) {
+        const char = line[i];
+
+        // Check for string start
+        if (char === '"' || char === "'") {
+          // Check for triple quotes
+          const tripleQuote = line.slice(i, i + 3);
+          const isTriple = tripleQuote === char.repeat(3);
+          const quoteChar = isTriple ? tripleQuote : char;
+          const startIndex = i;
+          i += quoteChar.length;
+
+          // Find end of string
+          let foundEnd = false;
+          let escaped = false;
+
+          while (i < line.length) {
+            const c = line[i];
+            if (escaped) {
+              escaped = false;
+              i++;
+              continue;
+            }
+            if (c === "\\") {
+              escaped = true;
+              i++;
+              continue;
+            }
+            if (line.slice(i, i + quoteChar.length) === quoteChar) {
+              foundEnd = true;
+              i += quoteChar.length;
+              break;
+            }
+            i++;
+          }
+
+          // For triple quotes, the end might be on a later line
+          // We handle this in a simplified way - just check single-line strings
+          if (!isTriple && !foundEnd) {
+            return {
+              valid: false,
+              error: `Unterminated string literal`,
+              line: lineNum + 1,
+              column: startIndex + 1,
+            };
+          }
+        } else {
+          i++;
+        }
+      }
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Check for common syntax patterns
+   */
+  private checkSyntaxPatterns(source: string): PythonValidationResult {
+    const lines = source.split("\n");
+
+    for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum].trim();
+
+      // Skip empty lines and comments
+      if (!line || line.startsWith("#")) continue;
+
+      // Remove string literals for pattern checking
+      const codeOnly = line.replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, "");
+
+      // Check for invalid assignment targets
+      const invalidAssignment = codeOnly.match(/^(\d+|\d+\.\d+)\s*=/);
+      if (invalidAssignment) {
+        return {
+          valid: false,
+          error: `Cannot assign to literal`,
+          line: lineNum + 1,
+          column: 1,
+        };
+      }
+
+      // Check for missing colons after block statements
+      const blockKeywords = ["if", "elif", "else", "for", "while", "def", "class", "try", "except", "finally", "with"];
+      for (const kw of blockKeywords) {
+        const pattern = new RegExp(`^${kw}\\b`);
+        if (pattern.test(codeOnly) && !codeOnly.endsWith(":")) {
+          // Check if it's a single-line statement
+          if (!codeOnly.includes(";")) {
+            return {
+              valid: false,
+              error: `Missing ':' after '${kw}' statement`,
+              line: lineNum + 1,
+              column: codeOnly.indexOf(kw) + 1,
+            };
+          }
+        }
+      }
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate using Pyodide (when available)
+   */
+  private async validateWithPyodide(source: string): Promise<PythonValidationResult> {
+    try {
+      const g = globalThis as { pyodide?: { runPython?: (code: string) => unknown } };
+      if (!g.pyodide?.runPython) {
+        return { valid: true }; // Fall back to basic validation
+      }
+
+      // Use Python's compile() to check syntax
+      const code = `
+import ast
+try:
+    ast.parse(${JSON.stringify(source)})
+    "valid"
+except SyntaxError as e:
+    f"{e.msg}|{e.lineno}|{e.offset}"
+`;
+      const result = g.pyodide.runPython(code) as string;
+
+      if (result === "valid") {
+        return { valid: true };
+      }
+
+      const [msg, line, col] = result.split("|");
+      return {
+        valid: false,
+        error: msg,
+        line: line ? parseInt(line, 10) : undefined,
+        column: col ? parseInt(col, 10) : undefined,
+      };
+    } catch {
+      // If Pyodide validation fails, fall back to basic validation result
+      return { valid: true };
+    }
+  }
+
+  /**
+   * Check permissions for Python execution
+   */
+  private checkPermissions(permissions: Permissions): void {
+    // Python often needs filesystem access
+    if (permissions.fs?.write || permissions.network?.outbound) {
+      // These require appropriate sandboxing
+    }
+  }
+
+  /**
+   * Create a stub WASM module that wraps Python code
+   *
+   * This creates a minimal WASM module that can be used with a Python runtime.
+   * The actual Python execution happens in the runtime, not the compiler.
+   */
+  private async createStubWasm(source: string, options?: CompilerOptions): Promise<Uint8Array> {
+    // Encode the Python source into the WASM data section
+    const sourceBytes = new TextEncoder().encode(source);
+
+    // Create a minimal WASM module structure
+    // This is a stub - actual execution requires a Python runtime
+    const wasmModule = this.buildWasmModule(sourceBytes, options?.optimize ?? false);
+
+    return wasmModule;
+  }
+
+  /**
+   * Build a minimal WASM module structure
+   *
+   * Creates a WASM module with:
+   * - Memory section
+   * - Data section containing Python source
+   * - Exported functions for runtime interaction
+   */
+  private buildWasmModule(sourceBytes: Uint8Array, _optimize: boolean): Uint8Array {
+    // WASM module header
+    const magic = new Uint8Array([0x00, 0x61, 0x73, 0x6D]); // \0asm
+    const version = new Uint8Array([0x01, 0x00, 0x00, 0x00]); // version 1
+
+    // Build sections
+    const sections: Uint8Array[] = [];
+
+    // Type section (section id 1)
+    const typeSection = this.buildTypeSection();
+    sections.push(typeSection);
+
+    // Function section (section id 3)
+    const funcSection = this.buildFunctionSection();
+    sections.push(funcSection);
+
+    // Memory section (section id 5)
+    const memorySection = this.buildMemorySection(sourceBytes.length);
+    sections.push(memorySection);
+
+    // Export section (section id 7)
+    const exportSection = this.buildExportSection();
+    sections.push(exportSection);
+
+    // Code section (section id 10)
+    const codeSection = this.buildCodeSection();
+    sections.push(codeSection);
+
+    // Data section (section id 11)
+    const dataSection = this.buildDataSection(sourceBytes);
+    sections.push(dataSection);
+
+    // Combine all parts
+    const totalLength = magic.length + version.length +
+      sections.reduce((sum, s) => sum + s.length, 0);
+    const result = new Uint8Array(totalLength);
+
+    let offset = 0;
+    result.set(magic, offset);
+    offset += magic.length;
+    result.set(version, offset);
+    offset += version.length;
+
+    for (const section of sections) {
+      result.set(section, offset);
+      offset += section.length;
+    }
+
+    return result;
+  }
+
+  private buildTypeSection(): Uint8Array {
+    // Section id = 1
+    // 1 function type: () -> i32
+    const content = new Uint8Array([
+      0x01,  // section id
+      0x05,  // section size
+      0x01,  // 1 type
+      0x60,  // func type
+      0x00,  // 0 params
+      0x01, 0x41,  // 1 result: i32
+    ]);
+    return content;
+  }
+
+  private buildFunctionSection(): Uint8Array {
+    // Section id = 3
+    // 1 function using type 0
+    const content = new Uint8Array([
+      0x03,  // section id
+      0x02,  // section size
+      0x01,  // 1 function
+      0x00,  // type index 0
+    ]);
+    return content;
+  }
+
+  private buildMemorySection(sourceLength: number): Uint8Array {
+    // Calculate required pages (64KB each)
+    const pagesNeeded = Math.ceil((sourceLength + 65536) / 65536);
+    const maxPages = Math.max(pagesNeeded, 16);
+
+    // Section id = 5
+    const content = new Uint8Array([
+      0x05,  // section id
+      0x03,  // section size
+      0x01,  // 1 memory
+      0x00,  // no max specified (has max)
+      pagesNeeded & 0x7F,  // min pages (LEB128)
+      maxPages & 0x7F,  // max pages (LEB128)
+    ]);
+    return content;
+  }
+
+  private buildExportSection(): Uint8Array {
+    // Section id = 7
+    // Export "run" function
+    const nameBytes = new TextEncoder().encode("run");
+    const content = new Uint8Array([
+      0x07,  // section id
+      0x07,  // section size
+      0x01,  // 1 export
+      nameBytes.length,  // name length
+      ...nameBytes,  // "run"
+      0x00,  // export kind: function
+      0x00,  // function index 0
+    ]);
+    return content;
+  }
+
+  private buildCodeSection(): Uint8Array {
+    // Section id = 10
+    // Simple function that returns the source length
+    const content = new Uint8Array([
+      0x0A,  // section id
+      0x07,  // section size
+      0x01,  // 1 function body
+      0x05,  // body size
+      0x00,  // local count
+      0x41, 0x00,  // i32.const 0 (return source start offset)
+      0x0B,  // end
+    ]);
+    return content;
+  }
+
+  private buildDataSection(sourceBytes: Uint8Array): Uint8Array {
+    // Section id = 11
+    // Store Python source at memory offset 0
+    const dataHeader = new Uint8Array([
+      0x0B,  // section id
+    ]);
+
+    // Calculate section size
+    const sizeBytes = this.encodeLEB128(4 + 1 + 2 + sourceBytes.length);
+    const dataContent = new Uint8Array([
+      0x01,  // 1 data segment
+      0x00,  // active, memory index 0
+      0x41, 0x00,  // i32.const 0 (offset)
+      0x0B,  // end
+      ...this.encodeLEB128(sourceBytes.length),  // size
+    ]);
+
+    const total = new Uint8Array(dataHeader.length + sizeBytes.length + dataContent.length + sourceBytes.length);
+    let offset = 0;
+    total.set(dataHeader, offset);
+    offset += dataHeader.length;
+    total.set(sizeBytes, offset);
+    offset += sizeBytes.length;
+    total.set(dataContent, offset);
+    offset += dataContent.length;
+    total.set(sourceBytes, offset);
+
+    return total;
+  }
+
+  /**
+   * Encode a number as LEB128
+   */
+  private encodeLEB128(value: number): Uint8Array {
+    const bytes: number[] = [];
+    let remaining = value;
+
+    do {
+      let byte = remaining & 0x7F;
+      remaining >>>= 7;
+      if (remaining !== 0) {
+        byte |= 0x80;
+      }
+      bytes.push(byte);
+    } while (remaining !== 0);
+
+    return new Uint8Array(bytes);
+  }
+
+  /**
+   * Calculate memory pages needed
+   */
+  private calculateMemoryPages(source: string, limits: Limits): number {
+    const sourceSize = new TextEncoder().encode(source).length;
+    const basePages = Math.ceil(sourceSize / 65536);
+    const limitPages = limits.memory ? Math.ceil(this.parseMemoryLimit(limits.memory) / 65536) : 256;
+    return Math.max(Math.min(basePages + 4, limitPages), 4);
+  }
+
+  /**
+   * Parse memory limit to bytes
+   */
+  private parseMemoryLimit(mem: number | string): number {
+    if (typeof mem === "number") return mem;
+
+    const match = mem.match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i);
+    if (!match) return 16 * 1024 * 1024;
+
+    const [, num, unit] = match;
+    const multipliers: Record<string, number> = {
+      b: 1, kb: 1024, mb: 1024 ** 2, gb: 1024 ** 3,
+    };
+    return Math.floor(parseFloat(num) * (multipliers[unit?.toLowerCase() ?? "b"] ?? 1));
+  }
+}
+
+/**
+ * Create a Python compiler instance
+ */
+export function createPythonCompiler(): PythonCompiler {
+  return new PythonCompiler();
+}
+
+/**
+ * Default Python compiler instance
+ */
+export const pythonCompiler = new PythonCompiler();