Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(sdk-recorder): cancel capture startup when destroyed

Akshar Patel2ae8d7ebdaf5
diff --git a/packages/sdk-recorder/__tests__/startup-cancellation.test.ts b/packages/sdk-recorder/__tests__/startup-cancellation.test.ts
new file mode 100644
index 000000000..b773acb05
--- /dev/null
+++ b/packages/sdk-recorder/__tests__/startup-cancellation.test.ts
@@ -0,0 +1,295 @@
+import { afterEach, beforeEach, expect, mock, test } from "bun:test";
+import { CapRecorder } from "../src/index";
+
+class Track {
+ readyState = "live";
+ onended: (() => void) | null = null;
+
+ constructor(readonly kind: "video" | "audio") {}
+
+ stop() {
+ this.readyState = "ended";
+ }
+}
+
+class Stream {
+ constructor(private readonly tracks: Track[]) {}
+
+ getTracks() {
+ return this.tracks;
+ }
+
+ getVideoTracks() {
+ return this.tracks.filter((track) => track.kind === "video");
+ }
+
+ getAudioTracks() {
+ return this.tracks.filter((track) => track.kind === "audio");
+ }
+}
+
+class Encoder {
+ static starts = 0;
+ state = "inactive";
+
+ static isTypeSupported() {
+ return true;
+ }
+
+ start() {
+ Encoder.starts++;
+ this.state = "recording";
+ }
+
+ stop() {
+ this.state = "inactive";
+ }
+}
+
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ let reject!: (error: Error) => void;
+ const promise = new Promise<T>((res, rej) => {
+ resolve = res;
+ reject = rej;
+ });
+ return { promise, resolve, reject };
+}
+
+const descriptors = [
+ "navigator",
+ "MediaStream",
+ "MediaRecorder",
+ "AudioContext",
+].map(
+ (name) => [name, Object.getOwnPropertyDescriptor(globalThis, name)] as const,
+);
+
+function setGlobal(name: string, value: unknown) {
+ Object.defineProperty(globalThis, name, { configurable: true, value });
+}
+
+beforeEach(() => {
+ Encoder.starts = 0;
+ setGlobal("MediaStream", Stream);
+ setGlobal("MediaRecorder", Encoder);
+});
+
+afterEach(() => {
+ for (const [name, descriptor] of descriptors) {
+ if (descriptor) Object.defineProperty(globalThis, name, descriptor);
+ else Reflect.deleteProperty(globalThis, name);
+ }
+});
+
+test("destroy cancels pending camera startup without requesting the microphone", async () => {
+ const permission = deferred<Stream>();
+ const camera = new Track("video");
+ const microphone = new Track("audio");
+ const getUserMedia = mock((constraints: MediaStreamConstraints) =>
+ constraints.video
+ ? permission.promise
+ : Promise.resolve(new Stream([microphone])),
+ );
+ setGlobal("navigator", { mediaDevices: { getUserMedia } });
+ const recorder = new CapRecorder({ publicKey: "fixture", mode: "camera" });
+
+ try {
+ const starting = recorder.start();
+ expect(recorder.phase).toBe("requesting-permission");
+ recorder.destroy();
+ permission.resolve(new Stream([camera]));
+ await starting;
+
+ expect(recorder.phase).toBe("idle");
+ expect(camera.readyState).toBe("ended");
+ expect(getUserMedia).toHaveBeenCalledTimes(1);
+ expect(Encoder.starts).toBe(0);
+ } finally {
+ recorder.destroy();
+ }
+});
+
+test("destroy releases the screen while microphone permission is pending", async () => {
+ const permission = deferred<Stream>();
+ const screen = new Track("video");
+ const microphone = new Track("audio");
+ const getUserMedia = mock(() => permission.promise);
+ setGlobal("navigator", {
+ mediaDevices: {
+ getDisplayMedia: async () => new Stream([screen]),
+ getUserMedia,
+ },
+ });
+ const recorder = new CapRecorder({
+ publicKey: "fixture",
+ camera: { enabled: false },
+ });
+
+ try {
+ const starting = recorder.start();
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ expect(getUserMedia).toHaveBeenCalledTimes(1);
+ recorder.destroy();
+ const screenAfterDestroy = screen.readyState;
+ permission.resolve(new Stream([microphone]));
+ await starting;
+
+ expect(screenAfterDestroy).toBe("ended");
+ expect(microphone.readyState).toBe("ended");
+ expect(recorder.phase).toBe("idle");
+ expect(Encoder.starts).toBe(0);
+ } finally {
+ recorder.destroy();
+ }
+});
+
+test("destroy releases streams returned before start resumes", async () => {
+ const permission = deferred<Stream>();
+ const camera = new Track("video");
+ setGlobal("navigator", {
+ mediaDevices: { getUserMedia: () => permission.promise },
+ });
+ const recorder = new CapRecorder({
+ publicKey: "fixture",
+ mode: "camera",
+ microphone: { enabled: false },
+ });
+
+ try {
+ const starting = recorder.start();
+ permission.resolve(new Stream([camera]));
+ queueMicrotask(() => recorder.destroy());
+ await starting;
+
+ expect(recorder.phase).toBe("idle");
+ expect(camera.readyState).toBe("ended");
+ expect(Encoder.starts).toBe(0);
+ } finally {
+ recorder.destroy();
+ }
+});
+
+test.each(["grant", "deny"] as const)(
+ "a late screen permission %s cannot change a replacement recording",
+ async (outcome) => {
+ const permission = deferred<Stream>();
+ const oldScreen = new Track("video");
+ const newScreen = new Track("video");
+ const getDisplayMedia = mock()
+ .mockImplementationOnce(() => permission.promise)
+ .mockImplementationOnce(async () => new Stream([newScreen]));
+ setGlobal("navigator", { mediaDevices: { getDisplayMedia } });
+ const recorder = new CapRecorder({
+ publicKey: "fixture",
+ camera: { enabled: false },
+ microphone: { enabled: false },
+ });
+ const errors = mock(() => {});
+ recorder.on("error", errors);
+
+ try {
+ const starting = recorder.start().catch((error: unknown) => error);
+ recorder.destroy();
+ await recorder.start();
+ if (outcome === "grant") permission.resolve(new Stream([oldScreen]));
+ else permission.reject(new Error("Permission denied"));
+ expect(await starting).toBeUndefined();
+
+ expect(recorder.phase).toBe("recording");
+ expect(newScreen.readyState).toBe("live");
+ if (outcome === "grant") expect(oldScreen.readyState).toBe("ended");
+ expect(errors).not.toHaveBeenCalled();
+ expect(Encoder.starts).toBe(1);
+ } finally {
+ recorder.destroy();
+ }
+ },
+);
+
+test.each(["resolve", "reject"] as const)(
+ "destroy cancels audio startup when resume later %ss",
+ async (outcome) => {
+ const startup = deferred<void>();
+ const screen = new Track("video");
+ const system = new Track("audio");
+ const microphone = new Track("audio");
+ const mixed = new Track("audio");
+ const close = mock(async () => {});
+ const resume = mock(() => startup.promise);
+ setGlobal("navigator", {
+ mediaDevices: {
+ getDisplayMedia: async () => new Stream([screen, system]),
+ getUserMedia: async () => new Stream([microphone]),
+ },
+ });
+ setGlobal(
+ "AudioContext",
+ class {
+ close = close;
+ resume = resume;
+ createMediaStreamDestination() {
+ return { stream: new Stream([mixed]) };
+ }
+ createGain() {
+ return { gain: { value: 1 }, connect() {} };
+ }
+ createMediaStreamSource() {
+ return { connect() {} };
+ }
+ },
+ );
+ const recorder = new CapRecorder({
+ publicKey: "fixture",
+ camera: { enabled: false },
+ systemAudio: true,
+ });
+
+ try {
+ const starting = recorder.start().catch((error: unknown) => error);
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ expect(resume).toHaveBeenCalledTimes(1);
+ recorder.destroy();
+ for (const track of [screen, system, microphone, mixed]) {
+ expect(track.readyState).toBe("ended");
+ }
+ if (outcome === "resolve") startup.resolve();
+ else startup.reject(new Error("Audio context closed"));
+ expect(await starting).toBeUndefined();
+ expect(recorder.phase).toBe("idle");
+ expect(close).toHaveBeenCalledTimes(1);
+ expect(Encoder.starts).toBe(0);
+ } finally {
+ recorder.destroy();
+ }
+ },
+);
+
+test("an error handler can destroy and start a replacement recording", async () => {
+ const camera = new Track("video");
+ const getDisplayMedia = mock()
+ .mockRejectedValueOnce(new Error("Permission failed"))
+ .mockResolvedValueOnce(new Stream([camera]));
+ setGlobal("navigator", { mediaDevices: { getDisplayMedia } });
+ const recorder = new CapRecorder({
+ publicKey: "fixture",
+ camera: { enabled: false },
+ microphone: { enabled: false },
+ });
+ let replacement: Promise<void> | undefined;
+ recorder.on("error", () => {
+ recorder.destroy();
+ replacement = recorder.start();
+ });
+
+ try {
+ await expect(recorder.start()).rejects.toThrow("Permission failed");
+ await replacement;
+
+ expect(recorder.phase).toBe("recording");
+ expect(camera.readyState).toBe("live");
+ expect(Encoder.starts).toBe(1);
+ } finally {
+ recorder.destroy();
+ }
+});
diff --git a/packages/sdk-recorder/src/core/stream-manager.ts b/packages/sdk-recorder/src/core/stream-manager.ts
index f93156d09..1f6c99d25 100644
--- a/packages/sdk-recorder/src/core/stream-manager.ts
+++ b/packages/sdk-recorder/src/core/stream-manager.ts
@@ -16,6 +16,7 @@ export interface ManagedStreams {
export async function acquireStreams(
config: StreamConfig,
+ signal: AbortSignal,
): Promise<ManagedStreams> {
const result: ManagedStreams = {
display: null,
@@ -23,50 +24,65 @@ export async function acquireStreams(
microphone: null,
};
- if (config.mode !== "camera") {
- const displayMediaOptions: DisplayMediaStreamOptions = {
- video: true,
- audio: config.systemAudio ?? false,
- };
+ signal.throwIfAborted();
+ const onAbort = () => releaseStreams(result);
+ signal.addEventListener("abort", onAbort, { once: true });
- if (config.mode === "window") {
- (displayMediaOptions as Record<string, unknown>).preferCurrentTab = false;
- }
+ try {
+ if (config.mode !== "camera") {
+ const displayMediaOptions: DisplayMediaStreamOptions = {
+ video: true,
+ audio: config.systemAudio ?? false,
+ };
+
+ if (config.mode === "window") {
+ (displayMediaOptions as Record<string, unknown>).preferCurrentTab =
+ false;
+ }
- result.display =
- await navigator.mediaDevices.getDisplayMedia(displayMediaOptions);
- }
+ result.display =
+ await navigator.mediaDevices.getDisplayMedia(displayMediaOptions);
+ signal.throwIfAborted();
+ }
- if (config.camera?.enabled !== false) {
- const constraints: MediaStreamConstraints = {
- video: config.camera?.deviceId
- ? { deviceId: { exact: config.camera.deviceId } }
- : true,
- audio: false,
- };
- try {
- result.camera = await navigator.mediaDevices.getUserMedia(constraints);
- } catch {
- result.camera = null;
+ if (config.camera?.enabled !== false) {
+ const constraints: MediaStreamConstraints = {
+ video: config.camera?.deviceId
+ ? { deviceId: { exact: config.camera.deviceId } }
+ : true,
+ audio: false,
+ };
+ try {
+ result.camera = await navigator.mediaDevices.getUserMedia(constraints);
+ } catch {
+ result.camera = null;
+ }
+ signal.throwIfAborted();
}
- }
- if (config.microphone?.enabled !== false) {
- const constraints: MediaStreamConstraints = {
- video: false,
- audio: config.microphone?.deviceId
- ? { deviceId: { exact: config.microphone.deviceId } }
- : true,
- };
- try {
- result.microphone =
- await navigator.mediaDevices.getUserMedia(constraints);
- } catch {
- result.microphone = null;
+ if (config.microphone?.enabled !== false) {
+ const constraints: MediaStreamConstraints = {
+ video: false,
+ audio: config.microphone?.deviceId
+ ? { deviceId: { exact: config.microphone.deviceId } }
+ : true,
+ };
+ try {
+ result.microphone =
+ await navigator.mediaDevices.getUserMedia(constraints);
+ } catch {
+ result.microphone = null;
+ }
+ signal.throwIfAborted();
}
- }
- return result;
+ return result;
+ } catch (error) {
+ releaseStreams(result);
+ throw error;
+ } finally {
+ signal.removeEventListener("abort", onAbort);
+ }
}
export function releaseStreams(streams: ManagedStreams) {
diff --git a/packages/sdk-recorder/src/index.ts b/packages/sdk-recorder/src/index.ts
index 2da81477c..51c58072d 100644
--- a/packages/sdk-recorder/src/index.ts
+++ b/packages/sdk-recorder/src/index.ts
@@ -36,6 +36,7 @@ export class CapRecorder {
private _durationMs = 0;
private recorder: MediaRecorder | null = null;
private streams: ManagedStreams | null = null;
+ private startup: AbortController | null = null;
private chunks: Blob[] = [];
private durationInterval: ReturnType<typeof setInterval> | null = null;
private accumulatedMs = 0;
@@ -114,18 +115,29 @@ export class CapRecorder {
throw new Error(`Cannot start from phase "${this._phase}"`);
}
const maxDurationMs = options?.maxDurationMs ?? this.maxDurationMs;
+ const startup = new AbortController();
+ this.startup = startup;
try {
this.setPhase("requesting-permission");
- this.streams = await acquireStreams({
- mode: this.options.mode,
- camera: this.options.camera,
- microphone: this.options.microphone,
- systemAudio: this.options.systemAudio,
- });
+ const streams = await acquireStreams(
+ {
+ mode: this.options.mode,
+ camera: this.options.camera,
+ microphone: this.options.microphone,
+ systemAudio: this.options.systemAudio,
+ },
+ startup.signal,
+ );
+ if (startup.signal.aborted) {
+ releaseStreams(streams);
+ return;
+ }
+ this.streams = streams;
- const composite = await buildCompositeStream(this.streams);
+ const composite = await buildCompositeStream(streams);
+ if (startup.signal.aborted) return;
if (composite.getTracks().length === 0) {
throw new Error("No media tracks available");
}
@@ -161,11 +173,12 @@ export class CapRecorder {
}, maxDurationMs);
this.setPhase("recording");
} catch (error) {
+ if (startup.signal.aborted) return;
+ this.cleanup();
this.setPhase("error");
this.emit("error", {
error: error instanceof Error ? error : new Error(String(error)),
});
- this.cleanup();
throw error;
}
}
@@ -275,6 +288,8 @@ export class CapRecorder {
}
private cleanup() {
+ this.startup?.abort();
+ this.startup = null;
this.stopDurationTimer();
if (this.maxDurationTimeout) {
clearTimeout(this.maxDurationTimeout);