memory-journal-mcp 6.1.2 → 6.2.1

package/src/codemode/sandbox-factory.ts

@@ -1,144 +0,0 @@
-/**
- * memory-journal-mcp - Sandbox Factory
- *
- * Mode selection factory for choosing between VM and Worker sandboxes.
- * Allows runtime configuration of the sandbox mode.
- */
-
-import { CodeModeSandbox, SandboxPool } from './sandbox.js'
-import { WorkerSandbox, WorkerSandboxPool } from './worker-sandbox.js'
-import type { SandboxOptions, PoolOptions, SandboxResult } from './types.js'
-import { ConfigurationError } from '../types/errors.js'
-
-// =============================================================================
-// Types
-// =============================================================================
-
-/** Available sandbox modes */
-export type SandboxMode = 'vm' | 'worker'
-
-/** Common sandbox interface */
-export interface ISandbox {
-    execute(
-        code: string,
-        bindings: Record<string, unknown>,
-        timeoutMs?: number
-    ): Promise<SandboxResult>
-}
-
-/** Common pool interface */
-export interface ISandboxPool {
-    execute(
-        code: string,
-        bindings: Record<string, unknown>,
-        timeoutMs?: number
-    ): Promise<SandboxResult>
-    getActiveCount(): number
-    readonly poolId: string
-}
-
-/** Information about a sandbox mode */
-export interface SandboxModeInfo {
-    mode: SandboxMode
-    description: string
-    securityLevel: 'basic' | 'production'
-    isolation: string
-}
-
-// =============================================================================
-// Default Mode
-// =============================================================================
-
-let defaultMode: SandboxMode = 'worker'
-
-/**
- * Set the default sandbox mode for new sandbox instances.
- */
-export function setDefaultSandboxMode(mode: SandboxMode): void {
-    defaultMode = mode
-}
-
-/**
- * Get the current default sandbox mode.
- */
-export function getDefaultSandboxMode(): SandboxMode {
-    return defaultMode
-}
-
-/**
- * Get all available sandbox modes.
- */
-export function getAvailableSandboxModes(): SandboxMode[] {
-    return ['vm', 'worker']
-}
-
-// =============================================================================
-// Factory Functions
-// =============================================================================
-
-/**
- * Create a sandbox instance for the specified mode.
- */
-export function createSandbox(mode?: SandboxMode, options?: SandboxOptions): ISandbox {
-    const resolvedMode = mode ?? defaultMode
-
-    switch (resolvedMode) {
-        case 'vm':
-            return new CodeModeSandbox(options)
-        case 'worker':
-            return new WorkerSandbox(options)
-        default:
-            throw new ConfigurationError(`Unknown sandbox mode: ${String(resolvedMode)}`)
-    }
-}
-
-/**
- * Create a sandbox pool for the specified mode.
- */
-export function createSandboxPool(
-    mode?: SandboxMode,
-    sandboxOptions?: SandboxOptions,
-    poolOptions?: PoolOptions
-): ISandboxPool {
-    const resolvedMode = mode ?? defaultMode
-
-    switch (resolvedMode) {
-        case 'vm':
-            return new SandboxPool(sandboxOptions, poolOptions)
-        case 'worker':
-            return new WorkerSandboxPool(sandboxOptions, poolOptions)
-        default:
-            throw new ConfigurationError(`Unknown sandbox mode: ${String(resolvedMode)}`)
-    }
-}
-
-// =============================================================================
-// Mode Info
-// =============================================================================
-
-/**
- * Get information about a sandbox mode.
- */
-export function getSandboxModeInfo(mode?: SandboxMode): SandboxModeInfo {
-    const resolvedMode = mode ?? defaultMode
-
-    switch (resolvedMode) {
-        case 'vm':
-            return {
-                mode: 'vm',
-                description:
-                    'VM-based sandbox using node:vm (lightweight, not a true security boundary)',
-                securityLevel: 'basic',
-                isolation: 'Script-level context isolation via vm.createContext',
-            }
-        case 'worker':
-            return {
-                mode: 'worker',
-                description: 'Worker-thread sandbox using node:worker_threads (true V8 isolate)',
-                securityLevel: 'production',
-                isolation: 'Process-level V8 isolate with resource limits and MessagePort RPC',
-            }
-        default:
-            throw new ConfigurationError(`Unknown sandbox mode: ${String(resolvedMode)}`)
-    }
-}

