ep_webrtc 2.5.37 → 2.5.39

package/.github/workflows/automerge.yml

@@ -2,6 +2,12 @@ name: Dependabot Automerge
 permissions:
   contents: write
   pull-requests: write
+  # `actions: write` lets the post-merge step kick off Node.js Package on
+  # the default branch via `gh workflow run`. Without this, automerge'd
+  # PRs land on main but the on-push release job never fires (GitHub
+  # Actions intentionally suppresses on:push triggers when the push is
+  # authenticated with GITHUB_TOKEN).
+  actions: write
 on:
   workflow_run:
     workflows:
@@ -21,6 +27,7 @@ jobs:
         uses: actions/checkout@v6
 
       - name: Automerge
+        id: automerge
         uses: "pascalgn/automerge-action@v0.16.4"
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -28,3 +35,11 @@ jobs:
           MERGE_LABELS: ""
           MERGE_RETRY_SLEEP: "100000"
 
+      - name: Trigger release on default branch
+        # `pascalgn/automerge-action` exits 0 whether or not it merged. Skip
+        # the dispatch when nothing was actually merged so we don't kick a
+        # phantom release run on every Dependabot Automerge invocation.
+        if: steps.automerge.outputs.mergeResult == 'merged'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh workflow run test-and-release.yml --ref ${{ github.event.repository.default_branch }}

package/.github/workflows/backend-tests.yml

@@ -26,7 +26,7 @@ jobs:
         with:
           repository: ether/etherpad-lite
           path: etherpad-lite
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v6
         name: Install Node.js
         with:
           node-version: 22

package/.github/workflows/frontend-tests.yml

@@ -16,7 +16,7 @@ jobs:
         with:
           repository: ether/etherpad-lite
           path: etherpad-lite
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v6
         name: Install Node.js
         with:
           node-version: 22

package/.github/workflows/test-and-release.yml

@@ -1,5 +1,11 @@
 name: Node.js Package
-on: [push]
+on:
+  push:
+  # Invoked by automerge.yml after a Dependabot PR is merged. GitHub
+  # Actions doesn't fire on:push when the push is authored by GITHUB_TOKEN
+  # (the automerge action's only available identity), so without this
+  # dispatch trigger the release job never runs after auto-merges.
+  workflow_dispatch:
 
 # id-token: write must be granted here so the reusable npmpublish workflow
 # can request an OIDC token for npm trusted publishing.

package/package.json

@@ -5,7 +5,7 @@
     "url": "git@github.com:ether/ep_webrtc.git",
     "type": "git"
   },
-  "version": "2.5.37",
+  "version": "2.5.39",
   "description": "WebRTC based audio/video chat to Etherpad",
   "author": "John McLear <john@mclear.co.uk>",
   "contributors": [],

package/static/js/index.js

