Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix: cancel extension startup when capture ends

Akshar Patelc6bd30fa0fe4
diff --git a/apps/chrome-extension/src/offscreen/recorder.test.ts b/apps/chrome-extension/src/offscreen/recorder.test.ts
index 3f50f3244..0f1991dbf 100644
--- a/apps/chrome-extension/src/offscreen/recorder.test.ts
+++ b/apps/chrome-extension/src/offscreen/recorder.test.ts
@@ -1,6 +1,10 @@
import type { RecordingSpool } from "@cap/recorder-core";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { OffscreenResponse, RecordingMode } from "../shared/types";
+import type {
+ ExtensionSettings,
+ OffscreenResponse,
+ RecordingMode,
+} from "../shared/types";
type MessageListener = Parameters<
typeof chrome.runtime.onMessage.addListener
@@ -18,6 +22,10 @@ class Track extends EventTarget {
getSettings() {
return { width: 320, height: 180, frameRate: 30 };
}
+
+ stop() {
+ this.readyState = "ended";
+ }
}
class Stream {
@@ -43,6 +51,7 @@ class Stream {
let onMessage: MessageListener;
let capturedStream: Stream;
let speakerStreams: Stream[];
+let spool: Pick<RecordingSpool, "sessionId" | "appendChunk" | "dispose">;
beforeEach(async () => {
vi.resetModules();
@@ -66,7 +75,9 @@ beforeEach(async () => {
onMessage = listener;
},
},
- sendMessage: (_message: unknown, callback: () => void) => callback(),
+ sendMessage: vi.fn((_message: unknown, callback: () => void) =>
+ callback(),
+ ),
},
});
vi.stubGlobal("MediaStream", Stream);
@@ -100,6 +111,10 @@ beforeEach(async () => {
},
};
}
+
+ close() {
+ return Promise.resolve();
+ }
},
);
vi.stubGlobal(
@@ -115,13 +130,19 @@ beforeEach(async () => {
if (url.endsWith("/initiate")) {
return Response.json({ uploadId: "upload-test", provider: "s3" });
}
+ if (url.endsWith("/instant-recordings/video-test")) {
+ return Response.json({ success: true });
+ }
throw new Error(`Unexpected request: ${url}`);
}),
);
const { RecordingSpool } = await import("@cap/recorder-core");
- vi.spyOn(RecordingSpool, "create").mockResolvedValue({
+ spool = {
sessionId: "spool-test",
- } as RecordingSpool);
+ appendChunk: vi.fn(async () => undefined),
+ dispose: vi.fn(async () => undefined),
+ };
+ vi.spyOn(RecordingSpool, "create").mockResolvedValue(spool as RecordingSpool);
});
afterEach(() => {
@@ -136,6 +157,31 @@ const send = (message: Record<string, unknown>) =>
onMessage({ target: "offscreen", ...message }, {}, resolve);
});
+const start = async (
+ settings: Partial<ExtensionSettings> = {},
+ mode: RecordingMode = "fullscreen",
+) => {
+ const { defaultSettings } = await import("../shared/storage");
+ await import("./recorder");
+ return send({
+ type: "start-recording",
+ mode,
+ tabStreamId: "tab-test",
+ settings: {
+ ...defaultSettings,
+ apiBaseUrl: "https://cap.test",
+ sounds: { enabled: false },
+ countdown: { enabled: false, seconds: 3 },
+ ...settings,
+ },
+ auth: { authApiKey: "test", userId: "user-test" },
+ bootstrap: {
+ organization: { id: "org-test" },
+ plan: { isPro: true, maxRecordingSeconds: null },
+ },
+ });
+};
+
describe("recording microphone mute", () => {
it.each([
{ mode: "tab", microphone: true, systemAudio: true },
@@ -163,27 +209,14 @@ describe("recording microphone mute", () => {
getDisplayMedia: async () => main,
},
});
- const { defaultSettings } = await import("../shared/storage");
- await import("./recorder");
expect(
- await send({
- type: "start-recording",
- mode,
- tabStreamId: "tab-test",
- settings: {
- ...defaultSettings,
- apiBaseUrl: "https://cap.test",
+ await start(
+ {
microphone: { enabled: microphone, deviceId: null },
systemAudio: { enabled: systemAudio },
- sounds: { enabled: false },
- countdown: { enabled: false, seconds: 3 },
- },
- auth: { authApiKey: "test", userId: "user-test" },
- bootstrap: {
- organization: { id: "org-test" },
- plan: { isPro: true, maxRecordingSeconds: null },
},
- }),
+ mode,
+ ),
).toMatchObject({ ok: true, status: { phase: "recording" } });
expect(speakerStreams).toEqual(
@@ -207,3 +240,107 @@ describe("recording microphone mute", () => {
},
);
});
+
+describe("recording source ending", () => {
+ let video: Track;
+ let microphone: Track;
+
+ beforeEach(() => {
+ video = new Track("video");
+ microphone = new Track("audio");
+ vi.stubGlobal("navigator", {
+ userAgent: "Chrome/152.0.0.0",
+ mediaDevices: {
+ getDisplayMedia: async () => new Stream([video]),
+ getUserMedia: async () => new Stream([microphone]),
+ },
+ });
+ });
+
+ it.each(["countdown", "recording creation", "manifest persistence"])(
+ "cancels when screen capture ends during %s",
+ async (stage) => {
+ const endSource = () => {
+ video.stop();
+ video.dispatchEvent(new Event("ended"));
+ };
+ const api = await import("../shared/api");
+ const storage = await import("../shared/storage");
+ if (stage === "recording creation") {
+ const create = api.createInstantRecording;
+ vi.spyOn(api, "createInstantRecording").mockImplementationOnce(
+ (input) => {
+ const pending = create(input);
+ endSource();
+ return pending;
+ },
+ );
+ }
+ if (stage === "manifest persistence") {
+ const save = storage.saveLiveRecordingManifest;
+ vi.spyOn(storage, "saveLiveRecordingManifest").mockImplementationOnce(
+ (manifest) => {
+ const pending = save(manifest);
+ endSource();
+ return pending;
+ },
+ );
+ }
+ const recorderStart = vi.spyOn(MediaRecorder.prototype, "start");
+ const closeAudio = vi.spyOn(AudioContext.prototype, "close");
+ await import("./recorder");
+ const pending = start({
+ countdown: { enabled: stage === "countdown", seconds: 3 },
+ });
+ if (stage === "countdown") {
+ await vi.advanceTimersByTimeAsync(1000);
+ expect(await send({ type: "get-recording-status" })).toMatchObject({
+ status: { phase: "creating" },
+ });
+ endSource();
+ await vi.advanceTimersByTimeAsync(2000);
+ }
+
+ expect(await pending).toMatchObject({ ok: false, canceled: true });
+ expect(await send({ type: "get-recording-status" })).toEqual({
+ ok: true,
+ status: { phase: "idle" },
+ });
+ expect(recorderStart).not.toHaveBeenCalled();
+ expect(microphone.readyState).toBe("ended");
+ expect(
+ capturedStream
+ .getTracks()
+ .every((track) => track.readyState === "ended"),
+ ).toBe(true);
+ expect(closeAudio).toHaveBeenCalledOnce();
+ expect(spool.appendChunk).not.toHaveBeenCalled();
+ expect(spool.dispose).toHaveBeenCalledOnce();
+ expect(await storage.loadLiveRecordingManifests()).toEqual([]);
+ expect(fetch).toHaveBeenCalledWith(
+ "https://cap.test/api/extension/instant-recordings/video-test",
+ expect.objectContaining({ method: "DELETE" }),
+ );
+ expect(
+ vi.mocked(fetch).mock.calls.some(([, init]) => init?.method === "PUT"),
+ ).toBe(false);
+ expect(chrome.runtime.sendMessage).not.toHaveBeenCalledWith(
+ { target: "service-worker", type: "stop-recording" },
+ expect.any(Function),
+ );
+ },
+ );
+
+ it("requests a normal stop when screen capture ends after startup", async () => {
+ expect(await start()).toMatchObject({
+ ok: true,
+ status: { phase: "recording" },
+ });
+ video.stop();
+ video.dispatchEvent(new Event("ended"));
+ expect(chrome.runtime.sendMessage).toHaveBeenCalledWith(
+ { target: "service-worker", type: "stop-recording" },
+ expect.any(Function),
+ );
+ });
+});
diff --git a/apps/chrome-extension/src/offscreen/recorder.ts b/apps/chrome-extension/src/offscreen/recorder.ts
index edeec2015..85b2beaf3 100644
--- a/apps/chrome-extension/src/offscreen/recorder.ts
+++ b/apps/chrome-extension/src/offscreen/recorder.ts
@@ -1034,11 +1034,6 @@ const startRecording = async (request: StartRecordingRequest) => {
ownedRecording = recording;
activeRecording = recording;
- for (const track of mainStream.getVideoTracks()) {
- track.addEventListener("ended", stopRecordingFromTrackEnd, {
- once: true,
- });
- }
// A crash from here on strands the spool; persisting the recording's
// identity alongside it lets the startup sweep surface a retryable
// failed-recording entry (videoId, subpath) instead of download-only.
@@ -1119,6 +1114,18 @@ const startRecording = async (request: StartRecordingRequest) => {
}
};
+ if (videoTracks.some((track) => track.readyState === "ended")) {
+ throw new DOMException(
+ "Recording source ended before recording started",
+ "AbortError",
+ );
+ }
+ for (const track of videoTracks) {
+ track.addEventListener("ended", stopRecordingFromTrackEnd, {
+ once: true,
+ });
+ }
+
status = {
phase: "recording",
videoId: creation.id,