package/src/codemode/sandbox.ts

@@ -1,220 +0,0 @@
-/**
- * memory-journal-mcp - Code Mode Sandbox (VM-based)
- *
- * Provides script-level isolation using `node:vm`.
- * This is the lightweight sandbox option — NOT a true security boundary.
- * For production use, prefer WorkerSandbox (worker_threads).
- */
-
-import * as vm from 'node:vm'
-import {
-    DEFAULT_SANDBOX_OPTIONS,
-    DEFAULT_POOL_OPTIONS,
-    type SandboxOptions,
-    type PoolOptions,
-    type SandboxResult,
-    type ExecutionMetrics,
-} from './types.js'
-import { transformAutoReturn } from './auto-return.js'
-
-// =============================================================================
-// Compilation Cache (LRU)
-// =============================================================================
-
-const SCRIPT_CACHE_MAX = 50
-
-class ScriptCache {
-    private readonly cache = new Map<string, vm.Script>()
-
-    get(code: string): vm.Script | undefined {
-        const script = this.cache.get(code)
-        if (script) {
-            // Move to end (most recently used)
-            this.cache.delete(code)
-            this.cache.set(code, script)
-        }
-        return script
-    }
-
-    set(code: string, script: vm.Script): void {
-        if (this.cache.size >= SCRIPT_CACHE_MAX) {
-            // Evict oldest entry
-            const firstKey = this.cache.keys().next().value
-            if (firstKey !== undefined) {
-                this.cache.delete(firstKey)
-            }
-        }
-        this.cache.set(code, script)
-    }
-
-    clear(): void {
-        this.cache.clear()
-    }
-
-    get size(): number {
-        return this.cache.size
-    }
-}
-
-// =============================================================================
-// Sandbox (VM-based)
-// =============================================================================
-
-/**
- * VM-based sandbox for executing user code in an isolated context.
- * Uses `node:vm` with nulled dangerous globals.
- *
- * WARNING: `node:vm` is NOT a true security boundary.
- * Use WorkerSandbox for production environments.
- */
-export class CodeModeSandbox {
-    private readonly options: Required<SandboxOptions>
-    private readonly scriptCache = new ScriptCache()
-
-    constructor(options?: SandboxOptions) {
-        this.options = { ...DEFAULT_SANDBOX_OPTIONS, ...options }
-    }
-
-    /**
-     * Execute code in a sandboxed VM context.
-     */
-    async execute(
-        code: string,
-        bindings: Record<string, unknown>,
-        timeoutMs?: number
-    ): Promise<SandboxResult> {
-        const effectiveTimeout = timeoutMs ?? this.options.timeoutMs
-        const startTime = performance.now()
-        const startRss = process.memoryUsage().rss
-
-        try {
-            // Build sandbox context with nulled dangerous globals
-            const sandbox: Record<string, unknown> = {
-                ...bindings,
-                console: {
-                    log: (...args: unknown[]) => args,
-                    warn: (...args: unknown[]) => args,
-                    error: (...args: unknown[]) => args,
-                },
-                // Nulled globals — prevent escape
-                process: undefined,
-                require: undefined,
-                global: undefined,
-                globalThis: undefined,
-                setTimeout: undefined,
-                setInterval: undefined,
-                setImmediate: undefined,
-            }
-
-            const context = vm.createContext(sandbox, {
-                name: 'codemode-sandbox',
-                microtaskMode: 'afterEvaluate',
-            })
-
-            // Compile or retrieve from cache
-            let script = this.scriptCache.get(code)
-            if (!script) {
-                const wrappedCode = `(async () => { ${transformAutoReturn(code)} })()`
-                script = new vm.Script(wrappedCode, {
-                    filename: 'codemode-execution.js',
-                })
-                this.scriptCache.set(code, script)
-            }
-
-            // Execute with timeout
-            const resultPromise = script.runInContext(context, {
-                timeout: effectiveTimeout,
-            }) as Promise<unknown>
-
-            const result = await resultPromise
-
-            const endTime = performance.now()
-            const endRss = process.memoryUsage().rss
-            const metrics: ExecutionMetrics = {
-                wallTimeMs: Math.round(endTime - startTime),
-                cpuTimeMs: Math.round(endTime - startTime),
-                memoryUsedMb: Math.round((endRss - startRss) / 1024 / 1024),
-            }
-
-            return { success: true, result, metrics }
-        } catch (err) {
-            const endTime = performance.now()
-            const endRss = process.memoryUsage().rss
-            const metrics: ExecutionMetrics = {
-                wallTimeMs: Math.round(endTime - startTime),
-                cpuTimeMs: Math.round(endTime - startTime),
-                memoryUsedMb: Math.round((endRss - startRss) / 1024 / 1024),
-            }
-
-            const error = err instanceof Error ? err : new Error(String(err))
-            return {
-                success: false,
-                error: error.message,
-                stack: error.stack,
-                metrics,
-            }
-        }
-    }
-
-    /** Clear the compilation cache */
-    clearCache(): void {
-        this.scriptCache.clear()
-    }
-
-    /** Get cache statistics */
-    getCacheSize(): number {
-        return this.scriptCache.size
-    }
-}
-
-// =============================================================================
-// Sandbox Pool (VM-based)
-// =============================================================================
-
-/**
- * Pool of VM-based sandboxes for concurrent execution.
- */
-export class SandboxPool {
-    private readonly options: Required<PoolOptions>
-    private readonly sandboxOptions: SandboxOptions
-    private activeCount = 0
-
-    constructor(sandboxOptions?: SandboxOptions, poolOptions?: PoolOptions) {
-        this.sandboxOptions = sandboxOptions ?? {}
-        this.options = { ...DEFAULT_POOL_OPTIONS, ...poolOptions }
-    }
-
-    /**
-     * Execute code in a pooled sandbox.
-     * Creates a fresh sandbox per execution for clean state.
-     */
-    async execute(
-        code: string,
-        bindings: Record<string, unknown>,
-        timeoutMs?: number
-    ): Promise<SandboxResult> {
-        if (this.activeCount >= this.options.maxInstances) {
-            return {
-                success: false,
-                error: `Sandbox pool exhausted (max ${String(this.options.maxInstances)} concurrent executions)`,
-                metrics: { wallTimeMs: 0, cpuTimeMs: 0, memoryUsedMb: 0 },
-            }
-        }
-
-        this.activeCount++
-        try {
-            const sandbox = new CodeModeSandbox(this.sandboxOptions)
-            return await sandbox.execute(code, bindings, timeoutMs)
-        } finally {
-            this.activeCount--
-        }
-    }
-
-    /** Get the current pool execution ID (for diagnostics) */
-    getActiveCount(): number {
-        return this.activeCount
-    }
-
-    /** Unique pool identifier */
-    readonly poolId = crypto.randomUUID()
-}