@@ -1061,12 +1061,28 @@ exports.rtc = new class {
         click: async () => {
           const screenshareEnabled = !this._selfViewButtons.screenshare.enabled;
           _debug(`button clicked to ${screenshareEnabled ? 'en' : 'dis'}able screen sharing`);
+          // Capture the previous camera state so we can restore it if
+          // the screen-picker is canceled (getDisplayMedia rejects).
+          // Without this, clicking screenshare → cancel turns the
+          // camera off permanently from the user's perspective and
+          // leaves a stale disabled camera track in the local stream.
+          const wasCameraOn = this._selfViewButtons.video.enabled;
           // Unconditionally disable the camera. Either screen sharing was previously disabled in
           // which case the user now wants to share the screen, or screen sharing was previously
           // enabled in which case the user wants to shut off all video.
           this._selfViewButtons.video.enabled = false;
           this._selfViewButtons.screenshare.enabled = screenshareEnabled;
           await this.updateLocalTracks({updateVideo: true});
+          // If the user wanted to start screensharing but the picker
+          // was canceled or denied, updateLocalTracks has flipped
+          // screenshare.enabled back to false. Bring the camera back
+          // to the state it was in before the click so the user isn't
+          // left with no video at all.
+          if (screenshareEnabled && wasCameraOn &&
+              !this._selfViewButtons.screenshare.enabled) {
+            this._selfViewButtons.video.enabled = true;
+            await this.updateLocalTracks({updateVideo: true});
+          }
           // Don't use `await` here -- see the comment for the audio button click handler above.
           this.unmuteAndPlayAll();
         },

package/static/tests/frontend-new/specs/screenshare.spec.ts

@@ -0,0 +1,106 @@
+import {expect, test} from '@playwright/test';
+import {goToNewPadWithParams, installFakeGetUserMedia, setPadPrefsCookie} from '../helper/utils';
+
+test.describe('screen share button', () => {
+  test.beforeEach(async ({page, context}) => {
+    test.setTimeout(60_000);
+    await context.clearCookies();
+    await setPadPrefsCookie(page, {
+      rtcEnabled: false,
+      audioEnabledOnStart: false,
+      videoEnabledOnStart: true,
+    });
+    await goToNewPadWithParams(page, {});
+    await installFakeGetUserMedia(page);
+    // Stub getDisplayMedia onto navigator.mediaDevices so the
+    // screenshare-btn doesn't get hidden by addInterface (it checks
+    // typeof navigator.mediaDevices.getDisplayMedia === 'function').
+    // Tests below override this stub per-case to control behavior.
+    await page.evaluate(() => {
+      const w = window as any;
+      w.__getDisplayMediaCallCount = 0;
+      w.navigator.mediaDevices.getDisplayMedia = async () => {
+        w.__getDisplayMediaCallCount++;
+        const err: any = new Error('user cancelled the picker');
+        err.name = 'NotAllowedError';
+        throw err;
+      };
+    });
+    await page.evaluate(() => (window as any).ep_webrtc.activate());
+    await page.waitForFunction(
+        () => (window as any).$('#rtcbox').data('initialized'));
+    // Confirm the starting state: camera on, screenshare off.
+    await page.waitForFunction(() => {
+      const w = window as any;
+      const videoBtn = w.$('.video-btn');
+      const ssBtn = w.$('.screenshare-btn');
+      return videoBtn.length === 1 && !videoBtn.hasClass('off') &&
+             ssBtn.length === 1 && ssBtn.hasClass('off');
+    }, undefined, {timeout: 5000});
+  });
+
+  test('canceling the screen-picker restores the camera', async ({page}) => {
+    // Click the screenshare button. Our stubbed getDisplayMedia
+    // rejects with NotAllowedError (the same error Chrome dispatches
+    // when the user clicks Cancel in the picker).
+    await page.evaluate(() => (window as any).$('.screenshare-btn').click());
+    await page.evaluate(
+        () => (window as any).$('.screenshare-btn').data('idle')('click'));
+    // The picker really fired.
+    const callCount = await page.evaluate(
+        () => (window as any).__getDisplayMediaCallCount);
+    expect(callCount).toBeGreaterThanOrEqual(1);
+    // Final state: camera is back on, screenshare is off.
+    const finalState = await page.evaluate(() => {
+      const w = window as any;
+      const videoBtn = w.$('.video-btn');
+      const ssBtn = w.$('.screenshare-btn');
+      return {
+        videoOff: videoBtn.hasClass('off'),
+        screenshareOff: ssBtn.hasClass('off'),
+      };
+    });
+    expect(finalState).toEqual({videoOff: false, screenshareOff: true});
+    // And there's a live, enabled video track in the local stream so
+    // the user actually sees their camera again (not just a button
+    // toggled on with no underlying media).
+    const trackState = await page.evaluate(() => {
+      const w = window as any;
+      const v = document.querySelector('video') as HTMLVideoElement | null;
+      const stream = v && (v.srcObject as MediaStream | null);
+      const t = stream && stream.getVideoTracks()[0];
+      return t == null ? null : {enabled: t.enabled, readyState: t.readyState};
+    });
+    expect(trackState).toEqual({enabled: true, readyState: 'live'});
+  });
+
+  test('canceling screen-picker when camera was off leaves both off', async ({page}) => {
+    // Turn camera off first.
+    await page.evaluate(() => (window as any).$('.video-btn').click());
+    await page.evaluate(
+        () => (window as any).$('.video-btn').data('idle')('click'));
+    // Sanity-check both buttons off, no live enabled video track.
+    const before = await page.evaluate(() => {
+      const w = window as any;
+      return {
+        videoOff: w.$('.video-btn').hasClass('off'),
+        screenshareOff: w.$('.screenshare-btn').hasClass('off'),
+      };
+    });
+    expect(before).toEqual({videoOff: true, screenshareOff: true});
+    // Click screenshare → cancel.
+    await page.evaluate(() => (window as any).$('.screenshare-btn').click());
+    await page.evaluate(
+        () => (window as any).$('.screenshare-btn').data('idle')('click'));
+    // Both should remain off (don't auto-enable the camera the user
+    // had explicitly turned off).
+    const after = await page.evaluate(() => {
+      const w = window as any;
+      return {
+        videoOff: w.$('.video-btn').hasClass('off'),
+        screenshareOff: w.$('.screenshare-btn').hasClass('off'),
+      };
+    });
+    expect(after).toEqual({videoOff: true, screenshareOff: true});
+  });
+});