mrmd-js 2.0.0

package/src/session/context/main.js

@@ -0,0 +1,357 @@
+/**
+ * Main Execution Context
+ *
+ * Executes JavaScript in the main window context (no isolation).
+ * Provides full access to the page's DOM and state.
+ *
+ * @module session/context/main
+ */
+
+import { ConsoleCapture } from '../console-capture.js';
+
+/**
+ * @typedef {import('./interface.js').ExecutionContext} ExecutionContext
+ * @typedef {import('./interface.js').RawExecutionResult} RawExecutionResult
+ */
+
+/**
+ * @typedef {Object} StdinRequest
+ * @property {string} prompt - Prompt text to display
+ * @property {boolean} password - Whether to hide input
+ * @property {string} execId - Execution ID for this request
+ */
+
+/**
+ * @callback OnStdinRequestCallback
+ * @param {StdinRequest} request - The stdin request
+ * @returns {Promise<string>} - Resolves with user input
+ */
+
+/**
+ * @typedef {Object} MainContextOptions
+ * @property {Record<string, *>} [utilities] - Custom utilities to inject
+ */
+
+/**
+ * Main window execution context (no isolation)
+ * @implements {ExecutionContext}
+ */
+export class MainContext {
+  /** @type {Set<string>} */
+  #trackedVars = new Set();
+
+  /** @type {ConsoleCapture | null} */
+  #consoleCapture = null;
+
+  /** @type {MainContextOptions} */
+  #options;
+
+  /** @type {boolean} */
+  #initialized = false;
+
+  /** @type {Array<{data: Record<string, string>, metadata: Record<string, *>}>} */
+  #displayQueue = [];
+
+  /** @type {OnStdinRequestCallback | null} */
+  #onStdinRequest = null;
+
+  /** @type {string} */
+  #currentExecId = '';
+
+  /**
+   * @param {MainContextOptions} [options]
+   */
+  constructor(options = {}) {
+    this.#options = options;
+  }
+
+  /**
+   * Initialize the context
+   */
+  #initialize() {
+    if (this.#initialized) return;
+
+    // Set up utilities on window
+    this.#setupUtilities();
+
+    // Set up console capture
+    this.#consoleCapture = new ConsoleCapture(window);
+    this.#consoleCapture.start();
+
+    this.#initialized = true;
+  }
+
+  /**
+   * Set up utility functions
+   */
+  #setupUtilities() {
+    const self = this;
+
+    // Sleep helper (if not already defined)
+    if (!('sleep' in window)) {
+      /** @type {*} */ (window).sleep = (ms) =>
+        new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
+    // Print helper
+    if (!('print' in window) || typeof window.print !== 'function') {
+      /** @type {*} */ (window).print = (...args) => {
+        console.log(...args);
+      };
+    }
+
+    // Input helper - prompts for user input (like Python's input())
+    /** @type {*} */ (window).__mrmd_input__ = async (prompt = '', options = {}) => {
+      // Print prompt to console (like Python does)
+      if (prompt) {
+        console.log(prompt);
+      }
+
+      // If no stdin handler is set, fall back to browser prompt()
+      if (!self.#onStdinRequest) {
+        const result = window.prompt(prompt) ?? '';
+        return result;
+      }
+
+      // Request input from the external handler
+      const request = {
+        prompt: prompt,
+        password: options.password ?? false,
+        execId: self.#currentExecId,
+      };
+
+      try {
+        const response = await self.#onStdinRequest(request);
+        // Remove trailing newline if present (input() in Python strips it)
+        return response.replace(/\n$/, '');
+      } catch (error) {
+        // If cancelled, throw an error like Python's KeyboardInterrupt
+        throw new Error('Input cancelled');
+      }
+    };
+
+    // Expose as 'input' if not already defined
+    if (!('input' in window)) {
+      /** @type {*} */ (window).input = /** @type {*} */ (window).__mrmd_input__;
+    }
+
+    // Display helper
+    /** @type {*} */ (window).__mrmd_display__ = (data, mimeType = 'text/plain') => {
+      let content;
+      if (typeof data === 'string') {
+        content = data;
+      } else if (data instanceof HTMLElement) {
+        content = data.outerHTML;
+        mimeType = 'text/html';
+      } else {
+        try {
+          content = JSON.stringify(data, null, 2);
+          mimeType = 'application/json';
+        } catch {
+          content = String(data);
+        }
+      }
+
+      this.#displayQueue.push({ data: { [mimeType]: content }, metadata: {} });
+    };
+
+    // Inject custom utilities
+    if (this.#options.utilities) {
+      for (const [key, value] of Object.entries(this.#options.utilities)) {
+        /** @type {*} */ (window)[key] = value;
+      }
+    }
+  }
+
+  /**
+   * Set the stdin request handler
+   * @param {OnStdinRequestCallback | null} handler
+   */
+  setStdinHandler(handler) {
+    this.#onStdinRequest = handler;
+  }
+
+  /**
+   * Get the current stdin request handler
+   * @returns {OnStdinRequestCallback | null}
+   */
+  getStdinHandler() {
+    return this.#onStdinRequest;
+  }
+
+  /**
+   * Execute code in main context
+   * @param {string} code - Already transformed/wrapped code from executor
+   * @param {{ execId?: string }} [options] - Execution options
+   * @returns {Promise<RawExecutionResult>}
+   */
+  async execute(code, options = {}) {
+    this.#initialize();
+
+    // Set current execution ID for input() calls
+    this.#currentExecId = options.execId || '';
+
+    // Clear display queue
+    this.#displayQueue = [];
+
+    // Clear console capture
+    this.#consoleCapture?.clear();
+
+    const startTime = performance.now();
+
+    try {
+      // Execute - code is already transformed/wrapped by the executor
+      const result = await eval(code);
+      const duration = performance.now() - startTime;
+
+      // Get logs
+      const logs = this.#consoleCapture?.flush() || [];
+
+      return {
+        result,
+        logs,
+        duration,
+      };
+    } catch (error) {
+      const duration = performance.now() - startTime;
+      const logs = this.#consoleCapture?.flush() || [];
+
+      return {
+        result: undefined,
+        logs,
+        error: error instanceof Error ? error : new Error(String(error)),
+        duration,
+      };
+    } finally {
+      // Clear current exec ID
+      this.#currentExecId = '';
+    }
+  }
+
+  /**
+   * Get all user-defined variables
+   * @returns {Record<string, *>}
+   */
+  getVariables() {
+    const vars = {};
+    for (const name of this.#trackedVars) {
+      try {
+        vars[name] = /** @type {*} */ (window)[name];
+      } catch {
+        // Skip inaccessible
+      }
+    }
+    return vars;
+  }
+
+  /**
+   * Get a specific variable
+   * @param {string} name
+   * @returns {*}
+   */
+  getVariable(name) {
+    return /** @type {*} */ (window)[name];
+  }
+
+  /**
+   * Check if variable exists
+   * @param {string} name
+   * @returns {boolean}
+   */
+  hasVariable(name) {
+    return name in window;
+  }
+
+  /**
+   * Get the global object
+   * @returns {Window}
+   */
+  getGlobal() {
+    return window;
+  }
+
+  /**
+   * Track a declared variable
+   * @param {string} name
+   */
+  trackVariable(name) {
+    this.#trackedVars.add(name);
+  }
+
+  /**
+   * Get tracked variable names
+   * @returns {Set<string>}
+   */
+  getTrackedVariables() {
+    return this.#trackedVars;
+  }
+
+  /**
+   * Reset the context
+   */
+  reset() {
+    // Delete tracked variables from window
+    for (const name of this.#trackedVars) {
+      try {
+        delete /** @type {*} */ (window)[name];
+      } catch {
+        // Some properties can't be deleted
+      }
+    }
+    this.#trackedVars = new Set();
+    this.#displayQueue = [];
+  }
+
+  /**
+   * Destroy the context
+   */
+  destroy() {
+    this.#consoleCapture?.stop();
+    this.#consoleCapture = null;
+
+    // Clean up tracked variables
+    this.reset();
+
+    // Clean up utilities we added
+    try {
+      delete /** @type {*} */ (window).__mrmd_display__;
+    } catch {
+      // Ignore
+    }
+
+    this.#initialized = false;
+  }
+
+  /**
+   * Check if this is main context
+   * @returns {boolean}
+   */
+  isMainContext() {
+    return true;
+  }
+
+  /**
+   * Get the iframe element
+   * @returns {null}
+   */
+  getIframe() {
+    return null;
+  }
+
+  /**
+   * Get display data queue
+   * @returns {Array<{data: Record<string, string>, metadata: Record<string, *>}>}
+   */
+  getDisplayQueue() {
+    return this.#displayQueue;
+  }
+}
+
+/**
+ * Create a main context
+ * @param {MainContextOptions} [options]
+ * @returns {MainContext}
+ */
+export function createMainContext(options) {
+  return new MainContext(options);
+}

package/src/session/index.js

@@ -0,0 +1,16 @@
+/**
+ * Session Management
+ *
+ * Session and context management for mrmd-js.
+ * @module session
+ */
+
+// Session classes
+export { Session, createSession } from './session.js';
+export { SessionManager, createSessionManager } from './manager.js';
+
+// Context infrastructure
+export { ConsoleCapture, createConsoleCapture } from './console-capture.js';
+export { IframeContext, createIframeContext } from './context/iframe.js';
+export { MainContext, createMainContext } from './context/main.js';
+export * from './context/interface.js';

package/src/session/manager.js

@@ -0,0 +1,327 @@
+/**
+ * Session Manager
+ *
+ * Manages multiple sessions, handles creation/destruction,
+ * and enforces limits.
+ *
+ * @module session/manager
+ */
+
+import { Session } from './session.js';
+
+/**
+ * @typedef {import('../types/session.js').SessionInfo} SessionInfo
+ * @typedef {import('../types/session.js').CreateSessionOptions} CreateSessionOptions
+ */
+
+/**
+ * @typedef {Object} SessionManagerOptions
+ * @property {number} [maxSessions=10] - Maximum number of concurrent sessions
+ * @property {string} [defaultLanguage='javascript'] - Default language for new sessions
+ * @property {import('../types/session.js').IsolationMode} [defaultIsolation='iframe'] - Default isolation mode
+ * @property {boolean} [defaultAllowMainAccess=false] - Default main access setting
+ */
+
+/**
+ * Generate a unique session ID
+ * @returns {string}
+ */
+function generateSessionId() {
+  return `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+/**
+ * Session Manager - manages multiple execution sessions
+ */
+export class SessionManager {
+  /** @type {Map<string, Session>} */
+  #sessions = new Map();
+
+  /** @type {SessionManagerOptions} */
+  #options;
+
+  /**
+   * @param {SessionManagerOptions} [options]
+   */
+  constructor(options = {}) {
+    this.#options = {
+      maxSessions: 10,
+      defaultLanguage: 'javascript',
+      defaultIsolation: 'iframe',
+      defaultAllowMainAccess: false,
+      ...options,
+    };
+  }
+
+  // ============================================================================
+  // Session Lifecycle
+  // ============================================================================
+
+  /**
+   * Create a new session
+   * @param {CreateSessionOptions} [options]
+   * @returns {Session}
+   * @throws {Error} If max sessions reached
+   */
+  create(options = {}) {
+    // Check limits
+    if (this.#sessions.size >= this.#options.maxSessions) {
+      throw new Error(
+        `Maximum sessions (${this.#options.maxSessions}) reached. ` +
+          'Destroy existing sessions before creating new ones.'
+      );
+    }
+
+    // Generate ID if not provided
+    const id = options.id || generateSessionId();
+
+    // Check for duplicate ID
+    if (this.#sessions.has(id)) {
+      throw new Error(`Session with ID '${id}' already exists`);
+    }
+
+    // Merge with defaults
+    const sessionOptions = {
+      language: options.language || this.#options.defaultLanguage,
+      isolation: options.isolation || this.#options.defaultIsolation,
+      allowMainAccess: options.allowMainAccess ?? this.#options.defaultAllowMainAccess,
+      utilities: options.utilities,
+      executorRegistry: options.executorRegistry,
+    };
+
+    // Create session
+    const session = new Session(id, sessionOptions);
+    this.#sessions.set(id, session);
+
+    return session;
+  }
+
+  /**
+   * Get an existing session by ID
+   * @param {string} id
+   * @returns {Session | undefined}
+   */
+  get(id) {
+    return this.#sessions.get(id);
+  }
+
+  /**
+   * Get a session, creating it if it doesn't exist
+   * @param {string} id
+   * @param {CreateSessionOptions} [options]
+   * @returns {Session}
+   */
+  getOrCreate(id, options = {}) {
+    const existing = this.#sessions.get(id);
+    if (existing) {
+      return existing;
+    }
+    return this.create({ ...options, id });
+  }
+
+  /**
+   * Check if a session exists
+   * @param {string} id
+   * @returns {boolean}
+   */
+  has(id) {
+    return this.#sessions.has(id);
+  }
+
+  /**
+   * Destroy a session by ID
+   * @param {string} id
+   * @returns {boolean} Whether a session was destroyed
+   */
+  destroy(id) {
+    const session = this.#sessions.get(id);
+    if (session) {
+      session.destroy();
+      this.#sessions.delete(id);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Destroy all sessions
+   */
+  destroyAll() {
+    for (const session of this.#sessions.values()) {
+      session.destroy();
+    }
+    this.#sessions.clear();
+  }
+
+  // ============================================================================
+  // Session Queries
+  // ============================================================================
+
+  /**
+   * List all sessions
+   * @returns {SessionInfo[]}
+   */
+  list() {
+    return Array.from(this.#sessions.values()).map((s) => s.getInfo());
+  }
+
+  /**
+   * Get number of active sessions
+   * @returns {number}
+   */
+  get size() {
+    return this.#sessions.size;
+  }
+
+  /**
+   * Get all session IDs
+   * @returns {string[]}
+   */
+  get ids() {
+    return Array.from(this.#sessions.keys());
+  }
+
+  /**
+   * Get the maximum number of sessions allowed
+   * @returns {number}
+   */
+  get maxSessions() {
+    return this.#options.maxSessions;
+  }
+
+  /**
+   * Iterate over sessions
+   * @returns {IterableIterator<Session>}
+   */
+  [Symbol.iterator]() {
+    return this.#sessions.values();
+  }
+
+  /**
+   * Iterate over session entries
+   * @returns {IterableIterator<[string, Session]>}
+   */
+  entries() {
+    return this.#sessions.entries();
+  }
+
+  // ============================================================================
+  // Bulk Operations
+  // ============================================================================
+
+  /**
+   * Reset all sessions (clear variables but keep sessions)
+   */
+  resetAll() {
+    for (const session of this.#sessions.values()) {
+      session.reset();
+    }
+  }
+
+  /**
+   * Interrupt all running executions across all sessions
+   * @returns {number} Number of sessions that had executions interrupted
+   */
+  interruptAll() {
+    let count = 0;
+    for (const session of this.#sessions.values()) {
+      if (session.interrupt()) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Get sessions by language
+   * @param {string} language
+   * @returns {Session[]}
+   */
+  getByLanguage(language) {
+    const results = [];
+    for (const session of this.#sessions.values()) {
+      if (session.language === language) {
+        results.push(session);
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Get the most recently active session
+   * @returns {Session | undefined}
+   */
+  getMostRecent() {
+    let mostRecent = undefined;
+    let latestTime = 0;
+
+    for (const session of this.#sessions.values()) {
+      const time = session.lastActivity.getTime();
+      if (time > latestTime) {
+        latestTime = time;
+        mostRecent = session;
+      }
+    }
+
+    return mostRecent;
+  }
+
+  // ============================================================================
+  // Cleanup
+  // ============================================================================
+
+  /**
+   * Destroy sessions that have been inactive for a certain time
+   * @param {number} maxIdleMs - Maximum idle time in milliseconds
+   * @returns {number} Number of sessions destroyed
+   */
+  cleanupIdle(maxIdleMs) {
+    const now = Date.now();
+    const toDestroy = [];
+
+    for (const [id, session] of this.#sessions) {
+      if (now - session.lastActivity.getTime() > maxIdleMs) {
+        toDestroy.push(id);
+      }
+    }
+
+    for (const id of toDestroy) {
+      this.destroy(id);
+    }
+
+    return toDestroy.length;
+  }
+
+  /**
+   * Destroy oldest sessions to get under a certain count
+   * @param {number} targetCount - Target number of sessions
+   * @returns {number} Number of sessions destroyed
+   */
+  trimToCount(targetCount) {
+    if (this.#sessions.size <= targetCount) {
+      return 0;
+    }
+
+    // Sort by last activity (oldest first)
+    const sorted = Array.from(this.#sessions.entries()).sort(
+      ([, a], [, b]) => a.lastActivity.getTime() - b.lastActivity.getTime()
+    );
+
+    const toDestroy = sorted.slice(0, this.#sessions.size - targetCount);
+
+    for (const [id] of toDestroy) {
+      this.destroy(id);
+    }
+
+    return toDestroy.length;
+  }
+}
+
+/**
+ * Create a session manager
+ * @param {SessionManagerOptions} [options]
+ * @returns {SessionManager}
+ */
+export function createSessionManager(options) {
+  return new SessionManager(options);
+}