package/src/codemode/security.ts

@@ -1,155 +0,0 @@
-/**
- * memory-journal-mcp - Code Mode Security
- *
- * Security validation for sandboxed code execution.
- * Enforces code length limits, blocked patterns, rate limiting,
- * and result size caps.
- */
-
-import { DEFAULT_SECURITY_CONFIG, type SecurityConfig, type ValidationResult } from './types.js'
-
-// =============================================================================
-// Rate Limiter
-// =============================================================================
-
-interface RateLimitEntry {
-    count: number
-    resetTime: number
-}
-
-// =============================================================================
-// Security Manager
-// =============================================================================
-
-/**
- * Validates user-submitted code against security policies before execution.
- */
-export class CodeModeSecurityManager {
-    private readonly config: SecurityConfig
-    private readonly rateLimits = new Map<string, RateLimitEntry>()
-
-    constructor(config?: Partial<SecurityConfig>) {
-        this.config = { ...DEFAULT_SECURITY_CONFIG, ...config }
-    }
-
-    // =========================================================================
-    // Code Validation
-    // =========================================================================
-
-    /**
-     * Validate code against all security policies.
-     * Returns a ValidationResult with any violations found.
-     */
-    validateCode(code: string): ValidationResult {
-        const errors: string[] = []
-
-        // Length check
-        if (Buffer.byteLength(code, 'utf-8') > this.config.maxCodeLength) {
-            errors.push(`Code exceeds maximum length of ${String(this.config.maxCodeLength)} bytes`)
-        }
-
-        // Empty code check
-        if (code.trim().length === 0) {
-            errors.push('Code cannot be empty')
-        }
-
-        // Blocked pattern scan
-        for (const pattern of this.config.blockedPatterns) {
-            if (pattern.test(code)) {
-                errors.push(`Code contains blocked pattern: ${pattern.source}`)
-            }
-        }
-
-        return {
-            valid: errors.length === 0,
-            errors,
-        }
-    }
-
-    // =========================================================================
-    // Rate Limiting
-    // =========================================================================
-
-    /**
-     * Check if a client has exceeded the rate limit.
-     * Returns true if the execution is allowed.
-     */
-    checkRateLimit(clientId: string): boolean {
-        const now = Date.now()
-        const windowMs = 60_000 // 1 minute window
-        const entry = this.rateLimits.get(clientId)
-
-        if (!entry || now > entry.resetTime) {
-            this.rateLimits.set(clientId, {
-                count: 1,
-                resetTime: now + windowMs,
-            })
-            return true
-        }
-
-        if (entry.count >= this.config.maxExecutionsPerMinute) {
-            return false
-        }
-
-        entry.count++
-        return true
-    }
-
-    /**
-     * Clean up expired rate limit entries.
-     * Should be called periodically to prevent memory leaks.
-     */
-    cleanupRateLimits(): void {
-        const now = Date.now()
-        for (const [clientId, entry] of this.rateLimits) {
-            if (now > entry.resetTime) {
-                this.rateLimits.delete(clientId)
-            }
-        }
-    }
-
-    // =========================================================================
-    // Result Validation
-    // =========================================================================
-
-    /**
-     * Validate that a result does not exceed size limits.
-     */
-    validateResultSize(result: unknown): ValidationResult {
-        const errors: string[] = []
-        try {
-            // Stringify and measure length iteratively or just check the resulting buffer bounds safely.
-            // In Node, creating a huge string can trigger V8 allocation limits (max ~1GB).
-            // A safer bounds check limits string allocation immediately.
-            const serialized = JSON.stringify(result)
-
-            // If stringification succeeded but the string itself is larger than the limit
-            if (Buffer.byteLength(serialized, 'utf-8') > this.config.maxResultSize) {
-                errors.push(
-                    `Result exceeds maximum size of ${String(this.config.maxResultSize)} bytes`
-                )
-            }
-        } catch (error) {
-            if (error instanceof RangeError || String(error).includes('Invalid string length')) {
-                errors.push(
-                    `Result exceeds V8 string length allocation limits (> ~${String(this.config.maxResultSize)} bytes)`
-                )
-            } else {
-                errors.push('Result could not be serialized to JSON')
-            }
-        }
-        return {
-            valid: errors.length === 0,
-            errors,
-        }
-    }
-
-    // =========================================================================
-    // Accessors
-    // =========================================================================
-
-    /** Get the current security configuration */
-    getConfig(): Readonly<SecurityConfig> {
-        return this.config
-    }
-}