@ebowwa/sandbox 0.1.1

package/src/session/repl.ts

@@ -0,0 +1,521 @@
+/**
+ * REPL Primitive
+ *
+ * Interactive Read-Eval-Print-Loop for multi-language execution.
+ * Provides terminal-style interactive coding experience.
+ */
+
+import type {
+  Language,
+  ExecutionResult,
+  Permissions,
+  Limits,
+} from "../core/types.js";
+import { BaseKernel, KernelManager } from "./kernel.js";
+import { createPermissions } from "../core/permissions.js";
+import { LimitsParser } from "../core/limits.js";
+import * as readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+/**
+ * REPL options
+ */
+export interface REPLOptions {
+  /** Default language */
+  language?: Language;
+  /** Available languages */
+  languages?: Language[];
+  /** Permissions */
+  permissions?: Permissions;
+  /** Resource limits */
+  limits?: Limits;
+  /** Prompt string */
+  prompt?: string;
+  /** Continuation prompt */
+  continuationPrompt?: string;
+  /** Welcome message */
+  welcomeMessage?: string;
+  /** Kernel manager */
+  kernelManager?: KernelManager;
+  /** Kernel factory */
+  kernelFactory?: (language: Language) => Promise<BaseKernel>;
+  /** Output stream */
+  output?: NodeJS.WritableStream;
+  /** Input stream */
+  input?: NodeJS.ReadableStream;
+}
+
+/**
+ * REPL history entry
+ */
+export interface REPLHistoryEntry {
+  /** Input code */
+  input: string;
+  /** Language */
+  language: Language;
+  /** Execution result */
+  result: ExecutionResult;
+  /** Timestamp */
+  timestamp: Date;
+}
+
+/**
+ * REPL state
+ */
+export interface REPLState {
+  /** Current language */
+  language: Language;
+  /** Is reading multiline input */
+  inMultiline: boolean;
+  /** Current multiline buffer */
+  multilineBuffer: string[];
+  /** History */
+  history: REPLHistoryEntry[];
+  /** Variables */
+  variables: Map<string, unknown>;
+}
+
+/**
+ * Base REPL Implementation
+ */
+export class BaseREPL {
+  private kernelManager: KernelManager;
+  private kernelFactory?: (language: Language) => Promise<BaseKernel>;
+  private kernels = new Map<Language, BaseKernel>();
+  private permissions: Permissions;
+  private limits: Limits;
+  private prompt: string;
+  private continuationPrompt: string;
+  private welcomeMessage: string;
+  private languages: Language[];
+  private output: NodeJS.WritableStream;
+  private input: NodeJS.ReadableStream;
+  private rl?: readline.Interface;
+
+  state: REPLState;
+
+  constructor(options: REPLOptions = {}) {
+    this.kernelManager = options.kernelManager ?? new KernelManager();
+    this.kernelFactory = options.kernelFactory;
+    this.permissions = options.permissions ?? {};
+    this.limits = options.limits ?? {};
+    this.prompt = options.prompt ?? ">>> ";
+    this.continuationPrompt = options.continuationPrompt ?? "... ";
+    this.welcomeMessage = options.welcomeMessage ?? this.getDefaultWelcome();
+    this.languages = options.languages ?? ["javascript", "python", "wasm"];
+    this.output = options.output ?? output;
+    this.input = options.input ?? input;
+
+    this.state = {
+      language: options.language ?? "javascript",
+      inMultiline: false,
+      multilineBuffer: [],
+      history: [],
+      variables: new Map(),
+    };
+  }
+
+  /**
+   * Start REPL
+   */
+  async start(): Promise<void> {
+    this.print(this.welcomeMessage);
+    this.print("");
+
+    this.rl = readline.createInterface({
+      input: this.input,
+      output: this.output,
+      prompt: this.getPrompt(),
+      history: this.getHistoryStrings(),
+    });
+
+    this.rl.prompt();
+
+    for await (const line of this.rl) {
+      await this.handleLine(line);
+      this.rl.setPrompt(this.getPrompt());
+      this.rl.prompt();
+    }
+  }
+
+  /**
+   * Handle a line of input
+   */
+  async handleLine(line: string): Promise<void> {
+    // Check for commands
+    if (line.startsWith("%")) {
+      await this.handleCommand(line);
+      return;
+    }
+
+    // Check for language switch
+    const langMatch = line.match(/^!(\w+)/);
+    if (langMatch) {
+      const lang = langMatch[1] as Language;
+      if (this.languages.includes(lang)) {
+        this.state.language = lang;
+        this.print(`Switched to ${lang}`);
+      } else {
+        this.print(`Unknown language: ${lang}`);
+        this.print(`Available: ${this.languages.join(", ")}`);
+      }
+      return;
+    }
+
+    // Check for empty line
+    if (line.trim() === "") {
+      if (this.state.inMultiline) {
+        // Execute multiline
+        const code = this.state.multilineBuffer.join("\n");
+        this.state.multilineBuffer = [];
+        this.state.inMultiline = false;
+        await this.execute(code);
+      }
+      return;
+    }
+
+    // Check for continuation
+    if (this.shouldContinue(line)) {
+      this.state.inMultiline = true;
+      this.state.multilineBuffer.push(line);
+      return;
+    }
+
+    // Execute single line
+    if (this.state.inMultiline) {
+      this.state.multilineBuffer.push(line);
+    } else {
+      await this.execute(line);
+    }
+  }
+
+  /**
+   * Execute code
+   */
+  async execute(code: string): Promise<ExecutionResult> {
+    const kernel = await this.getKernel(this.state.language);
+    const result = await kernel.execute(code);
+
+    // Add to history
+    this.state.history.push({
+      input: code,
+      language: this.state.language,
+      result,
+      timestamp: new Date(),
+    });
+
+    // Display result
+    this.displayResult(result);
+
+    // Update variables
+    if (result.success && result.exports) {
+      for (const [key, value] of result.exports) {
+        this.state.variables.set(key, value);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Handle REPL command
+   */
+  private async handleCommand(command: string): Promise<void> {
+    const [cmd, ...args] = command.slice(1).split(/\s+/);
+
+    switch (cmd.toLowerCase()) {
+      case "help":
+        this.showHelp();
+        break;
+
+      case "exit":
+      case "quit":
+        this.print("Goodbye!");
+        process.exit(0);
+
+      case "clear":
+        console.clear();
+        break;
+
+      case "reset":
+        await this.reset();
+        this.print("Session reset");
+        break;
+
+      case "history":
+        this.showHistory();
+        break;
+
+      case "vars":
+        this.showVariables();
+        break;
+
+      case "lang":
+      case "language":
+        if (args[0]) {
+          const lang = args[0] as Language;
+          if (this.languages.includes(lang)) {
+            this.state.language = lang;
+            this.print(`Switched to ${lang}`);
+          } else {
+            this.print(`Unknown language: ${lang}`);
+          }
+        } else {
+          this.print(`Current language: ${this.state.language}`);
+          this.print(`Available: ${this.languages.join(", ")}`);
+        }
+        break;
+
+      case "save":
+        await this.save(args[0] ?? "session.json");
+        break;
+
+      case "load":
+        await this.load(args[0] ?? "session.json");
+        break;
+
+      default:
+        this.print(`Unknown command: ${cmd}`);
+        this.print("Type %help for available commands");
+    }
+  }
+
+  /**
+   * Get or create kernel for language
+   */
+  private async getKernel(language: Language): Promise<BaseKernel> {
+    let kernel = this.kernels.get(language);
+
+    if (!kernel) {
+      if (this.kernelFactory) {
+        kernel = await this.kernelFactory(language);
+      } else {
+        throw new Error(`No kernel available for language: ${language}`);
+      }
+
+      this.kernels.set(language, kernel);
+    }
+
+    return kernel;
+  }
+
+  /**
+   * Check if input should continue to next line
+   */
+  private shouldContinue(line: string): boolean {
+    // Check for incomplete statements
+    const openBrackets = (line.match(/[\{\[\(]/g) ?? []).length;
+    const closeBrackets = (line.match(/[\}\]\)]/g) ?? []).length;
+
+    if (openBrackets > closeBrackets) return true;
+
+    // Check for trailing operators/keywords
+    const trimmed = line.trim();
+    if (trimmed.endsWith(":") || trimmed.endsWith("\\")) return true;
+    if (/^(if|else|for|while|def|function|class)\b/.test(trimmed)) return true;
+
+    return false;
+  }
+
+  /**
+   * Display execution result
+   */
+  private displayResult(result: ExecutionResult): void {
+    // Show stdout
+    for (const line of result.output.stdout) {
+      this.print(line);
+    }
+
+    // Show stderr
+    for (const line of result.output.stderr) {
+      this.print(`[stderr] ${line}`);
+    }
+
+    // Show displays
+    for (const display of result.output.displays) {
+      switch (display.type) {
+        case "text":
+          this.print(String(display.data));
+          break;
+        case "html":
+        case "image":
+        case "json":
+        case "markdown":
+          this.print(`[${display.type} output]`);
+          break;
+      }
+    }
+
+    // Show return value
+    if (result.success && result.value !== undefined) {
+      this.print(this.formatValue(result.value));
+    }
+
+    // Show error
+    if (result.error) {
+      this.print(`Error (${result.error.type}): ${result.error.message}`);
+      if (result.error.stack) {
+        this.print(result.error.stack);
+      }
+    }
+
+    // Show metrics
+    this.print(`[${result.metrics.duration}ms]`);
+  }
+
+  /**
+   * Format value for display
+   */
+  private formatValue(value: unknown): string {
+    if (value === undefined) return "undefined";
+    if (value === null) return "null";
+    if (typeof value === "string") return `"${value}"`;
+    if (typeof value === "object") {
+      try {
+        return JSON.stringify(value, null, 2);
+      } catch {
+        return String(value);
+      }
+    }
+    return String(value);
+  }
+
+  /**
+   * Get prompt string
+   */
+  private getPrompt(): string {
+    if (this.state.inMultiline) {
+      return this.continuationPrompt;
+    }
+    return `[${this.state.language}] ${this.prompt}`;
+  }
+
+  /**
+   * Get history as strings
+   */
+  private getHistoryStrings(): string[] {
+    return this.state.history.map(h => h.input);
+  }
+
+  /**
+   * Show help
+   */
+  private showHelp(): void {
+    this.print(`
+REPL Commands:
+  %help              Show this help
+  %exit, %quit       Exit REPL
+  %clear             Clear screen
+  %reset             Reset session
+  %history           Show execution history
+  %vars              Show defined variables
+  %lang [name]       Switch or show language
+  %save [file]       Save session
+  %load [file]       Load session
+
+Shortcuts:
+  !python            Switch to Python
+  !javascript        Switch to JavaScript
+  !wasm              Switch to WASM
+
+Press Enter twice to execute multiline input.
+    `);
+  }
+
+  /**
+   * Show history
+   */
+  private showHistory(): void {
+    for (let i = 0; i < this.state.history.length; i++) {
+      const entry = this.state.history[i];
+      this.print(`${i + 1}: [${entry.language}] ${entry.input.slice(0, 50)}...`);
+    }
+  }
+
+  /**
+   * Show variables
+   */
+  private showVariables(): void {
+    if (this.state.variables.size === 0) {
+      this.print("No variables defined");
+      return;
+    }
+
+    for (const [key, value] of this.state.variables) {
+      this.print(`${key} = ${this.formatValue(value)}`);
+    }
+  }
+
+  /**
+   * Reset session
+   */
+  private async reset(): Promise<void> {
+    // Restart all kernels
+    for (const kernel of this.kernels.values()) {
+      await kernel.restart();
+    }
+
+    // Clear state
+    this.state.history = [];
+    this.state.variables.clear();
+    this.state.inMultiline = false;
+    this.state.multilineBuffer = [];
+  }
+
+  /**
+   * Save session
+   */
+  private async save(filename: string): Promise<void> {
+    const fs = await import("node:fs/promises");
+    const data = {
+      language: this.state.language,
+      history: this.state.history,
+      variables: Array.from(this.state.variables.entries()),
+    };
+
+    await fs.writeFile(filename, JSON.stringify(data, null, 2));
+    this.print(`Session saved to ${filename}`);
+  }
+
+  /**
+   * Load session
+   */
+  private async load(filename: string): Promise<void> {
+    const fs = await import("node:fs/promises");
+    const data = JSON.parse(await fs.readFile(filename, "utf-8"));
+
+    this.state.language = data.language;
+    this.state.history = data.history;
+    this.state.variables = new Map(data.variables);
+
+    this.print(`Session loaded from ${filename}`);
+  }
+
+  /**
+   * Print to output
+   */
+  private print(message: string): void {
+    this.output.write(message + "\n");
+  }
+
+  /**
+   * Get default welcome message
+   */
+  private getDefaultWelcome(): string {
+    return `
+╔════════════════════════════════════════════════════════════════╗
+║                    @ebowwa/sandbox REPL                        ║
+║                                                                ║
+║  Multi-language sandboxed execution environment               ║
+║  Type %help for commands, !<lang> to switch language          ║
+╚════════════════════════════════════════════════════════════════╝
+    `.trim();
+  }
+}
+
+/**
+ * Create a REPL
+ */
+export function createREPL(options?: REPLOptions): BaseREPL {
+  return new BaseREPL(options);
+}

package/src/wasm2wasm.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Type declarations for @ebowwa/wasm2wasm (stub)
+ * TODO: Remove when package is published
+ */
+
+declare module "@ebowwa/wasm2wasm" {
+  export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+  }
+
+  export interface WasmRuntimeOptions {
+    maxMemoryPages?: number;
+  }
+
+  export interface ExecutionResult {
+    success: boolean;
+    output?: unknown;
+    error?: string;
+    memoryUsed?: number;
+    executionTime?: number;
+  }
+
+  export function validate(bytes: Uint8Array): ValidationResult;
+  export function execute(
+    bytes: Uint8Array,
+    options?: WasmRuntimeOptions
+  ): Promise<ExecutionResult>;
+
+  export class WasmRuntimeWrapper {
+    constructor(options?: WasmRuntimeOptions);
+    execute(bytes: Uint8Array): Promise<ExecutionResult>;
+    terminate(): void;
+  }
+}