@mostrom/meeting-detector 1.0.3 → 1.0.5

package/dist/detector.js

@@ -6,12 +6,20 @@ export class MeetingDetector extends EventEmitter {
     constructor(options = {}) {
         super();
         this.activeSessions = new Map();
+        this.pendingConfidence = new Map();
+        this.serviceContext = new Map();
+        this.activeMeeting = null;
         // Get the absolute path to the script relative to this package
         const defaultScriptPath = options.scriptPath || join(dirname(fileURLToPath(import.meta.url)), '../meeting-detect.sh');
         this.options = {
             scriptPath: defaultScriptPath,
             debug: options.debug || false,
-            sessionDeduplicationMs: options.sessionDeduplicationMs || 60000
+            sessionDeduplicationMs: options.sessionDeduplicationMs || 60000,
+            meetingEndTimeoutMs: options.meetingEndTimeoutMs || 30000,
+            emitUnknown: options.emitUnknown || false,
+            includeSensitiveMetadata: options.includeSensitiveMetadata || false,
+            includeRawSignalInLifecycle: options.includeRawSignalInLifecycle || false,
+            startupProbe: options.startupProbe !== false
         };
     }
     /**
@@ -28,28 +36,43 @@ export class MeetingDetector extends EventEmitter {
         this.process = spawn('sh', [this.options.scriptPath], {
             stdio: ['pipe', 'pipe', 'pipe']
         });
+        // Probe for an already-active meeting so detectors that start mid-call emit immediately.
+        if (this.options.startupProbe) {
+            this.probeActiveMeetingAtStartup();
+        }
+        let stderrBuffer = '';
         this.process.stdout?.on('data', (data) => {
             const lines = data.toString().trim().split('\n');
             for (const line of lines) {
                 if (line.trim()) {
                     try {
-                        const signal = this.parseSignal(line);
+                        const parsedSignal = this.parseSignal(line);
+                        const signal = this.stabilizeSignalContext(parsedSignal);
                         if (this.shouldIgnoreSignal(signal)) {
                             if (this.options.debug) {
                                 console.log('[MeetingDetector] Ignoring signal:', signal);
                             }
                             continue;
                         }
-                        if (this.isDuplicateSession(signal)) {
+                        const confidentSignal = this.resolveConfidence(signal);
+                        if (!confidentSignal) {
+                            if (this.options.debug) {
+                                console.log('[MeetingDetector] Holding low-confidence signal:', signal);
+                            }
+                            continue;
+                        }
+                        this.updateMeetingLifecycle(confidentSignal);
+                        if (this.isDuplicateSession(confidentSignal)) {
                             if (this.options.debug) {
-                                console.log('[MeetingDetector] Skipping duplicate session:', signal);
+                                console.log('[MeetingDetector] Skipping duplicate session:', confidentSignal);
                             }
                             continue;
                         }
+                        const outputSignal = this.sanitizeSignalForOutput(confidentSignal);
                         if (this.options.debug) {
-                            console.log('[MeetingDetector] Parsed signal:', signal);
+                            console.log('[MeetingDetector] Parsed signal:', outputSignal);
                         }
-                        this.emit('meeting', signal);
+                        this.emit('meeting', outputSignal);
                     }
                     catch (error) {
                         if (this.options.debug) {
@@ -61,8 +84,10 @@ export class MeetingDetector extends EventEmitter {
             }
         });
         this.process.stderr?.on('data', (data) => {
+            const text = data.toString();
+            stderrBuffer += text;
             if (this.options.debug) {
-                console.log('[MeetingDetector] stderr:', data.toString());
+                console.log('[MeetingDetector] stderr:', text);
             }
         });
         this.process.on('error', (error) => {
@@ -72,6 +97,26 @@ export class MeetingDetector extends EventEmitter {
             if (this.options.debug) {
                 console.log(`[MeetingDetector] Process exited with code ${code}, signal ${signal}`);
             }
+            // Detect permission errors: log stream exits immediately with non-zero code and
+            // a relevant message when macOS privacy access has not been granted.
+            if (code !== 0 && code !== null && !signal) {
+                const stderr = stderrBuffer.toLowerCase();
+                if (stderr.includes('not allowed') ||
+                    stderr.includes('authorization') ||
+                    stderr.includes('permission denied') ||
+                    stderr.includes('operation not permitted')) {
+                    this.emit('error', new Error('Meeting detector failed to access macOS privacy logs (exit code ' + code + '). ' +
+                        'Grant Full Disk Access or Automation permissions in System Settings > Privacy & Security.'));
+                }
+            }
+            if (this.meetingEndTimer) {
+                clearTimeout(this.meetingEndTimer);
+                this.meetingEndTimer = undefined;
+            }
+            if (this.activeMeeting) {
+                this.emitMeetingLifecycle('meeting_ended', this.activeMeeting.platform, this.activeMeeting.confidence, 'stop', this.activeMeeting.signal);
+                this.activeMeeting = null;
+            }
             this.process = undefined;
             this.emit('exit', { code, signal });
         });
@@ -86,8 +131,18 @@ export class MeetingDetector extends EventEmitter {
         if (this.process) {
             this.process.kill('SIGTERM');
             this.process = undefined;
+            if (this.meetingEndTimer) {
+                clearTimeout(this.meetingEndTimer);
+                this.meetingEndTimer = undefined;
+            }
+            if (this.activeMeeting) {
+                this.emitMeetingLifecycle('meeting_ended', this.activeMeeting.platform, this.activeMeeting.confidence, 'stop', this.activeMeeting.signal);
+            }
+            this.activeMeeting = null;
             // Clear active sessions when stopping
             this.activeSessions.clear();
+            this.pendingConfidence.clear();
+            this.serviceContext.clear();
             if (this.options.debug) {
                 console.log('[MeetingDetector] Stopped monitoring');
             }
@@ -111,6 +166,18 @@ export class MeetingDetector extends EventEmitter {
     onError(callback) {
         this.on('error', callback);
     }
+    /**
+     * Add lifecycle event listeners
+     */
+    onMeetingStarted(callback) {
+        this.on('meeting_started', callback);
+    }
+    onMeetingChanged(callback) {
+        this.on('meeting_changed', callback);
+    }
+    onMeetingEnded(callback) {
+        this.on('meeting_ended', callback);
+    }
     /**
      * Comprehensive filtering to prevent false positives
      * Filters out:
@@ -130,10 +197,13 @@ export class MeetingDetector extends EventEmitter {
             'granola helper', // Screen recording helper
             'webkit.gpu', // WebKit GPU process
             'webkit.networking', // WebKit networking
-            'chrome helper', // Chrome helper processes (too generic)
-            'electron helper', // Electron helper processes
+            // NOTE: 'chrome helper' intentionally NOT listed — Chrome Helper is the process
+            // used by Google Meet, Zoom web, and other browser-based meeting platforms.
+            'electron helper', // Electron helper processes (not meeting-specific)
+            'caphost', // Zoom internal media helper (emitted separately)
+            'webview helper', // Generic WKWebView helper
         ];
-        // Services/apps that are too generic or development-related
+        // Services/apps that are too generic or non-meeting
         const genericServices = [
             'electron',
             'terminal',
@@ -141,14 +211,20 @@ export class MeetingDetector extends EventEmitter {
             'finder',
             'xcode',
             'tips',
-            'google chrome', // Generic Chrome service (not a specific meeting)
-            'safari', // Generic Safari service
-            'firefox', // Generic Firefox service
-            'microsoft edge', // Generic Edge service
+            'google chrome', // Generic Chrome (resolved to 'Google Meet' when in a call)
+            'safari',
+            'firefox',
+            'microsoft edge',
+            'photo booth',
+            'quicktime player',
+            'quicktime playerx',
         ];
         const processName = signal.process?.toLowerCase() || '';
         const serviceName = signal.service?.toLowerCase() || '';
-        // Filter by process name patterns (partial match for flexibility)
+        if (serviceName === 'unknown' && !this.options.emitUnknown) {
+            return true;
+        }
+        // Filter by process name patterns (partial match)
         if (systemProcessPatterns.some(pattern => processName.includes(pattern))) {
             return true;
         }
@@ -156,38 +232,282 @@ export class MeetingDetector extends EventEmitter {
         if (genericServices.includes(serviceName)) {
             return true;
         }
-        // Camera initialization filter: if verdict is 'requested' and window_title is empty,
-        // it's likely just camera initialization, not an actual meeting
-        // This applies to ALL apps to prevent false positives during camera setup
+        // Camera initialization filter: if verdict is 'requested' and window_title is empty
+        // AND the camera hardware is not yet active, it's a pre-check, not an active call.
         if (signal.verdict === 'requested' && (!signal.window_title || signal.window_title.trim() === '')) {
-            // Exception: if camera is actively being used (not just requested), allow it through
-            // This helps distinguish between "requesting permission" vs "actively in a call"
             if (!signal.camera_active) {
                 return true;
             }
         }
-        // For Google Meet specifically: require window title to contain meeting URL patterns
-        // This prevents false positives from just opening Chrome with camera permissions
+        // For Google Meet (Chrome-based): validate title only when it is available.
+        // When Chrome is backgrounded the title is empty — still allow the signal through
+        // because the meeting is genuinely active (camera_active guard above already handles
+        // the pre-check case).
         if (serviceName === 'google meet') {
-            const windowTitle = signal.window_title || '';
-            // Valid Google Meet windows should contain:
-            // - meet.google.com URL
-            // - "Meet - " prefix in title
-            // - Valid meeting code pattern (e.g., abc-defg-hij)
-            const hasValidMeetTitle = windowTitle.includes('meet.google.com') ||
-                windowTitle.includes('Meet - ') ||
-                /[a-z]{3}-[a-z]{4}-[a-z]{3}/.test(windowTitle); // Meeting code pattern
-            if (!hasValidMeetTitle) {
-                return true;
+            const windowTitle = signal.window_title?.trim() || '';
+            if (windowTitle !== '') {
+                // Title present → require it to look like an actual meeting room
+                const hasValidMeetTitle = windowTitle.includes('meet.google.com') ||
+                    windowTitle.includes('Meet - ') ||
+                    /[a-z]{3}-[a-z]{4}-[a-z]{3}/.test(windowTitle);
+                if (!hasValidMeetTitle) {
+                    return true;
+                }
             }
+            // Empty title → pass through (Chrome is backgrounded but meeting is active)
         }
         return false;
     }
+    sanitizeSignalForOutput(signal) {
+        if (this.options.includeSensitiveMetadata) {
+            return { ...signal };
+        }
+        return {
+            ...signal,
+            window_title: '',
+            chrome_url: undefined,
+        };
+    }
+    normalizePlatform(service) {
+        const key = (service || '').trim().toLowerCase();
+        if (!key)
+            return 'Unknown';
+        if (key === 'microsoft teams')
+            return 'Microsoft Teams';
+        if (key === 'zoom')
+            return 'Zoom';
+        if (key === 'google meet')
+            return 'Google Meet';
+        if (key === 'slack')
+            return 'Slack';
+        if (key === 'webex' || key === 'cisco webex')
+            return 'Cisco Webex';
+        if (key === 'discord')
+            return 'Discord';
+        if (key === 'facetime')
+            return 'FaceTime';
+        if (key === 'skype')
+            return 'Skype';
+        if (key === 'whereby')
+            return 'Whereby';
+        if (key === 'gotomeeting')
+            return 'GoToMeeting';
+        if (key === 'bluejeans')
+            return 'BlueJeans';
+        if (key === 'jitsi meet')
+            return 'Jitsi Meet';
+        if (key === '8x8')
+            return '8x8';
+        if (key === 'ringcentral')
+            return 'RingCentral';
+        if (key === 'bigbluebutton')
+            return 'BigBlueButton';
+        if (key === 'amazon chime')
+            return 'Amazon Chime';
+        if (key === 'google hangouts')
+            return 'Google Hangouts';
+        if (key === 'adobe connect')
+            return 'Adobe Connect';
+        if (key === 'teamviewer')
+            return 'TeamViewer';
+        if (key === 'anydesk')
+            return 'AnyDesk';
+        if (key === 'clickmeeting')
+            return 'ClickMeeting';
+        if (key === 'appear.in')
+            return 'Appear.in';
+        return 'Unknown';
+    }
+    getSignalConfidence(signal) {
+        if (signal.verdict === 'allowed' || signal.preflight === false) {
+            return 'high';
+        }
+        if ((signal.window_title && signal.window_title.trim() !== '') || signal.camera_active) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    emitMeetingLifecycle(event, platform, confidence, reason, signal, previousPlatform) {
+        const payload = {
+            event,
+            timestamp: new Date().toISOString(),
+            platform,
+            confidence,
+            reason,
+            previous_platform: previousPlatform,
+            raw_signal: this.options.includeRawSignalInLifecycle ? this.sanitizeSignalForOutput(signal) : undefined,
+        };
+        this.emit(event, payload);
+        this.emit('meeting_lifecycle', payload);
+    }
+    scheduleMeetingEndCheck() {
+        if (this.meetingEndTimer) {
+            clearTimeout(this.meetingEndTimer);
+        }
+        if (!this.activeMeeting) {
+            this.meetingEndTimer = undefined;
+            return;
+        }
+        this.meetingEndTimer = setTimeout(() => {
+            this.handleMeetingEndTimeout();
+        }, this.options.meetingEndTimeoutMs);
+        this.meetingEndTimer.unref?.();
+    }
+    handleMeetingEndTimeout() {
+        if (!this.activeMeeting) {
+            this.meetingEndTimer = undefined;
+            return;
+        }
+        const idleMs = Date.now() - this.activeMeeting.lastSeen;
+        if (idleMs >= this.options.meetingEndTimeoutMs) {
+            const ended = this.activeMeeting;
+            this.activeMeeting = null;
+            this.meetingEndTimer = undefined;
+            this.emitMeetingLifecycle('meeting_ended', ended.platform, ended.confidence, 'timeout', ended.signal);
+            return;
+        }
+        this.scheduleMeetingEndCheck();
+    }
+    updateMeetingLifecycle(signal) {
+        const platform = this.normalizePlatform(signal.service);
+        if (platform === 'Unknown' && !this.options.emitUnknown) {
+            return;
+        }
+        const confidence = this.getSignalConfidence(signal);
+        const now = Date.now();
+        if (!this.activeMeeting) {
+            this.activeMeeting = {
+                platform,
+                lastSeen: now,
+                confidence,
+                signal,
+            };
+            this.emitMeetingLifecycle('meeting_started', platform, confidence, 'signal', signal);
+            this.scheduleMeetingEndCheck();
+            return;
+        }
+        if (this.activeMeeting.platform !== platform) {
+            const previousPlatform = this.activeMeeting.platform;
+            this.activeMeeting = {
+                platform,
+                lastSeen: now,
+                confidence,
+                signal,
+            };
+            this.emitMeetingLifecycle('meeting_changed', platform, confidence, 'switch', signal, previousPlatform);
+            this.scheduleMeetingEndCheck();
+            return;
+        }
+        this.activeMeeting.lastSeen = now;
+        this.activeMeeting.confidence = confidence;
+        this.activeMeeting.signal = signal;
+        this.scheduleMeetingEndCheck();
+    }
+    getServiceKey(signal) {
+        return (signal.service || signal.front_app || signal.process || '').toLowerCase();
+    }
+    isFrontAppConsistentWithService(frontApp, service) {
+        const f = (frontApp || '').toLowerCase();
+        const s = (service || '').toLowerCase();
+        if (!f || !s)
+            return false;
+        if (s === 'microsoft teams') {
+            return f.includes('teams') || f.includes('msteams');
+        }
+        if (s === 'google meet') {
+            return f.includes('chrome') || f.includes('google meet');
+        }
+        if (s === 'zoom') {
+            return f.includes('zoom');
+        }
+        if (s === 'cisco webex') {
+            return f.includes('webex');
+        }
+        if (s === 'slack') {
+            return f.includes('slack');
+        }
+        return f.includes(s);
+    }
+    stabilizeSignalContext(signal) {
+        const key = this.getServiceKey(signal);
+        const existing = this.serviceContext.get(key) || {};
+        const next = { ...signal };
+        const rawFront = (signal.front_app || '').trim();
+        const rawTitle = (signal.window_title || '').trim();
+        const frontConsistent = this.isFrontAppConsistentWithService(rawFront, signal.service);
+        if (rawFront && frontConsistent) {
+            next.front_app = rawFront;
+            existing.frontApp = rawFront;
+        }
+        else if (existing.frontApp) {
+            next.front_app = existing.frontApp;
+        }
+        else {
+            // Keep context aligned with detected service when OS foreground sampling is stale.
+            next.front_app = signal.service;
+            existing.frontApp = signal.service;
+        }
+        if (rawTitle && frontConsistent) {
+            next.window_title = rawTitle;
+            existing.windowTitle = rawTitle;
+        }
+        else if (existing.windowTitle && this.isFrontAppConsistentWithService(next.front_app, signal.service)) {
+            next.window_title = existing.windowTitle;
+        }
+        else {
+            next.window_title = '';
+        }
+        this.serviceContext.set(key, existing);
+        return next;
+    }
+    isLowConfidenceSignal(signal) {
+        const serviceKey = this.getServiceKey(signal);
+        if (!MeetingDetector.PRECHECK_PRONE_SERVICES.has(serviceKey)) {
+            return false;
+        }
+        const hasNoWindowTitle = !signal.window_title || signal.window_title.trim() === '';
+        return signal.verdict === 'requested' && signal.preflight === true && hasNoWindowTitle;
+    }
+    hasStrongMeetingEvidence(signal) {
+        if (signal.verdict === 'allowed' || signal.preflight === false) {
+            return true;
+        }
+        return !!signal.window_title && signal.window_title.trim() !== '';
+    }
+    cleanupExpiredPendingConfidence(now) {
+        for (const [key, pending] of this.pendingConfidence.entries()) {
+            if (now - pending.lastSeen > MeetingDetector.LOW_CONFIDENCE_WINDOW_MS) {
+                this.pendingConfidence.delete(key);
+            }
+        }
+    }
+    resolveConfidence(signal) {
+        const now = Date.now();
+        this.cleanupExpiredPendingConfidence(now);
+        const key = this.getServiceKey(signal);
+        const pending = this.pendingConfidence.get(key);
+        const lowConfidence = this.isLowConfidenceSignal(signal);
+        const strongEvidence = this.hasStrongMeetingEvidence(signal);
+        if (strongEvidence) {
+            this.pendingConfidence.delete(key);
+            return signal;
+        }
+        if (!lowConfidence) {
+            return signal;
+        }
+        // For precheck-prone services (Teams, Zoom, Webex, Slack) only strong evidence
+        // is trusted. These apps continuously send preflight checks even when idle, so
+        // the burst+sparse-follow-up pattern would satisfy any time/count threshold.
+        // Real meetings from these apps produce FORWARD events (preflight=false) which
+        // are caught by hasStrongMeetingEvidence above.
+        return null;
+    }
     /**
      * Generate a unique session key based on the signal properties
      */
     getSessionKey(signal) {
-        return `${signal.pid}:${signal.service}:${signal.front_app}`;
+        // Session key is service-centric to collapse helper-process bursts from the same app.
+        return signal.service || signal.front_app || signal.process;
     }
     /**
      * Check if this signal is a duplicate of an existing session
@@ -234,9 +554,10 @@ export class MeetingDetector extends EventEmitter {
     }
     parseSignal(line) {
         const signal = JSON.parse(line);
+        const chromeUrl = signal.chrome_url || '';
         // Use transformed app name as service if the original service is a system service like 'microphone' or 'camera'
         const originalService = signal.service || '';
-        const transformedService = this.transformAppName(signal.front_app, signal.process);
+        const transformedService = this.transformAppName(signal.front_app, signal.process, signal.window_title || '', chromeUrl);
         const finalService = (originalService === 'microphone' || originalService === 'camera' || !originalService)
             ? transformedService
             : originalService;
@@ -245,6 +566,7 @@ export class MeetingDetector extends EventEmitter {
             timestamp: signal.timestamp,
             service: finalService,
             verdict: signal.verdict || '',
+            preflight: signal.preflight === 'true' || signal.preflight === true,
             process: signal.process || '',
             pid: signal.pid || '',
             parent_pid: signal.parent_pid || '',
@@ -252,84 +574,237 @@ export class MeetingDetector extends EventEmitter {
             front_app: signal.front_app || '',
             window_title: signal.window_title || '',
             session_id: signal.session_id || '',
-            camera_active: signal.camera_active === 'true' || signal.camera_active === true
+            camera_active: signal.camera_active === 'true' || signal.camera_active === true,
+            chrome_url: chromeUrl
         };
     }
-    transformAppName(frontApp, process) {
+    includesAny(value, patterns) {
+        return patterns.some((pattern) => value.includes(pattern));
+    }
+    transformAppName(frontApp, process, windowTitle = '', chromeUrl = '') {
         const app = frontApp?.toLowerCase() || '';
         const proc = process?.toLowerCase() || '';
-        if (app.includes('slack') || proc.includes('slack')) {
-            return 'Slack';
-        }
-        else if (app.includes('msteams') || proc.includes('microsoft teams') || proc.includes('teams')) {
+        const title = windowTitle?.toLowerCase() || '';
+        const url = chromeUrl.toLowerCase();
+        // For Chrome Helper processes, the active tab URL is the definitive source —
+        // it does not depend on which app is currently frontmost.
+        if (url && proc.includes('chrome')) {
+            if (url.includes('meet.google.com'))
+                return 'Google Meet';
+            if (url.includes('zoom.us/wc/') || url.includes('zoom.us/j/'))
+                return 'Zoom';
+            if (url.includes('teams.microsoft.com') || url.includes('teams.live.com'))
+                return 'Microsoft Teams';
+            if (url.includes('web.webex.com') || url.includes('webex.com/meet'))
+                return 'Cisco Webex';
+            if (url.includes('app.slack.com') && url.includes('huddle'))
+                return 'Slack';
+            if (url.includes('meet.jit.si') || url.includes('jitsi'))
+                return 'Jitsi Meet';
+            if (url.includes('whereby.com'))
+                return 'Whereby';
+            if (url.includes('bluejeans.com'))
+                return 'BlueJeans';
+            if (url.includes('ringcentral.com'))
+                return 'RingCentral';
+            if (url.includes('chime.aws'))
+                return 'Amazon Chime';
+            if (url.includes('goto.com') || url.includes('gotomeeting.com'))
+                return 'GoToMeeting';
+        }
+        // Prefer process identity next because front_app sampling can be stale.
+        if (this.includesAny(proc, ['microsoft teams', 'msteams']))
             return 'Microsoft Teams';
-        }
-        else if (app.includes('zoom') || proc.includes('zoom')) {
+        if (this.includesAny(proc, ['zoom']))
             return 'Zoom';
-        }
-        else if (app.includes('webex') || proc.includes('webex') || proc.includes('cisco webex')) {
-            return 'Webex';
-        }
-        else if (app.includes('google meet') || proc.includes('google meet') || proc.includes('meet.google.com') || (app.includes('chrome') && proc.includes('chrome'))) {
+        if (this.includesAny(proc, ['webex', 'cisco webex']))
+            return 'Cisco Webex';
+        if (this.includesAny(proc, ['slack']))
+            return 'Slack';
+        if (this.includesAny(proc, ['google meet', 'meet.google.com']))
+            return 'Google Meet';
+        if (proc.includes('chrome') && (title.includes('meet.google.com') || /[a-z]{3}-[a-z]{4}-[a-z]{3}/.test(title))) {
             return 'Google Meet';
         }
-        else if (app.includes('skype') || proc.includes('skype')) {
+        if (this.includesAny(proc, ['skype']))
             return 'Skype';
-        }
-        else if (app.includes('discord') || proc.includes('discord')) {
+        if (this.includesAny(proc, ['discord']))
             return 'Discord';
-        }
-        else if (app.includes('facetime') || proc.includes('facetime')) {
+        if (this.includesAny(proc, ['facetime']))
             return 'FaceTime';
-        }
-        else if (app.includes('gotomeeting') || proc.includes('gotomeeting') || proc.includes('goto meeting')) {
+        if (this.includesAny(proc, ['gotomeeting', 'goto meeting']))
             return 'GoToMeeting';
-        }
-        else if (app.includes('bluejeans') || proc.includes('bluejeans') || proc.includes('blue jeans')) {
+        if (this.includesAny(proc, ['bluejeans', 'blue jeans']))
             return 'BlueJeans';
-        }
-        else if (app.includes('jitsi') || proc.includes('jitsi')) {
+        if (this.includesAny(proc, ['jitsi']))
             return 'Jitsi Meet';
-        }
-        else if (app.includes('whereby') || proc.includes('whereby')) {
+        if (this.includesAny(proc, ['whereby']))
             return 'Whereby';
-        }
-        else if (app.includes('8x8') || proc.includes('8x8')) {
+        if (this.includesAny(proc, ['8x8']))
             return '8x8';
-        }
-        else if (app.includes('ringcentral') || proc.includes('ringcentral') || proc.includes('ring central')) {
+        if (this.includesAny(proc, ['ringcentral', 'ring central']))
             return 'RingCentral';
-        }
-        else if (app.includes('bigbluebutton') || proc.includes('bigbluebutton') || proc.includes('big blue button')) {
+        if (this.includesAny(proc, ['bigbluebutton', 'big blue button']))
             return 'BigBlueButton';
-        }
-        else if (app.includes('chime') || proc.includes('chime') || proc.includes('amazon chime')) {
+        if (this.includesAny(proc, ['amazon chime', 'chime']))
             return 'Amazon Chime';
-        }
-        else if (app.includes('hangouts') || proc.includes('hangouts') || proc.includes('google hangouts')) {
+        if (this.includesAny(proc, ['google hangouts', 'hangouts']))
             return 'Google Hangouts';
-        }
-        else if (app.includes('adobe connect') || proc.includes('adobe connect')) {
+        if (this.includesAny(proc, ['adobe connect']))
             return 'Adobe Connect';
-        }
-        else if (app.includes('teamviewer') || proc.includes('teamviewer')) {
+        if (this.includesAny(proc, ['teamviewer']))
             return 'TeamViewer';
-        }
-        else if (app.includes('anydesk') || proc.includes('anydesk')) {
+        if (this.includesAny(proc, ['anydesk']))
             return 'AnyDesk';
-        }
-        else if (app.includes('clickmeeting') || proc.includes('clickmeeting')) {
+        if (this.includesAny(proc, ['clickmeeting']))
             return 'ClickMeeting';
-        }
-        else if (app.includes('appear.in') || proc.includes('appear.in')) {
+        if (this.includesAny(proc, ['appear.in']))
             return 'Appear.in';
+        // Fallback to front_app when process identity is generic/indirect (e.g., Chrome Helper
+        // without a chrome_url resolved). front_app is unreliable when Chrome is backgrounded
+        // — only use it when we have no better signal.
+        if (this.includesAny(app, ['microsoft teams', 'msteams']))
+            return 'Microsoft Teams';
+        if (this.includesAny(app, ['zoom']))
+            return 'Zoom';
+        if (this.includesAny(app, ['webex']))
+            return 'Cisco Webex';
+        if (this.includesAny(app, ['slack']))
+            return 'Slack';
+        if (this.includesAny(app, ['google meet']))
+            return 'Google Meet';
+        if (this.includesAny(app, ['chrome']) && (title.includes('meet.google.com') || /[a-z]{3}-[a-z]{4}-[a-z]{3}/.test(title))) {
+            return 'Google Meet';
         }
-        else {
-            // Fallback to front_app if no match
-            return frontApp || 'Meeting App';
-        }
+        if (this.includesAny(app, ['skype']))
+            return 'Skype';
+        if (this.includesAny(app, ['discord']))
+            return 'Discord';
+        if (this.includesAny(app, ['facetime']))
+            return 'FaceTime';
+        if (this.includesAny(app, ['gotomeeting']))
+            return 'GoToMeeting';
+        if (this.includesAny(app, ['bluejeans']))
+            return 'BlueJeans';
+        if (this.includesAny(app, ['jitsi']))
+            return 'Jitsi Meet';
+        if (this.includesAny(app, ['whereby']))
+            return 'Whereby';
+        if (this.includesAny(app, ['8x8']))
+            return '8x8';
+        if (this.includesAny(app, ['ringcentral']))
+            return 'RingCentral';
+        if (this.includesAny(app, ['chime']))
+            return 'Amazon Chime';
+        if (this.includesAny(app, ['hangouts']))
+            return 'Google Hangouts';
+        if (this.includesAny(app, ['adobe connect']))
+            return 'Adobe Connect';
+        if (this.includesAny(app, ['teamviewer']))
+            return 'TeamViewer';
+        if (this.includesAny(app, ['anydesk']))
+            return 'AnyDesk';
+        if (this.includesAny(app, ['clickmeeting']))
+            return 'ClickMeeting';
+        if (this.includesAny(app, ['appear.in']))
+            return 'Appear.in';
+        // Final fallback: do not guess.
+        return 'Unknown';
+    }
+    /**
+     * Check at startup whether a supported meeting is already active.
+     * Emits a synthetic meeting_started lifecycle event if found.
+     * This handles the case where the detector starts while a call is already in progress.
+     */
+    probeActiveMeetingAtStartup() {
+        // Check whether the camera daemon is already running (indicates active camera use).
+        const cameraProbe = spawn('sh', ['-c',
+            'pgrep -xq VDCAssistant 2>/dev/null || pgrep -xq AppleCameraAssistant 2>/dev/null'
+        ]);
+        cameraProbe.on('close', (cameraCode) => {
+            // P2 guard: abort if the detector was stopped before this callback fired.
+            if (!this.process)
+                return;
+            if (cameraCode !== 0)
+                return; // Camera not active — no meeting in progress.
+            // Candidates in priority order. Run ALL checks independently (semicolons, not ||) so
+            // every running app is discovered, then resolve ambiguity via front-app tiebreak.
+            const candidates = [
+                ['Microsoft Teams', 'Microsoft Teams'],
+                ['zoom.us', 'Zoom'],
+                ['Webex', 'Cisco Webex'],
+                ['Slack', 'Slack'],
+                ['Discord', 'Discord'],
+                ['FaceTime', 'FaceTime'],
+            ];
+            // Query front app in parallel with process checks so we can resolve ambiguity
+            // without adding extra latency.
+            const procScript = candidates
+                .map(([proc, label]) => `pgrep -xq "${proc}" 2>/dev/null && echo "${label}"; true`)
+                .join('; ');
+            const fullScript = `(${procScript}); echo "FRONTAPP=$(osascript -e 'tell application "System Events" to name of first application process whose frontmost is true' 2>/dev/null || echo '')"`;
+            const procProbe = spawn('sh', ['-c', fullScript]);
+            let output = '';
+            procProbe.stdout?.on('data', (d) => { output += d.toString(); });
+            procProbe.on('close', () => {
+                // P2 guard: abort if the detector was stopped while the probe was running.
+                if (!this.process)
+                    return;
+                const matched = candidates.filter(([, label]) => output.includes(label));
+                if (matched.length === 0)
+                    return; // No known meeting process found.
+                let selected = matched[0]; // Priority-order fallback (first in candidate list).
+                if (matched.length > 1) {
+                    // Multiple meeting apps are running. Use the frontmost app to tiebreak:
+                    // the focused window is almost always the active meeting.
+                    const frontMatch = output.match(/FRONTAPP=(.+)/);
+                    const frontApp = (frontMatch?.[1] || '').trim().toLowerCase();
+                    const frontCandidate = matched.find(([proc]) => proc.toLowerCase().includes(frontApp) || frontApp.includes(proc.toLowerCase()));
+                    if (frontCandidate) {
+                        selected = frontCandidate;
+                    }
+                    // If frontmost app is not a meeting app (e.g. user is in Zoom but looking at
+                    // a browser), fall through to priority-order selection (selected = matched[0]).
+                    if (this.options.debug) {
+                        console.log('[MeetingDetector] Startup probe: multiple apps found, front app resolution', { matched: matched.map(([, l]) => l), frontApp, selected: selected[1] });
+                    }
+                }
+                const [procName, platform] = selected;
+                const now = new Date().toISOString().slice(0, 19) + 'Z';
+                const syntheticSignal = {
+                    event: 'meeting_signal',
+                    timestamp: now,
+                    service: platform,
+                    verdict: 'allowed',
+                    preflight: false,
+                    process: procName,
+                    pid: '',
+                    parent_pid: '',
+                    process_path: '',
+                    front_app: procName,
+                    window_title: '',
+                    session_id: '',
+                    camera_active: true,
+                };
+                if (this.options.debug) {
+                    console.log('[MeetingDetector] Startup probe found active meeting:', platform);
+                }
+                this.updateMeetingLifecycle(syntheticSignal);
+                const outputSignal = this.sanitizeSignalForOutput(syntheticSignal);
+                this.emit('meeting', outputSignal);
+            });
+        });
     }
 }
+MeetingDetector.LOW_CONFIDENCE_WINDOW_MS = 45000;
+MeetingDetector.LOW_CONFIDENCE_FALLBACK_MIN_SIGNALS = 4;
+MeetingDetector.LOW_CONFIDENCE_FALLBACK_MIN_DURATION_MS = 30000;
+MeetingDetector.PRECHECK_PRONE_SERVICES = new Set([
+    'microsoft teams',
+    'zoom',
+    'cisco webex',
+    'slack'
+]);
 // Convenience function for simple usage
 export function detector(callback, options) {
     const detector = new MeetingDetector(options);