Could
const C=window.Capacitor; if(!C||!C.Plugins||!C.Plugins.App) return;
const App=C.Plugins.App;
try{ App.addListener('appUrlOpen', (d)=>{ if(d&&/^bizconnect:\/\/share/i.test(d.url||'')) setTimeout(bzCheckSharedInbox, 150); }); }catch(_){}
- try{ App.addListener('appStateChange', (s)=>{ if(s&&s.isActive) setTimeout(bzCheckSharedInbox, 300); }); }catch(_){}
+ try{ App.addListener('appStateChange', (s)=>{ if(s&&s.isActive){ setTimeout(bzCheckSharedInbox, 300); try{ refreshPresenceOnResume(); }catch(_){} } }); }catch(_){} // #8: native resume β reconnect + refresh presence
})();
// Request permission from a user gesture (e.g. opening a chat) AND subscribe on grant β the
// subscribe-on-grant is essential on iOS, where permission is granted in-session and push
@@ -4163,8 +4244,8 @@ function markOpenChatRead(){
const body=JSON.stringify(selected.kind==='group'?{group:selected.id}:{with:selected.id});
try{ fetch('/api/messages/read',{method:'POST',headers:{'Content-Type':'application/json'},body}); }catch(_){}
}
-window.addEventListener('focus', ()=>{ checkWebBuild(); markOpenChatRead(); }); // coming back to the app (throttled)
-document.addEventListener('visibilitychange', ()=>{ if(!document.hidden){ checkWebBuild(); markOpenChatRead(); } });
+window.addEventListener('focus', ()=>{ checkWebBuild(); markOpenChatRead(); refreshPresenceOnResume(); }); // coming back to the app (throttled)
+document.addEventListener('visibilitychange', ()=>{ if(!document.hidden){ checkWebBuild(); markOpenChatRead(); refreshPresenceOnResume(); } }); // #8: refresh online/last-seen on resume
setTimeout(()=>checkWebBuild(true), 3000); // shortly after boot
// Deliberately NO banner and NO toast: a web build is an implementation detail. Surfacing it would make
// users think about "web build vs app version". It just updates.
@@ -4300,11 +4381,13 @@ function onChatMessage(m){
const isSys=!!m.system || m.from==='__system__'; // activity lines: show in chat, but no ping/notify/unread
if(m.from!==ME.id && !isSys){
if(!isGroupMsg && chatWs && chatWs.readyState===1){ try{ chatWs.send(JSON.stringify({type:'chat-delivered', id:m.id})); }catch(_){} } // ack DM delivery
- // Popup rule: ping always. In-page popup only when the tab is VISIBLE but you're on another
- // chat. When the tab is HIDDEN, let Web Push show it (the SW). If push isn't active, fall
- // back to an in-page popup so hidden-tab users still get alerted.
- if(notifOn(kind)){ playPing(); const wantPopup=!(isOpen && !document.hidden);
- if(wantPopup && !(document.hidden && pushActive)){
+ // #2: if you're ACTIVELY looking at this chat (app visible AND this chat open), the message lands
+ // right in front of you β no ping, no popup. Alert in every other case: a different chat, OR this
+ // same chat while the app is minimised (document.hidden) β that backgrounded case is exactly the one
+ // that used to stay silent. When hidden with push active, let the SW/native push show it instead.
+ const activelyViewing = isOpen && !document.hidden;
+ if(notifOn(kind) && !activelyViewing){ playPing();
+ if(!(document.hidden && pushActive)){
const prev=isGifUrl(m.body)?'ποΈ GIF':(m.body?(m.body.length>80?m.body.slice(0,80)+'β¦':m.body):'Sent an attachment');
// Group: title = GROUP name, body = "Sender: message" (so you know which group it's from).
if(kind==='group') notify((it&&it.name)||m.groupName||'Group', (m.fromName?m.fromName+': ':'')+prev, kind, rid);
@@ -4372,6 +4455,18 @@ async function refreshOpenThread(){
if(changed){ THREAD.sort((a,b)=>(a.created_at||0)-(b.created_at||0)); THREAD_CACHE.set(kind+':'+id, THREAD.slice()); renderThread(); }
}
let _chatReconnectT=null;
+// #8: after the app comes back from background, make sure presence is FRESH. iOS suspends the WebView and
+// freezes JS, so the chat socket can be dead while its onclose (and the 3s auto-reconnect) hasn't fired yet β
+// leaving contacts stuck on a stale "Offline"/last-seen. If the socket isn't OPEN, reconnect now (its onopen
+// re-runs resyncChatβloadSidebar); either way re-pull the sidebar so online/last-seen reflect reality. The
+// sidebar's live isOnline comes over HTTP, so it's correct even if the socket is momentarily down.
+let _lastPresenceRefresh=0;
+function refreshPresenceOnResume(){
+ try{
+ if(!chatWs || chatWs.readyState>1){ connectChatWs(); } // dead/closed β force reconnect (skip if OPEN/CONNECTING)
+ const t=Date.now(); if(t-_lastPresenceRefresh>4000){ _lastPresenceRefresh=t; try{ loadSidebar(); }catch(_){} } // throttle so rapid tab switches don't spam
+ }catch(_){}
+}
function connectChatWs(){
try{
// Defensive: drop any prior socket first so a flaky reconnect can't leave TWO live sockets β
diff --git a/server/public/icons.js b/server/public/icons.js
index ad05a80..16e6556 100644
--- a/server/public/icons.js
+++ b/server/public/icons.js
@@ -24,6 +24,7 @@
search: '
',
edit: '
',
trash: '
',
+ eyeOff: '
',
pin: '
',
pinOff: '
',
logOut: '
',
diff --git a/server/routes.js b/server/routes.js
index af08e25..b614fe8 100644
--- a/server/routes.js
+++ b/server/routes.js
@@ -11,7 +11,7 @@ const PUSH = require('./push');
const MSG_MAX = 4000;
const parseMentions = (s) => { if (!s) return []; try { const a = JSON.parse(s); return Array.isArray(a) ? a : []; } catch { return []; } };
const SYSTEM_SENDER = '__system__';
-const msgDTO = (m) => ({ id: m.id, from: m.sender_id, to: m.recipient_id, conversation_id: m.conversation_id || null, body: m.deleted ? '' : m.body, created_at: m.created_at, read_at: m.read_at, delivered_at: m.delivered_at || null, reply_to: m.deleted ? null : (m.reply_to || null), mentions: parseMentions(m.mentions), evt: m.msg_type || null, fwd_from: m.deleted ? null : (m.fwd_from || null), deleted: !!m.deleted, pinned: !!m.pinned_at, system: m.sender_id === SYSTEM_SENDER || !!m.msg_type });
+const msgDTO = (m) => ({ id: m.id, from: m.sender_id, to: m.recipient_id, conversation_id: m.conversation_id || null, body: m.deleted ? '' : m.body, created_at: m.created_at, read_at: m.read_at, delivered_at: m.delivered_at || null, reply_to: m.deleted ? null : (m.reply_to || null), mentions: parseMentions(m.mentions), evt: m.msg_type || null, fwd_from: m.deleted ? null : (m.fwd_from || null), deleted: !!m.deleted, pinned: !!m.pinned_at, edited_at: m.deleted ? null : (m.edited_at || null), system: m.sender_id === SYSTEM_SENDER || !!m.msg_type });
async function namesFor(teamId){ const o = {}; for (const x of await R.users.listByTenant(teamId)) o[x.id] = x.name || x.email; return o; }
// Await-aware filter: keep items whose async predicate resolves truthy (these predicates hit the DB, and a
// plain .filter() can't await). Sequential so per-item DB order is deterministic.
@@ -971,6 +971,7 @@ route('POST', '/api/calls/invite', async (req, res) => {
// #15: adding people to a 1:1 call promotes it to a persistent GROUP call (survives leaves + lets an added
// person rejoin after dropping). When that happens promoteDmToGroup's own group-call broadcast already rings
// the invitees in, so we only send the plain call-invite for a call that WASN'T promoted (group/ad-hoc).
+ try { CALLS.clearLeft(String(room), ids); } catch (_) {} // #New1: an explicit re-invite should ring again, even if they left earlier
let groupId = null;
try { groupId = await CALLS.promoteDmToGroup(String(room), u, ids); } catch (_) {}
if (!groupId) { for (const id of ids) { try { CHAT.pushToUser(id, { type: 'call-invite', room: String(room), byName: (u.name || u.email) }); } catch (_) {} } }
diff --git a/server/signaling.js b/server/signaling.js
index 40a5e59..37cedcc 100644
--- a/server/signaling.js
+++ b/server/signaling.js
@@ -406,6 +406,10 @@ async function leaveMeeting(ws) {
if (!peers) { if (leaverId) CHAT.broadcastPresence(leaverId); return; }
try { await require('./calls').finalizeTranscript(room, ws._meetingUserId); } catch (_) {} // save THIS user's transcript
peers.delete(pid);
+ // #New1: remember this user LEFT, so a later socket reconnect doesn't auto-ring them back into a call that's
+ // still running for the others (replayActiveCalls sends them noRing state instead). Harmless on a call that
+ // then ends. Only meaningful for a group/promoted call that survives one person leaving.
+ try { if (leaverId) require('./calls').markLeft(room, leaverId); } catch (_) {}
// 1:1 call: end it for everyone ONLY when fewer than two people would remain. A DM call that had
// extra people ADDED (via "Add people") is effectively a group now β one participant closing their
// app must NOT hang up the call for the rest (#11). We only tear the whole thing down when β€1 person