@williamzujkowski/live-coding-music-mcp 4.0.0 → 4.1.1

package/dist/services/AudioCaptureService.js

@@ -20,6 +20,8 @@ export class AudioCaptureService {
     DEFAULT_SAMPLE_RATE = 48000;
     DEFAULT_DURATION_MS = 5000;
     MIME_TYPE = 'audio/webm;codecs=opus';
+    /** Cap on an unbounded streaming capture. Ten minutes (#437). */
+    static DEFAULT_MAX_CAPTURE_MS = 10 * 60 * 1000;
     /**
      * Injects audio capture code into the Strudel page.
      * Must be called before any capture operations.
@@ -27,10 +29,83 @@ export class AudioCaptureService {
      * @param page - Playwright page instance to inject into
      * @throws {Error} When injection fails
      */
+    /**
+     * The page this service's recorder was injected into.
+     *
+     * A service is bound to one page: `injectRecorder` defines
+     * `window.strudelAudioCapture` there, and every later call evaluates
+     * against it. Callers that cache services must be able to tell whether
+     * a cached one still matches the page they are about to use — a session
+     * recreated under the same id, or a browser recovered by `init`, gets a
+     * NEW page, and the old recorder does not exist on it (#264).
+     */
+    injectedPage = null;
+    /**
+     * Whether this service's recorder is live on the given page.
+     *
+     * Asks the page, rather than comparing object identity. A Playwright
+     * `Page` outlives the JS realm it points at: reload strudel.cc — which
+     * a user can do at any time, since CLAUDE.md makes the visible browser
+     * window the intended interface — and `window.strudelAudioCapture` is
+     * gone while `injectedPage === page` still holds.
+     *
+     * The cached service was then returned without re-injecting, and every
+     * capture and export failed with "Audio capture not initialized" for
+     * the rest of the session. `init` could not recover it either:
+     * `initialize()` returns 'Already initialized' whenever the page is
+     * alive, so the same page and the same cached service came back (#437).
+     *
+     * Identity is still checked first — it is free, and it catches the
+     * recreated-session and recovered-browser cases (#264) without a round
+     * trip to the page.
+     */
+    async isInjectedInto(page) {
+        if (this.injectedPage !== page)
+            return false;
+        try {
+            return await page.evaluate(/* istanbul ignore next */ () => typeof window.strudelAudioCapture === 'object'
+                && window.strudelAudioCapture !== null);
+        }
+        catch {
+            // An unreadable page is not an injected one.
+            return false;
+        }
+    }
     async injectRecorder(page) {
         /* istanbul ignore next -- browser-injected IIFE, covered by integration tests */
-        await page.evaluate(() => {
+        await page.evaluate(/* istanbul ignore next */ () => {
+            // Clear the previous object's timers before replacing it.
+            //
+            // This assignment overwrites `strudelAudioCapture` outright, and
+            // a `setTimeout` does not stop because nothing points at its
+            // owner any more. `server.ts` builds a fresh service for a page
+            // that may already carry an injected object, so a cap timer or a
+            // stop watchdog from the old one could still fire — and both of
+            // them reach in and empty `chunks`, which is how the previous
+            // capture's watchdog destroyed the NEXT capture in #464.
+            //
+            // The same hazard, measured on the analyzer's collector, is
+            // #479: a re-inject there left the old 20ms interval sampling
+            // into an orphaned array.
+            const previous = window.strudelAudioCapture;
+            if (previous) {
+                if (previous.capTimer)
+                    clearTimeout(previous.capTimer);
+                if (previous.stopWatchdog)
+                    clearTimeout(previous.stopWatchdog);
+                previous.capTimer = null;
+                previous.stopWatchdog = null;
+                previous.isCapturing = false;
+            }
             window.strudelAudioCapture = {
+                /** In-flight stop, so a second one waits rather than racing it. */
+                stopping: null,
+                /** Auto-stop at maxDuration; cleared when a stop lands first. */
+                capTimer: null,
+                /** Set when the cap ended the recording, so a later stop knows. */
+                reachedCap: false,
+                /** Watchdog for a stop that never completes; cleared when it does. */
+                stopWatchdog: null,
                 mediaStreamDest: null,
                 recorder: null,
                 isConnected: false,
@@ -64,7 +139,7 @@ export class AudioCaptureService {
                  * Starts audio capture
                  * @returns Success status and any error message
                  */
-                startCapture() {
+                startCapture(maxDurationMs) {
                     const capture = window.strudelAudioCapture;
                     if (!capture.isConnected || !capture.mediaStreamDest) {
                         return {
@@ -76,9 +151,21 @@ export class AudioCaptureService {
                         return { success: false, error: 'Capture already in progress.' };
                     }
                     try {
-                        // Reset state
+                        // Reset state. Timers included: a leftover timer from an
+                        // earlier capture fires against THIS one, and both of them
+                        // reach in and empty `chunks` (#464).
                         capture.chunks = [];
                         capture.error = null;
+                        capture.reachedCap = false;
+                        if (capture.capTimer !== null) {
+                            clearTimeout(capture.capTimer);
+                            capture.capTimer = null;
+                        }
+                        if (capture.stopWatchdog !== null) {
+                            clearTimeout(capture.stopWatchdog);
+                            capture.stopWatchdog = null;
+                        }
+                        capture.stopping = null;
                         // Create MediaRecorder with WebM/Opus codec (Gemini compatible)
                         const options = {
                             mimeType: 'audio/webm;codecs=opus'
@@ -98,10 +185,45 @@ export class AudioCaptureService {
                         };
                         capture.startTime = Date.now();
                         capture.isCapturing = true;
+                        // A previous capture's error is not this one's.
+                        capture.error = null;
                         capture.recorder.start(100); // Collect data every 100ms
+                        // A streaming capture had no upper bound at all: it
+                        // accumulated a 100ms blob in page memory until someone
+                        // stopped it, and `maxDuration` — advertised by the tool —
+                        // was accepted and discarded (#437).
+                        //
+                        // The cap stops the recorder and marks WHY. Without the mark
+                        // the recording was thrown away: `onstop` clears
+                        // `isCapturing`, so a later `stop` fell into the "No capture
+                        // in progress" branch with every chunk still sitting in
+                        // `capture.chunks`. The comment here used to claim the
+                        // opposite — and with a ten-minute default on every capture,
+                        // any long take lost all of its audio (#464).
+                        if (typeof maxDurationMs === 'number' && maxDurationMs > 0) {
+                            capture.capTimer = setTimeout(() => {
+                                if (!capture.isCapturing)
+                                    return;
+                                capture.reachedCap = true;
+                                try {
+                                    capture.recorder.stop();
+                                }
+                                catch { /* already stopped */ }
+                            }, maxDurationMs);
+                        }
                         return { success: true };
                     }
                     catch (err) {
+                        // Reset before returning, or the page is wedged for good.
+                        //
+                        // `isCapturing` is set just above, and `recorder.start()` can
+                        // throw — on a track-less stream, for instance. The flag then
+                        // stayed true while the Node mirror stayed false, so every
+                        // later start got "Capture already in progress", every export
+                        // got "A capture is already in progress", and stop was
+                        // refused by the Node-side gate. Nothing cleared it short of
+                        // a new page (#437).
+                        capture.isCapturing = false;
                         return { success: false, error: err.message || 'Failed to start capture' };
                     }
                 },
@@ -112,13 +234,89 @@ export class AudioCaptureService {
                 async stopCapture() {
                     const capture = window.strudelAudioCapture;
                     if (!capture.recorder || !capture.isCapturing) {
+                        // The cap ended it. That is a finished recording, not an
+                        // absent one — hand it over (#464).
+                        if (capture.reachedCap === true && capture.chunks.length > 0) {
+                            const collected = capture.chunks;
+                            capture.chunks = [];
+                            capture.reachedCap = false;
+                            return {
+                                success: true,
+                                blob: new Blob(collected, { type: 'audio/webm;codecs=opus' }),
+                                duration: Date.now() - capture.startTime,
+                                format: 'audio/webm;codecs=opus',
+                                warning: 'Recording stopped at maxDuration; this is the audio up to that point.',
+                            };
+                        }
+                        // A recorder error clears `isCapturing` too, so this branch
+                        // covered two very different situations with one message.
+                        // `capture.error` was set and nothing ever read it — the
+                        // real cause was discarded and the caller was told there had
+                        // been no capture at all (#437).
+                        if (capture.error !== null) {
+                            const failure = capture.error;
+                            const orphaned = capture.chunks.length;
+                            capture.error = null;
+                            capture.chunks = [];
+                            return {
+                                success: false,
+                                error: `${failure}. ${String(orphaned)} chunk(s) were recorded before it and have been discarded.`,
+                            };
+                        }
                         return { success: false, error: 'No capture in progress.' };
                     }
-                    return new Promise((resolve) => {
+                    // A stop already in flight is awaited, not started again.
+                    //
+                    // `isCapturing` is cleared inside `onstop`, which has not run
+                    // yet when a second stop arrives — so both calls got past the
+                    // check above, the second overwrote the first's `onstop` and
+                    // called `stop()` on an inactive recorder. The second threw
+                    // InvalidStateError; the FIRST call's resolver became
+                    // unreachable, and `page.evaluate` has no timeout, so that MCP
+                    // request never returned (#437).
+                    if (capture.stopping) {
+                        return await capture.stopping;
+                    }
+                    capture.stopping = new Promise((resolve) => {
                         const recorder = capture.recorder;
                         const startTime = capture.startTime;
+                        // Both timers die on whichever path settles first. The
+                        // watchdog handle was not kept at all, so it outlived its
+                        // own capture and fired during the NEXT one — passing its
+                        // guard, clearing `isCapturing` and emptying `chunks`, which
+                        // destroyed a recording that was going perfectly well. The
+                        // cap timer leaked the same way across captures and could
+                        // stop a recorder that belonged to a later take (#464).
+                        // Method shorthand, not `const clearTimers = () => {}`:
+                        // esbuild rewrites the arrow into `__name(fn, "fn")` and
+                        // `__name` does not exist in page context. Written as an
+                        // arrow first; PageEvaluateNameWrapping.test.ts caught it.
+                        const timers = {
+                            clear() {
+                                if (capture.capTimer !== null) {
+                                    clearTimeout(capture.capTimer);
+                                    capture.capTimer = null;
+                                }
+                                if (capture.stopWatchdog !== null) {
+                                    clearTimeout(capture.stopWatchdog);
+                                    capture.stopWatchdog = null;
+                                }
+                            },
+                        };
                         recorder.onstop = () => {
                             capture.isCapturing = false;
+                            timers.clear();
+                            // An error that fired after this handler was installed
+                            // still delivers `dataavailable` and `stop`, so this used
+                            // to return success:true over a truncated recording and
+                            // the tool reported a normal capture (#437).
+                            if (capture.error !== null) {
+                                const failure = capture.error;
+                                capture.error = null;
+                                capture.chunks = [];
+                                resolve({ success: false, error: `${failure} during stop; the recording is incomplete.` });
+                                return;
+                            }
                             const duration = Date.now() - startTime;
                             if (capture.chunks.length === 0) {
                                 resolve({ success: false, error: 'No audio data captured.' });
@@ -133,8 +331,41 @@ export class AudioCaptureService {
                                 format: 'audio/webm;codecs=opus'
                             });
                         };
+                        // A stop that never completes must not hang the request.
+                        //
+                        // `page.evaluate` has no timeout, so if `onstop` never fires
+                        // — a wedged recorder, a stream whose tracks died — the MCP
+                        // call waits forever. Resolving with whatever was collected
+                        // is a worse recording than the caller asked for and an
+                        // infinitely better outcome than no answer (#437).
+                        capture.stopWatchdog = setTimeout(() => {
+                            // Always settles. This used to `return` without resolving
+                            // when the capture was already flagged done and empty —
+                            // which is precisely the never-returning request #437 was
+                            // written to remove, reintroduced by its own fix (#464).
+                            capture.stopWatchdog = null;
+                            timers.clear();
+                            capture.isCapturing = false;
+                            const collected = capture.chunks;
+                            capture.chunks = [];
+                            resolve(collected.length === 0
+                                ? { success: false, error: 'Recorder did not stop, and nothing was captured.' }
+                                : {
+                                    success: true,
+                                    blob: new Blob(collected, { type: 'audio/webm;codecs=opus' }),
+                                    duration: Date.now() - startTime,
+                                    format: 'audio/webm;codecs=opus',
+                                    warning: 'Recorder did not stop cleanly; returned what was captured.',
+                                });
+                        }, 5000);
                         recorder.stop();
                     });
+                    try {
+                        return await capture.stopping;
+                    }
+                    finally {
+                        capture.stopping = null;
+                    }
                 },
                 /**
                  * Returns current capture state
@@ -151,6 +382,7 @@ export class AudioCaptureService {
             // Initialize connection interception
             window.strudelAudioCapture.connect();
         });
+        this.injectedPage = page;
         this.logger.debug('Audio capture injected');
     }
     /**
@@ -161,14 +393,19 @@ export class AudioCaptureService {
      *   recorder config is fixed at injectRecorder time)
      * @throws {Error} When capture fails to start
      */
-    async startCapture(page, _config) {
-        const result = await page.evaluate(/* istanbul ignore next */ () => {
+    async startCapture(page, config) {
+        // Bounded even when the caller does not ask. An unbounded streaming
+        // capture grows in page memory until someone remembers to stop it,
+        // and nothing here ever timed it out (#437). Ten minutes is far
+        // longer than any musical take and far shorter than forever.
+        const maxDurationMs = config?.maxDuration ?? AudioCaptureService.DEFAULT_MAX_CAPTURE_MS;
+        const result = await page.evaluate(/* istanbul ignore next */ (capMs) => {
             const capture = window.strudelAudioCapture;
             if (!capture) {
                 return { success: false, error: 'Audio capture not initialized. Call injectRecorder first.' };
             }
-            return capture.startCapture();
-        });
+            return capture.startCapture(capMs);
+        }, maxDurationMs);
         if (!result.success) {
             throw new Error(result.error || 'Failed to start capture');
         }
@@ -189,18 +426,50 @@ export class AudioCaptureService {
             if (!capture) {
                 return { success: false, error: 'Audio capture not initialized.' };
             }
-            return await capture.stopCapture();
+            const captureResult = await capture.stopCapture();
+            if (!captureResult.success || !captureResult.blob) {
+                return captureResult;
+            }
+            // Playwright cannot serialize a browser Blob into a Node Blob with
+            // methods intact. Convert to base64 inside the browser context and
+            // rehydrate a real Node-side Blob below.
+            const buffer = await captureResult.blob.arrayBuffer();
+            const bytes = new Uint8Array(buffer);
+            let binary = '';
+            for (let i = 0; i < bytes.length; i++) {
+                binary += String.fromCharCode(bytes[i]);
+            }
+            return {
+                success: true,
+                audio: btoa(binary),
+                duration: captureResult.duration,
+                format: captureResult.format,
+                warning: captureResult.warning,
+            };
+        }).finally(() => {
+            // Cleared whatever happens.
+            //
+            // This assignment sat after the await, so a rejected evaluate --
+            // a closed page, a navigation, a crashed renderer -- skipped it
+            // and left the Node mirror reading "capturing" for a capture that
+            // is over. Recoverable, since a later stop clears it, but it
+            // costs a wasted call and makes `isCapturing()` lie until then
+            // (#437 item 8).
+            this._isCapturing = false;
         });
-        this._isCapturing = false;
         if (!result.success) {
             throw new Error(result.error || 'Failed to stop capture');
         }
         this.logger.debug(`Audio capture stopped: ${result.duration}ms`);
+        const blob = result.audio
+            ? new Blob([Buffer.from(result.audio, 'base64')], { type: result.format })
+            : result.blob;
         return {
-            blob: result.blob,
+            blob,
             duration: result.duration,
             format: result.format,
-            timestamp: Date.now()
+            timestamp: Date.now(),
+            ...(result.warning ? { warning: result.warning } : {}),
         };
     }
     /**
@@ -232,16 +501,30 @@ export class AudioCaptureService {
         return this._isCapturing;
     }
     /**
-     * Returns the elapsed capture time in milliseconds.
-     * Returns 0 if not currently capturing.
+     * Whether the PAGE thinks a capture is running, whoever started it.
+     *
+     * `isCapturing()` reports this service's own mirror. `export_audio`
+     * drives the page-side recorder directly and never touches that
+     * mirror, so for the whole of a 30s export the mirror read false and
+     * `audio_capture({action:'stop'})` answered "No audio capture in
+     * progress" — which is not true, and told the caller the opposite of
+     * what was happening (#437 item 9).
      *
-     * @returns Elapsed time in milliseconds
+     * Reported rather than acted on: stopping the export's recorder from
+     * here would leave the export's own `stopCapture` with nothing to
+     * collect, which is a worse outcome than saying what is going on.
+     *
+     * @param page - Playwright page instance
+     * @returns true when the injected recorder is mid-capture
      */
-    getElapsedTime() {
-        if (!this._isCapturing) {
-            return 0;
+    async isPageCapturing(page) {
+        try {
+            return await page.evaluate(/* istanbul ignore next */ () => window.strudelAudioCapture?.isCapturing === true);
+        }
+        catch {
+            // An unreadable page is not a capturing one.
+            return false;
         }
-        return Date.now() - this._startTime;
     }
     /**
      * Checks if audio capture is connected to Strudel's audio output.
@@ -255,20 +538,6 @@ export class AudioCaptureService {
             return capture?.isConnected ?? false;
         });
     }
-    /**
-     * Clears any recorded chunks without stopping capture.
-     * Useful for discarding unwanted audio.
-     *
-     * @param page - Playwright page instance
-     */
-    async clearChunks(page) {
-        await page.evaluate(/* istanbul ignore next */ () => {
-            const capture = window.strudelAudioCapture;
-            if (capture) {
-                capture.chunks = [];
-            }
-        });
-    }
     /**
      * Gets the MIME type used for recording.
      *