@williamzujkowski/live-coding-music-mcp 1.0.0

package/dist/services/SessionManager.js

@@ -0,0 +1,316 @@
+import { chromium } from 'playwright';
+import { StrudelController } from '../StrudelController.js';
+import { Logger } from '../utils/Logger.js';
+/**
+ * Manages multiple concurrent Strudel browser sessions.
+ * Uses browser contexts for isolation - one browser instance with multiple contexts.
+ * Each context has isolated cookies, storage, and its own page.
+ */
+export class SessionManager {
+    browser = null;
+    sessions = new Map();
+    defaultSessionId = 'default';
+    logger;
+    isHeadless;
+    /** Maximum concurrent sessions to prevent resource exhaustion */
+    MAX_SESSIONS = 5;
+    /** Inactivity timeout in ms (30 minutes) */
+    INACTIVITY_TIMEOUT = 30 * 60 * 1000;
+    /** Cleanup interval in ms (5 minutes) */
+    CLEANUP_INTERVAL = 5 * 60 * 1000;
+    cleanupTimer = null;
+    constructor(headless = false) {
+        this.isHeadless = headless;
+        this.logger = new Logger();
+    }
+    /**
+     * Ensures the shared browser instance is running
+     */
+    async ensureBrowser() {
+        if (!this.browser) {
+            this.browser = await chromium.launch({
+                headless: this.isHeadless,
+                args: [
+                    '--use-fake-ui-for-media-stream',
+                    '--disable-dev-shm-usage',
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox',
+                    '--disable-gpu',
+                    '--disable-software-rasterizer'
+                ],
+            });
+            // Start cleanup timer when browser is created
+            this.startCleanupTimer();
+        }
+        return this.browser;
+    }
+    /**
+     * Creates a new isolated Strudel session
+     * @param id - Unique session identifier
+     * @param headless - Override headless mode for this session (unused, uses shared browser)
+     * @returns Initialized StrudelController for the session
+     * @throws {Error} When max sessions limit reached or session ID already exists
+     */
+    async createSession(id, headless) {
+        // Validate session ID
+        if (!id || typeof id !== 'string') {
+            throw new Error('Session ID must be a non-empty string');
+        }
+        // Check if session already exists
+        if (this.sessions.has(id)) {
+            throw new Error(`Session '${id}' already exists`);
+        }
+        // Check max sessions limit
+        if (this.sessions.size >= this.MAX_SESSIONS) {
+            throw new Error(`Maximum session limit (${this.MAX_SESSIONS}) reached. Destroy an existing session first.`);
+        }
+        const browser = await this.ensureBrowser();
+        // Create isolated browser context
+        const context = await browser.newContext({
+            permissions: ['microphone'],
+            viewport: { width: 1280, height: 720 },
+            reducedMotion: 'reduce',
+        });
+        const page = await context.newPage();
+        // Create controller with injected page (using a factory pattern)
+        const controller = new StrudelController(this.isHeadless);
+        // Initialize the controller with the existing page
+        await this.initializeControllerWithPage(controller, page);
+        const session = {
+            controller,
+            context,
+            page,
+            created: new Date(),
+            lastActivity: new Date(),
+        };
+        this.sessions.set(id, session);
+        this.logger.info(`Session '${id}' created`, {
+            totalSessions: this.sessions.size,
+        });
+        return controller;
+    }
+    /**
+     * Initializes a StrudelController with an existing page
+     * This bypasses the normal initialize() which creates its own browser
+     */
+    async initializeControllerWithPage(controller, page) {
+        // Set up page routing for resource optimization
+        await page.route('**/*', (route) => {
+            const resourceType = route.request().resourceType();
+            if (['image', 'font', 'media'].includes(resourceType)) {
+                route.abort();
+            }
+            else {
+                route.continue();
+            }
+        });
+        // Navigate to Strudel
+        await page.goto('https://strudel.cc/', {
+            waitUntil: 'domcontentloaded',
+            timeout: 15000,
+        });
+        // Wait for editor
+        await page.waitForSelector('.cm-content', { timeout: 8000 });
+        // Wait for CodeMirror to initialize
+        await page.waitForFunction(() => {
+            const editor = document.querySelector('.cm-content');
+            return editor && editor.__view;
+        }, { timeout: 5000 });
+        // Inject page into controller via internal method
+        controller._page = page;
+        controller.browser = null; // Controller doesn't own the browser
+        // Inject audio analyzer
+        await controller.analyzer.inject(page);
+    }
+    /**
+     * Gets an existing session's controller
+     * @param id - Session identifier
+     * @returns StrudelController or undefined if session doesn't exist
+     */
+    getSession(id) {
+        const session = this.sessions.get(id);
+        if (session) {
+            session.lastActivity = new Date();
+            return session.controller;
+        }
+        return undefined;
+    }
+    /**
+     * Destroys a session and releases its resources
+     * @param id - Session identifier
+     * @throws {Error} When session doesn't exist
+     */
+    async destroySession(id) {
+        const session = this.sessions.get(id);
+        if (!session) {
+            throw new Error(`Session '${id}' not found`);
+        }
+        try {
+            // Close the browser context (which closes the page)
+            await session.context.close();
+        }
+        catch (error) {
+            this.logger.warn(`Error closing session context: ${error.message}`);
+        }
+        this.sessions.delete(id);
+        // If this was the default session, reset to 'default'
+        if (this.defaultSessionId === id) {
+            this.defaultSessionId = 'default';
+        }
+        this.logger.info(`Session '${id}' destroyed`, {
+            totalSessions: this.sessions.size,
+        });
+        // If no more sessions, close browser
+        if (this.sessions.size === 0) {
+            await this.closeBrowser();
+        }
+    }
+    /**
+     * Lists all active session IDs
+     * @returns Array of session identifiers
+     */
+    listSessions() {
+        return Array.from(this.sessions.keys());
+    }
+    /**
+     * Gets detailed information about all sessions
+     * @returns Array of session info objects
+     */
+    getSessionsInfo() {
+        const info = [];
+        for (const [id, session] of this.sessions) {
+            info.push({
+                id,
+                created: session.created,
+                lastActivity: session.lastActivity,
+                isPlaying: session.controller.getPlaybackState(),
+            });
+        }
+        return info;
+    }
+    /**
+     * Gets the default session's controller
+     * @returns StrudelController or undefined if no default session exists
+     */
+    getDefaultSession() {
+        return this.getSession(this.defaultSessionId);
+    }
+    /**
+     * Sets the default session
+     * @param id - Session identifier to set as default
+     * @throws {Error} When session doesn't exist
+     */
+    setDefaultSession(id) {
+        if (!this.sessions.has(id)) {
+            throw new Error(`Session '${id}' not found`);
+        }
+        this.defaultSessionId = id;
+        this.logger.info(`Default session set to '${id}'`);
+    }
+    /**
+     * Gets the current default session ID
+     * @returns Default session identifier
+     */
+    getDefaultSessionId() {
+        return this.defaultSessionId;
+    }
+    /**
+     * Destroys all sessions and closes the browser
+     */
+    async destroyAll() {
+        const sessionIds = this.listSessions();
+        for (const id of sessionIds) {
+            try {
+                const session = this.sessions.get(id);
+                if (session) {
+                    await session.context.close();
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Error closing session '${id}': ${error.message}`);
+            }
+        }
+        this.sessions.clear();
+        await this.closeBrowser();
+        this.logger.info('All sessions destroyed');
+    }
+    /**
+     * Closes the shared browser instance
+     */
+    async closeBrowser() {
+        this.stopCleanupTimer();
+        if (this.browser) {
+            try {
+                await this.browser.close();
+            }
+            catch (error) {
+                this.logger.warn(`Error closing browser: ${error.message}`);
+            }
+            this.browser = null;
+        }
+    }
+    /**
+     * Starts the automatic cleanup timer
+     */
+    startCleanupTimer() {
+        if (this.cleanupTimer)
+            return;
+        this.cleanupTimer = setInterval(() => {
+            this.cleanupInactiveSessions().catch((err) => {
+                this.logger.error('Cleanup failed', err);
+            });
+        }, this.CLEANUP_INTERVAL);
+    }
+    /**
+     * Stops the automatic cleanup timer
+     */
+    stopCleanupTimer() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+    }
+    /**
+     * Cleans up sessions that have been inactive beyond the timeout
+     */
+    async cleanupInactiveSessions() {
+        const now = Date.now();
+        const sessionsToDestroy = [];
+        for (const [id, session] of this.sessions) {
+            const inactiveTime = now - session.lastActivity.getTime();
+            if (inactiveTime > this.INACTIVITY_TIMEOUT) {
+                sessionsToDestroy.push(id);
+            }
+        }
+        for (const id of sessionsToDestroy) {
+            this.logger.info(`Auto-destroying inactive session '${id}'`);
+            try {
+                await this.destroySession(id);
+            }
+            catch (error) {
+                this.logger.error(`Failed to destroy session '${id}'`, error);
+            }
+        }
+    }
+    /**
+     * Gets the number of active sessions
+     * @returns Number of active sessions
+     */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+    /**
+     * Checks if the browser is running
+     * @returns True if browser is initialized
+     */
+    isBrowserRunning() {
+        return this.browser !== null;
+    }
+    /**
+     * Gets the maximum allowed sessions
+     * @returns Maximum session limit
+     */
+    getMaxSessions() {
+        return this.MAX_SESSIONS;
+    }
+}

package/dist/services/StrudelEngine.js

@@ -0,0 +1,374 @@
+/**
+ * StrudelEngine - Local Strudel pattern engine for Node.js
+ *
+ * Executes Strudel patterns without browser automation.
+ * Uses @strudel/core, @strudel/mini, and @strudel/transpiler for:
+ * - Pattern validation with precise error locations
+ * - Event querying for pattern analysis
+ * - Syntax checking without browser overhead
+ *
+ * Note: Audio playback still requires browser (Playwright) - this is for
+ * validation and analysis only.
+ *
+ * @module services/StrudelEngine
+ */
+import * as strudelCore from '@strudel/core';
+import { mini } from '@strudel/mini';
+import { transpiler } from '@strudel/transpiler';
+/**
+ * Local Strudel pattern engine - executes patterns without browser.
+ * Replaces fragile browser automation for pattern validation and analysis.
+ *
+ * @example
+ * ```typescript
+ * const engine = new StrudelEngine();
+ *
+ * // Validate a pattern
+ * const validation = engine.validate('s("bd hh").fast(2)');
+ * if (validation.valid) {
+ *   console.log('Pattern is valid');
+ * }
+ *
+ * // Query events
+ * const events = engine.queryEvents('s("bd hh sd hh")', 0, 2);
+ * console.log(`Found ${events.length} events in 2 cycles`);
+ * ```
+ */
+export class StrudelEngine {
+    /** Execution context with Strudel functions */
+    context;
+    constructor() {
+        // Build execution context with all Strudel functions
+        this.context = {
+            ...strudelCore,
+            m: mini,
+            mini,
+        };
+    }
+    /**
+     * Transpile a Strudel pattern to JavaScript
+     *
+     * @param code - Strudel pattern code
+     * @returns Transpilation result with code or error
+     *
+     * @example
+     * ```typescript
+     * const result = engine.transpile('s("bd hh").fast(2)');
+     * if (result.success) {
+     *   console.log('Transpiled:', result.transpiledCode);
+     * }
+     * ```
+     */
+    transpile(code) {
+        if (!code || code.trim().length === 0) {
+            return {
+                success: false,
+                error: 'Empty pattern',
+                errorLocation: { line: 1, column: 1, offset: 0 },
+            };
+        }
+        try {
+            const result = transpiler(code);
+            return {
+                success: true,
+                transpiledCode: result.output,
+                locations: result.locations || [],
+            };
+        }
+        catch (error) {
+            // Parse error location from Strudel/acorn errors
+            const location = this.parseErrorLocation(error);
+            return {
+                success: false,
+                error: error.message || 'Transpilation failed',
+                errorLocation: location,
+            };
+        }
+    }
+    /**
+     * Validate pattern syntax without execution
+     *
+     * @param code - Strudel pattern code
+     * @returns Validation result with errors and suggestions
+     *
+     * @example
+     * ```typescript
+     * const result = engine.validate('s("bd hh").fast(');
+     * if (!result.valid) {
+     *   console.log('Errors:', result.errors);
+     * }
+     * ```
+     */
+    validate(code) {
+        const errors = [];
+        const warnings = [];
+        const suggestions = [];
+        // Empty check
+        if (!code || code.trim().length === 0) {
+            return {
+                valid: false,
+                errors: ['Pattern is empty'],
+                warnings: [],
+                suggestions: ['Add a pattern like: s("bd hh sd hh")'],
+            };
+        }
+        // Try transpilation first - catches syntax errors
+        const transpileResult = this.transpile(code);
+        if (!transpileResult.success) {
+            return {
+                valid: false,
+                errors: [transpileResult.error || 'Syntax error'],
+                warnings,
+                suggestions: this.getSuggestionsForError(transpileResult.error || ''),
+                errorLocation: transpileResult.errorLocation
+                    ? { line: transpileResult.errorLocation.line, column: transpileResult.errorLocation.column }
+                    : undefined,
+            };
+        }
+        // Try to evaluate the pattern to catch runtime errors
+        try {
+            const fn = new Function(...Object.keys(this.context), transpileResult.transpiledCode);
+            const pattern = fn(...Object.values(this.context));
+            // Verify it's a valid pattern
+            if (!pattern || typeof pattern.queryArc !== 'function') {
+                errors.push('Code did not produce a valid pattern');
+                suggestions.push('Ensure your code returns a pattern (e.g., s("bd"), note("c3"), stack(...))');
+            }
+        }
+        catch (error) {
+            errors.push(`Runtime error: ${error.message}`);
+            suggestions.push(...this.getSuggestionsForError(error.message));
+        }
+        // Check for common issues
+        this.checkCommonIssues(code, warnings, suggestions);
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+            suggestions,
+        };
+    }
+    /**
+     * Query pattern events for a time range
+     *
+     * @param code - Strudel pattern code
+     * @param start - Start time in cycles
+     * @param end - End time in cycles
+     * @returns Array of pattern events
+     * @throws {Error} If pattern is invalid
+     *
+     * @example
+     * ```typescript
+     * const events = engine.queryEvents('s("bd hh sd hh")', 0, 2);
+     * events.forEach(e => {
+     *   console.log(`${e.value} at ${e.start}-${e.end}`);
+     * });
+     * ```
+     */
+    queryEvents(code, start, end) {
+        const transpileResult = this.transpile(code);
+        if (!transpileResult.success) {
+            throw new Error(`Transpilation failed: ${transpileResult.error}`);
+        }
+        try {
+            const fn = new Function(...Object.keys(this.context), transpileResult.transpiledCode);
+            const pattern = fn(...Object.values(this.context));
+            if (!pattern || typeof pattern.queryArc !== 'function') {
+                throw new Error('Code did not produce a valid pattern');
+            }
+            const haps = pattern.queryArc(start, end);
+            return haps.map((hap) => this.hapToEvent(hap));
+        }
+        catch (error) {
+            throw new Error(`Pattern execution failed: ${error.message}`);
+        }
+    }
+    /**
+     * Execute a pattern and return the compiled pattern object
+     *
+     * @param code - Strudel pattern code
+     * @returns Compiled pattern object
+     * @throws {Error} If pattern is invalid
+     */
+    compile(code) {
+        const transpileResult = this.transpile(code);
+        if (!transpileResult.success) {
+            throw new Error(`Transpilation failed: ${transpileResult.error}`);
+        }
+        try {
+            const fn = new Function(...Object.keys(this.context), transpileResult.transpiledCode);
+            const pattern = fn(...Object.values(this.context));
+            if (!pattern || typeof pattern.queryArc !== 'function') {
+                throw new Error('Code did not produce a valid pattern');
+            }
+            return pattern;
+        }
+        catch (error) {
+            throw new Error(`Pattern execution failed: ${error.message}`);
+        }
+    }
+    /**
+     * Extract pattern metadata by analyzing events and code
+     *
+     * @param code - Strudel pattern code
+     * @returns Pattern metadata
+     *
+     * @example
+     * ```typescript
+     * const meta = engine.analyzePattern('s("bd hh").fast(2)');
+     * console.log('Events per cycle:', meta.eventsPerCycle);
+     * console.log('Complexity:', meta.complexity);
+     * ```
+     */
+    analyzePattern(code) {
+        // Default metadata
+        const metadata = {
+            eventsPerCycle: 0,
+            uniqueValues: [],
+            usesSound: false,
+            usesNote: false,
+            isStack: false,
+            functionsUsed: [],
+            complexity: 0,
+        };
+        // Extract BPM from setcpm
+        const bpmMatch = code.match(/setcpm\s*\(\s*(\d+(?:\.\d+)?)\s*\)/);
+        if (bpmMatch) {
+            metadata.bpm = parseFloat(bpmMatch[1]);
+        }
+        // Analyze code structure
+        metadata.usesSound = /\bs\s*\(/.test(code) || /\bsound\s*\(/.test(code);
+        metadata.usesNote = /\bnote\s*\(/.test(code);
+        metadata.isStack = /\bstack\s*\(/.test(code);
+        // Extract function names used
+        const funcMatches = code.match(/\b([a-z][a-zA-Z0-9_]*)\s*\(/g);
+        if (funcMatches) {
+            const funcNames = funcMatches.map(m => m.replace(/\s*\($/, ''));
+            metadata.functionsUsed = [...new Set(funcNames)];
+        }
+        // Try to query events for detailed analysis
+        try {
+            const events = this.queryEvents(code, 0, 1);
+            metadata.eventsPerCycle = events.length;
+            // Extract unique values
+            const values = events.map(e => {
+                if (typeof e.value === 'object' && e.value !== null) {
+                    return e.value.s || e.value.note || e.value.n || JSON.stringify(e.value);
+                }
+                return String(e.value);
+            });
+            metadata.uniqueValues = [...new Set(values)];
+            // Calculate complexity based on various factors
+            const complexityFactors = [
+                Math.min(events.length / 16, 1) * 0.3, // Event density
+                Math.min(metadata.uniqueValues.length / 8, 1) * 0.2, // Variety
+                Math.min(metadata.functionsUsed.length / 10, 1) * 0.3, // Function complexity
+                metadata.isStack ? 0.1 : 0, // Layering
+                (code.length / 500) * 0.1, // Code length
+            ];
+            metadata.complexity = Math.min(complexityFactors.reduce((a, b) => a + b, 0), 1);
+        }
+        catch {
+            // If we can't query events, estimate from code
+            metadata.complexity = Math.min((metadata.functionsUsed.length / 10) * 0.5 +
+                (code.length / 500) * 0.3 +
+                (metadata.isStack ? 0.2 : 0), 1);
+        }
+        return metadata;
+    }
+    /**
+     * Convert a Strudel Hap to our PatternEvent format
+     */
+    hapToEvent(hap) {
+        return {
+            value: hap.value,
+            start: hap.whole?.begin?.valueOf() ?? hap.part.begin.valueOf(),
+            end: hap.whole?.end?.valueOf() ?? hap.part.end.valueOf(),
+            isWhole: hap.whole !== undefined,
+            context: hap.context,
+        };
+    }
+    /**
+     * Parse error location from various error formats
+     */
+    parseErrorLocation(error) {
+        // Acorn-style location
+        if (error.loc) {
+            return {
+                line: error.loc.line,
+                column: error.loc.column,
+                offset: error.pos || 0,
+            };
+        }
+        // Strudel mini SyntaxError
+        if (error.location) {
+            return {
+                line: error.location.start.line,
+                column: error.location.start.column,
+                offset: error.location.start.offset,
+            };
+        }
+        // Try to parse from message
+        const lineColMatch = error.message?.match(/line\s*(\d+).*column\s*(\d+)/i);
+        if (lineColMatch) {
+            return {
+                line: parseInt(lineColMatch[1]),
+                column: parseInt(lineColMatch[2]),
+                offset: 0,
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Get suggestions based on error message
+     */
+    getSuggestionsForError(error) {
+        const suggestions = [];
+        const lowerError = error.toLowerCase();
+        if (lowerError.includes('unexpected token')) {
+            suggestions.push('Check for missing quotes, parentheses, or brackets');
+            suggestions.push('Ensure all function calls have matching ()');
+        }
+        if (lowerError.includes('is not defined')) {
+            const match = error.match(/(\w+) is not defined/);
+            if (match) {
+                suggestions.push(`"${match[1]}" is not a known Strudel function`);
+                suggestions.push('Check spelling or use a valid function like s(), note(), stack()');
+            }
+        }
+        if (lowerError.includes('not a function')) {
+            suggestions.push('Check that you are calling methods on a pattern object');
+        }
+        if (lowerError.includes('unexpected end')) {
+            suggestions.push('Pattern appears incomplete - check for missing closing brackets');
+        }
+        return suggestions;
+    }
+    /**
+     * Check for common issues in pattern code
+     */
+    checkCommonIssues(code, warnings, suggestions) {
+        // Check for high gain values
+        const gainMatches = code.match(/\.gain\s*\(\s*(\d+(?:\.\d+)?)\s*\)/g);
+        if (gainMatches) {
+            for (const match of gainMatches) {
+                const value = parseFloat(match.match(/(\d+(?:\.\d+)?)/)?.[1] || '0');
+                if (value > 2) {
+                    warnings.push(`High gain value (${value}) may cause distortion`);
+                }
+                if (value > 5) {
+                    warnings.push(`Dangerous gain value (${value}) - consider reducing to 2 or less`);
+                }
+            }
+        }
+        // Check for missing sound-producing functions
+        if (!/\b(s|sound|note|n)\s*\(/.test(code) && !/\bstack\s*\(/.test(code)) {
+            warnings.push('Pattern may not produce sound - no s(), note(), or stack() found');
+            suggestions.push('Add a sound source like s("bd") or note("c3")');
+        }
+        // Suggest tempo if not set
+        if (!/setcpm|setbpm|cpm|bpm/.test(code)) {
+            suggestions.push('Consider setting tempo with setcpm(120)');
+        }
+    }
+}