Fix screen-share reshare black-screen & invisible tile; add channel auto-clear messages timer mode (#5390)

Screen share: stopScreenShare now awaits per-peer renegotiation with Promise.allSettled (8s safety cap) instead of racing against a 3s timeout, dead-track detection in sameLiveTrack guard forces srcObject reassignment on reshare, and ontrack.onended skips tile teardown if a new screen-share is already registered. Auto-clear (#5390): new auto_delete_mode + auto_delete_interval_hours columns, set-channel-expiry accepts mode, cleanup interval branches between full delete and message wipe, badge shows hours+recur glyph, channel-messages-cleared event refreshes the viewer.

Author: ancsemi

public/js/modules/app-channels.js

@@ -500,7 +500,11 @@ _updateChannelFunctionsPanel(ch) {
   const hasExpiry = !!ch.expires_at;
   if (hasExpiry) {
     const hoursLeft = Math.max(1, Math.round((new Date(ch.expires_at) - Date.now()) / 3600000));
-    this._setCfnBadge('self-destruct', true, `${hoursLeft}h`);
+    // #5390 — distinguish 'clear messages' mode from full channel deletion
+    // so admins can tell at a glance what the timer will do. The ↻ glyph
+    // hints that the clear timer rearms itself.
+    const isClear = ch.auto_delete_mode === 'clear';
+    this._setCfnBadge('self-destruct', true, isClear ? `${hoursLeft}h ↻` : `${hoursLeft}h`);
   } else {
     this._setCfnBadge('self-destruct', false, 'OFF');
   }

public/js/modules/app-socket.js

@@ -1146,6 +1146,18 @@ _setupSocketListeners() {
     }
   });
 
+  // #5390 — sister event of channel-deleted: messages were wiped via the
+  // auto-clear self-destruct mode but the channel itself still exists.
+  // If the user is viewing the affected channel, refetch its messages by
+  // resetting the view. Otherwise nothing visual needs to change.
+  this.socket.on('channel-messages-cleared', (data) => {
+    if (!data || !data.code) return;
+    if (this.currentChannel === data.code) {
+      try { this.switchChannel(data.code); } catch (e) { console.warn('[auto-clear] re-switch failed:', e); }
+      this._showToast('🧹 Channel messages were auto-cleared', 'info');
+    }
+  });
+
   // ── Temporary voice channel events (#163) ──────────────
   this.socket.on('temp-channel-created', (channel) => {
     if (!this.channels.find(c => c.code === channel.code)) {

public/js/modules/app-ui.js

@@ -511,27 +511,59 @@ _setupUI() {
       if (row.querySelector('.cfn-input')) return;
       const badge = row.querySelector('.cfn-badge');
       if (!badge) return;
+      // #5390 — self-destruct now has two modes: 'delete' (legacy: remove
+      // the whole channel when the timer fires) and 'clear' (wipe messages
+      // only, then rearm the timer at the same interval). We render the
+      // hours input next to a mode select so admins can pick both at once.
+      const wrap = document.createElement('span');
+      wrap.className = 'cfn-input-wrap';
       const input = document.createElement('input');
       input.type = 'number'; input.min = '0'; input.max = '720';
-      input.value = ''; input.placeholder = t('channel_functions.self_destruct_placeholder'); input.className = 'cfn-input';
+      input.value = ''; input.placeholder = t('channel_functions.self_destruct_placeholder'); input.className = 'cfn-input cfn-input-hours';
       input.onclick = e2 => e2.stopPropagation();
-      badge.replaceWith(input);
+      const modeSelect = document.createElement('select');
+      modeSelect.className = 'cfn-input cfn-mode-select';
+      const optDelete = document.createElement('option');
+      optDelete.value = 'delete';
+      optDelete.textContent = t('channel_functions.self_destruct_mode_delete') || 'Delete channel';
+      const optClear = document.createElement('option');
+      optClear.value = 'clear';
+      optClear.textContent = t('channel_functions.self_destruct_mode_clear') || 'Clear messages';
+      modeSelect.appendChild(optDelete);
+      modeSelect.appendChild(optClear);
+      modeSelect.value = ch?.auto_delete_mode === 'clear' ? 'clear' : 'delete';
+      modeSelect.onclick = e2 => e2.stopPropagation();
+      wrap.appendChild(input);
+      wrap.appendChild(modeSelect);
+      badge.replaceWith(wrap);
       input.focus(); input.select();
+      let committed = false;
       const commitExpiry = () => {
+        if (committed) return;
         const hours = parseInt(input.value);
         if (isNaN(hours) || hours < 0) return;
+        committed = true;
+        const mode = modeSelect.value === 'clear' ? 'clear' : 'delete';
         if (hours === 0) {
-          optimistic({ expires_at: null });
-          this.socket.emit('set-channel-expiry', { code, hours: 0 });
+          optimistic({ expires_at: null, auto_delete_mode: 'delete', auto_delete_interval_hours: null });
+          this.socket.emit('set-channel-expiry', { code, hours: 0, mode });
         } else {
           const clamped = Math.max(1, Math.min(720, hours));
           const expiresAt = new Date(Date.now() + clamped * 3600000).toISOString();
-          optimistic({ expires_at: expiresAt });
-          this.socket.emit('set-channel-expiry', { code, hours: clamped });
+          optimistic({ expires_at: expiresAt, auto_delete_mode: mode, auto_delete_interval_hours: clamped });
+          this.socket.emit('set-channel-expiry', { code, hours: clamped, mode });
         }
       };
+      // Delay blur-commit briefly so focus moving between input and select
+      // inside the wrap doesn't fire a premature commit with stale values.
+      const onBlur = () => {
+        setTimeout(() => {
+          if (!wrap.contains(document.activeElement)) commitExpiry();
+        }, 50);
+      };
       input.addEventListener('keydown', e2 => { if (e2.key === 'Enter') { commitExpiry(); input.blur(); } });
-      input.addEventListener('blur', commitExpiry);
+      input.addEventListener('blur', onBlur);
+      modeSelect.addEventListener('blur', onBlur);
     } else if (fn === 'afk-sub') {
       // Show a select dropdown of sub-channels for this parent
       if (row.querySelector('.cfn-select')) return;

public/js/modules/app-voice.js

@@ -999,7 +999,14 @@ _handleScreenStream(userId, stream, { force = false } = {}) {
     const newVideoTrack = stream.getVideoTracks()[0] || null;
     const curStream = videoEl.srcObject;
     const curVideoTrack = curStream ? (curStream.getVideoTracks?.()[0] || null) : null;
-    const sameLiveTrack = newVideoTrack && curVideoTrack &&
+    // If the currently attached track is dead (readyState !== 'live'), we MUST
+    // reassign — even if the new track has the same id, the browser will keep
+    // rendering a black frame from the dead source. This happens on reshare
+    // when the sharer's stopScreenShare ends the track but the viewer's
+    // element still holds a reference to that dead MediaStreamTrack.
+    const curTrackIsDead = !!curVideoTrack && curVideoTrack.readyState !== 'live';
+    const sameLiveTrack = !curTrackIsDead &&
+      newVideoTrack && curVideoTrack &&
       newVideoTrack.id === curVideoTrack.id &&
       newVideoTrack.readyState === 'live' &&
       videoEl.videoWidth > 0;

public/js/voice.js

@@ -986,11 +986,20 @@ class VoiceManager {
       renegotiations.push(this._renegotiate(userId, peer.connection).catch(() => {}));
     }
 
-    // Wait for all renegotiations to complete (with a timeout so we don't hang forever)
+    // Wait for ALL renegotiations to actually finish before tearing the
+    // tracks down. The previous Promise.race(..., 3s) here was the cause of
+    // the months-long "black screen on reshare" / "streaming but no tile"
+    // bugs: if any peer's _renegotiate was still in flight when the 3s
+    // expired (perfectly possible since _renegotiate itself can wait up to
+    // 5s for signaling state to settle), this function would return, kill
+    // the tracks, and leave that peer's transceiver mid-direction-change.
+    // On the next startScreenShare the new addTrack would reuse that broken
+    // transceiver and ontrack would never fire on the viewer side — exactly
+    // the symptom users reported. Use allSettled with a generous safety cap.
     try {
       await Promise.race([
-        Promise.all(renegotiations),
-        new Promise(resolve => setTimeout(resolve, 3000))
+        Promise.allSettled(renegotiations),
+        new Promise(resolve => setTimeout(resolve, 8000))
       ]);
     } catch { /* proceed anyway */ }
 
@@ -1348,7 +1357,19 @@ class VoiceManager {
           };
           track.onmute = () => {};
           track.onended = () => {
-            if (this.onScreenStream) this.onScreenStream(userId, null);
+            // Don't tear down the tile if the sharer is in the middle of a
+            // stop+restart cycle. Their old track ends naturally as part of
+            // stopScreenShare, but the screenSharers set (driven by the
+            // server's screen-share-started/stopped events) is still true
+            // until we get screen-share-stopped. If we cleared the tile
+            // here on every onended, the viewer would see the tile vanish
+            // and the next track would have to recreate everything — which
+            // is fine in theory but masked the stuck-transceiver bug for
+            // months by making it look like "the new share never arrived".
+            // Only clear when the server has actually told us they stopped.
+            if (!this.screenSharers.has(userId)) {
+              if (this.onScreenStream) this.onScreenStream(userId, null);
+            }
           };
           // Check if any deferred audio belongs to this screen stream
           for (let i = deferredAudio.length - 1; i >= 0; i--) {

src/database.js

@@ -665,6 +665,14 @@ function initDatabase() {
     { name: 'notification_type',  sql: "ALTER TABLE channels ADD COLUMN notification_type TEXT DEFAULT 'default'" },
     { name: 'voice_enabled',     sql: "ALTER TABLE channels ADD COLUMN voice_enabled INTEGER DEFAULT 1" },
     { name: 'text_enabled',      sql: "ALTER TABLE channels ADD COLUMN text_enabled INTEGER DEFAULT 1" },
+    // #5390 — extend the self-destruct timer with a "clear messages only"
+    // mode. `auto_delete_mode` is 'delete' (existing behaviour: drop the
+    // whole channel) or 'clear' (wipe messages but keep channel, perms,
+    // roles, integrations). `auto_delete_interval_hours` stores the
+    // original interval so a 'clear' timer can rearm itself after firing
+    // (recurring sweep) instead of being a one-shot.
+    { name: 'auto_delete_mode',           sql: "ALTER TABLE channels ADD COLUMN auto_delete_mode TEXT DEFAULT 'delete'" },
+    { name: 'auto_delete_interval_hours', sql: "ALTER TABLE channels ADD COLUMN auto_delete_interval_hours INTEGER DEFAULT NULL" },
   ];
   for (const col of channelQolCols) {
     try { db.prepare(`SELECT ${col.name} FROM channels LIMIT 0`).get(); } catch { db.exec(col.sql); }

src/socketHandlers/channels.js

@@ -784,18 +784,28 @@ module.exports = function register(socket, ctx) {
     if (!code || !/^[a-f0-9]{8}$/i.test(code)) return;
     const channel = db.prepare('SELECT id FROM channels WHERE code = ? AND is_dm = 0').get(code);
     if (!channel) return socket.emit('error-msg', 'Channel not found');
+    // #5390 — second mode: 'clear' wipes messages periodically instead of
+    // deleting the whole channel. Anything other than 'clear' is treated
+    // as the legacy 'delete' behaviour so unknown values fail closed
+    // toward the original semantics.
+    const mode = data.mode === 'clear' ? 'clear' : 'delete';
     let expiresAt = null;
+    let intervalHours = null;
     if (data.hours && data.hours > 0) {
       const hours = Math.max(1, Math.min(720, parseInt(data.hours, 10)));
       if (isNaN(hours)) return socket.emit('error-msg', 'Invalid duration');
       expiresAt = new Date(Date.now() + hours * 3600000).toISOString();
+      intervalHours = hours;
     }
     try {
-      db.prepare('UPDATE channels SET expires_at = ? WHERE id = ?').run(expiresAt, channel.id);
+      db.prepare(
+        'UPDATE channels SET expires_at = ?, auto_delete_mode = ?, auto_delete_interval_hours = ? WHERE id = ?'
+      ).run(expiresAt, mode, intervalHours, channel.id);
       broadcastChannelLists();
       if (expiresAt) {
         const hours = Math.round((new Date(expiresAt) - Date.now()) / 3600000);
-        socket.emit('toast', { message: `⏱️ Channel will self-destruct in ${hours}h`, type: 'success' });
+        const verb = mode === 'clear' ? `clear messages every ${hours}h` : `self-destruct in ${hours}h`;
+        socket.emit('toast', { message: `⏱️ Channel will ${verb}`, type: 'success' });
       } else {
         socket.emit('toast', { message: '⏱️ Self-destruct timer removed', type: 'success' });
       }

src/socketHandlers/index.js

@@ -214,15 +214,15 @@ function setupSocketHandlers(io, db) {
                c.parent_channel_id, c.position, c.is_private, c.expires_at, c.is_temp_voice,
                c.streams_enabled, c.music_enabled, c.media_enabled, c.slow_mode_interval, c.category, c.sort_alphabetical,
                c.cleanup_exempt, c.channel_type, c.voice_user_limit, c.notification_type, c.voice_enabled, c.text_enabled, c.voice_bitrate,
-               c.afk_sub_code, c.afk_timeout_minutes, c.read_only
+               c.afk_sub_code, c.afk_timeout_minutes, c.read_only, c.auto_delete_mode, c.auto_delete_interval_hours
         FROM channels c WHERE c.is_dm = 0
         UNION
         SELECT c.id, c.name, c.code, c.created_by, c.topic, c.is_dm,
                c.code_visibility, c.code_mode, c.code_rotation_type, c.code_rotation_interval,
                c.parent_channel_id, c.position, c.is_private, c.expires_at, c.is_temp_voice,
                c.streams_enabled, c.music_enabled, c.media_enabled, c.slow_mode_interval, c.category, c.sort_alphabetical,
                c.cleanup_exempt, c.channel_type, c.voice_user_limit, c.notification_type, c.voice_enabled, c.text_enabled, c.voice_bitrate,
-               c.afk_sub_code, c.afk_timeout_minutes, c.read_only
+               c.afk_sub_code, c.afk_timeout_minutes, c.read_only, c.auto_delete_mode, c.auto_delete_interval_hours
         FROM channels c
         JOIN channel_members cm ON c.id = cm.channel_id
         WHERE cm.user_id = ? AND c.is_dm = 1
@@ -237,7 +237,7 @@ function setupSocketHandlers(io, db) {
                c.parent_channel_id, c.position, c.is_private, c.expires_at, c.is_temp_voice,
                c.streams_enabled, c.music_enabled, c.media_enabled, c.slow_mode_interval, c.category, c.sort_alphabetical,
                c.cleanup_exempt, c.channel_type, c.voice_user_limit, c.notification_type, c.voice_enabled, c.text_enabled, c.voice_bitrate,
-               c.afk_sub_code, c.afk_timeout_minutes, c.read_only
+               c.afk_sub_code, c.afk_timeout_minutes, c.read_only, c.auto_delete_mode, c.auto_delete_interval_hours
         FROM channels c
         JOIN channel_members cm ON c.id = cm.channel_id
         WHERE cm.user_id = ?
@@ -908,20 +908,44 @@ function setupSocketHandlers(io, db) {
   setInterval(() => {
     try {
       const expired = db.prepare(
-        "SELECT id, code FROM channels WHERE expires_at IS NOT NULL AND expires_at <= datetime('now')"
+        "SELECT id, code, auto_delete_mode, auto_delete_interval_hours FROM channels WHERE expires_at IS NOT NULL AND expires_at <= datetime('now')"
       ).all();
       for (const ch of expired) {
-        db.prepare('DELETE FROM reactions WHERE message_id IN (SELECT id FROM messages WHERE channel_id = ?)').run(ch.id);
-        db.prepare('DELETE FROM pinned_messages WHERE channel_id = ?').run(ch.id);
-        db.prepare('DELETE FROM messages WHERE channel_id = ?').run(ch.id);
-        db.prepare('DELETE FROM channel_members WHERE channel_id = ?').run(ch.id);
-        db.prepare('DELETE FROM channels WHERE id = ?').run(ch.id);
-        io.to(`channel:${ch.code}`).to(`voice:${ch.code}`).emit('channel-deleted', { code: ch.code, reason: 'expired' });
-        channelUsers.delete(ch.code);
-        voiceUsers.delete(ch.code);
-        activeMusic.delete(ch.code);
-        musicQueues.delete(ch.code);
-        console.log(`[Temporary] Channel "${ch.code}" expired and was deleted`);
+        if (ch.auto_delete_mode === 'clear') {
+          // #5390 — clear-messages mode: wipe message-related rows but keep
+          // the channel, its members, permissions, roles, and integrations
+          // intact. Then rearm the timer using the original interval so the
+          // sweep repeats (e.g. daily flood-channel reset) until an admin
+          // disables it. If for some reason the interval wasn't stored,
+          // fall back to disabling the timer to avoid getting stuck firing
+          // a zero-second loop.
+          db.prepare('DELETE FROM reactions WHERE message_id IN (SELECT id FROM messages WHERE channel_id = ?)').run(ch.id);
+          db.prepare('DELETE FROM pinned_messages WHERE channel_id = ?').run(ch.id);
+          db.prepare('DELETE FROM messages WHERE channel_id = ?').run(ch.id);
+          const interval = ch.auto_delete_interval_hours;
+          if (interval && interval > 0) {
+            const nextExpiry = new Date(Date.now() + interval * 3600000).toISOString();
+            db.prepare('UPDATE channels SET expires_at = ? WHERE id = ?').run(nextExpiry, ch.id);
+          } else {
+            db.prepare('UPDATE channels SET expires_at = NULL WHERE id = ?').run(ch.id);
+          }
+          io.to(`channel:${ch.code}`).emit('channel-messages-cleared', { code: ch.code, reason: 'auto-clear' });
+          // Refresh channel lists so the new expires_at propagates to clients.
+          try { broadcastChannelLists(); } catch {}
+          console.log(`[Temporary] Channel "${ch.code}" messages cleared (auto-clear mode)`);
+        } else {
+          db.prepare('DELETE FROM reactions WHERE message_id IN (SELECT id FROM messages WHERE channel_id = ?)').run(ch.id);
+          db.prepare('DELETE FROM pinned_messages WHERE channel_id = ?').run(ch.id);
+          db.prepare('DELETE FROM messages WHERE channel_id = ?').run(ch.id);
+          db.prepare('DELETE FROM channel_members WHERE channel_id = ?').run(ch.id);
+          db.prepare('DELETE FROM channels WHERE id = ?').run(ch.id);
+          io.to(`channel:${ch.code}`).to(`voice:${ch.code}`).emit('channel-deleted', { code: ch.code, reason: 'expired' });
+          channelUsers.delete(ch.code);
+          voiceUsers.delete(ch.code);
+          activeMusic.delete(ch.code);
+          musicQueues.delete(ch.code);
+          console.log(`[Temporary] Channel "${ch.code}" expired and was deleted`);
+        }
       }
     } catch (err) {
       console.error('Temporary channel cleanup error:', err);