Add custom screen picker dialog for Windows audio capture and update version to 0.5.10

forge.config.js

@@ -30,15 +30,15 @@ module.exports = {
         ],
         // use `security find-identity -v -p codesigning` to find your identity
         // for macos signing
-        // Use ad-hoc signing with entitlements for local development
-        osxSign: {
-            identity: '-', // ad-hoc signing (no Apple Developer account needed)
-            optionsForFile: (filePath) => {
-                return {
-                    entitlements: 'entitlements.plist',
-                };
-            },
-        },
+        // Disabled for local builds - ad-hoc signing causes issues
+        // osxSign: {
+        //     identity: '-', // ad-hoc signing (no Apple Developer account needed)
+        //     optionsForFile: (filePath) => {
+        //         return {
+        //             entitlements: 'entitlements.plist',
+        //         };
+        //     },
+        // },
         // notarize is off - requires Apple Developer account
         // osxNotarize: {
         //    appleId: 'your apple id',
@@ -61,6 +61,10 @@ module.exports = {
         {
             name: '@electron-forge/maker-dmg',
             platforms: ['darwin'],
+            config: {
+                name: 'CheatingDaddy',
+                format: 'ULFO',
+            },
         },
         {
             name: '@reforged/maker-appimage',

package.json

@@ -1,7 +1,7 @@
 {
     "name": "cheating-daddy",
     "productName": "cheating-daddy",
-    "version": "0.5.3",
+    "version": "0.5.10",
     "description": "cheating daddy",
     "main": "src/index.js",
     "scripts": {
@@ -19,8 +19,8 @@
         "cheating daddy ai assistant for interviews"
     ],
     "author": {
-        "name": "sohzm",
-        "email": "sohambharambe9@gmail.com"
+        "name": "ShiftyX1",
+        "email": "lead@pyserve.org"
     },
     "license": "GPL-3.0",
     "dependencies": {

src/components/app/CheatingDaddyApp.js

@@ -6,6 +6,7 @@ import { HelpView } from '../views/HelpView.js';
 import { HistoryView } from '../views/HistoryView.js';
 import { AssistantView } from '../views/AssistantView.js';
 import { OnboardingView } from '../views/OnboardingView.js';
+import { ScreenPickerDialog } from '../views/ScreenPickerDialog.js';
 
 export class CheatingDaddyApp extends LitElement {
     static styles = css`
@@ -112,6 +113,8 @@ export class CheatingDaddyApp extends LitElement {
         _storageLoaded: { state: true },
         aiProvider: { type: String },
         modelInfo: { type: Object },
+        showScreenPicker: { type: Boolean },
+        screenSources: { type: Array },
     };
 
     constructor() {
@@ -137,6 +140,8 @@ export class CheatingDaddyApp extends LitElement {
         this._storageLoaded = false;
         this.aiProvider = 'gemini';
         this.modelInfo = { model: '', visionModel: '', whisperModel: '' };
+        this.showScreenPicker = false;
+        this.screenSources = [];
 
         // Load from storage
         this._loadFromStorage();
@@ -549,6 +554,16 @@ export class CheatingDaddyApp extends LitElement {
                         <div class="view-container">${this.renderCurrentView()}</div>
                     </div>
                 </div>
+                ${this.showScreenPicker
+                    ? html`
+                          <screen-picker-dialog
+                              ?visible=${this.showScreenPicker}
+                              .sources=${this.screenSources}
+                              @source-selected=${this.handleSourceSelected}
+                              @cancelled=${this.handlePickerCancelled}
+                          ></screen-picker-dialog>
+                      `
+                    : ''}
             </div>
         `;
     }
@@ -579,6 +594,44 @@ export class CheatingDaddyApp extends LitElement {
 
         this.requestUpdate();
     }
+
+    async showScreenPickerDialog() {
+        const { ipcRenderer } = window.require('electron');
+        const result = await ipcRenderer.invoke('get-screen-sources');
+        
+        if (result.success) {
+            this.screenSources = result.sources;
+            this.showScreenPicker = true;
+            return new Promise((resolve) => {
+                this._screenPickerResolve = resolve;
+            });
+        } else {
+            console.error('Failed to get screen sources:', result.error);
+            return { cancelled: true };
+        }
+    }
+
+    async handleSourceSelected(event) {
+        const { source } = event.detail;
+        const { ipcRenderer } = window.require('electron');
+        
+        // Tell main process which source was selected
+        await ipcRenderer.invoke('set-selected-source', source.id);
+        
+        this.showScreenPicker = false;
+        if (this._screenPickerResolve) {
+            this._screenPickerResolve({ source });
+            this._screenPickerResolve = null;
+        }
+    }
+
+    handlePickerCancelled() {
+        this.showScreenPicker = false;
+        if (this._screenPickerResolve) {
+            this._screenPickerResolve({ cancelled: true });
+            this._screenPickerResolve = null;
+        }
+    }
 }
 
 customElements.define('cheating-daddy-app', CheatingDaddyApp);

src/components/views/ScreenPickerDialog.js

@@ -0,0 +1,175 @@
+import { html, css, LitElement } from '../../assets/lit-core-2.7.4.min.js';
+
+export class ScreenPickerDialog extends LitElement {
+    static properties = {
+        sources: { type: Array },
+        visible: { type: Boolean },
+    };
+
+    static styles = css`
+        :host {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: rgba(0, 0, 0, 0.8);
+            z-index: 10000;
+            align-items: center;
+            justify-content: center;
+        }
+
+        :host([visible]) {
+            display: flex;
+        }
+
+        .dialog {
+            background: var(--background-color);
+            border: 1px solid var(--border-color);
+            border-radius: 8px;
+            padding: 24px;
+            max-width: 800px;
+            max-height: 80vh;
+            overflow-y: auto;
+        }
+
+        h2 {
+            margin: 0 0 16px 0;
+            color: var(--text-color);
+            font-size: 18px;
+            font-weight: 500;
+        }
+
+        .sources-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+            gap: 12px;
+            margin-bottom: 16px;
+        }
+
+        .source-item {
+            background: var(--input-background);
+            border: 2px solid transparent;
+            border-radius: 6px;
+            padding: 12px;
+            cursor: pointer;
+            transition: all 0.2s ease;
+        }
+
+        .source-item:hover {
+            border-color: var(--border-default);
+            background: var(--button-hover);
+        }
+
+        .source-item.selected {
+            border-color: var(--accent-color);
+            background: var(--button-hover);
+        }
+
+        .source-thumbnail {
+            width: 100%;
+            height: 120px;
+            object-fit: contain;
+            background: #1a1a1a;
+            border-radius: 4px;
+            margin-bottom: 8px;
+        }
+
+        .source-name {
+            color: var(--text-color);
+            font-size: 13px;
+            text-align: center;
+            word-break: break-word;
+        }
+
+        .buttons {
+            display: flex;
+            gap: 8px;
+            justify-content: flex-end;
+        }
+
+        button {
+            background: var(--button-background);
+            color: var(--text-color);
+            border: 1px solid var(--border-color);
+            padding: 8px 16px;
+            border-radius: 3px;
+            cursor: pointer;
+            font-size: 13px;
+            transition: background-color 0.1s ease;
+        }
+
+        button:hover {
+            background: var(--button-hover);
+        }
+
+        button.primary {
+            background: var(--accent-color);
+            color: white;
+            border-color: var(--accent-color);
+        }
+
+        button.primary:hover {
+            background: var(--accent-hover);
+        }
+
+        button:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+    `;
+
+    constructor() {
+        super();
+        this.sources = [];
+        this.visible = false;
+        this.selectedSource = null;
+    }
+
+    selectSource(source) {
+        this.selectedSource = source;
+        this.requestUpdate();
+    }
+
+    confirm() {
+        if (this.selectedSource) {
+            this.dispatchEvent(
+                new CustomEvent('source-selected', {
+                    detail: { source: this.selectedSource },
+                })
+            );
+        }
+    }
+
+    cancel() {
+        this.dispatchEvent(new CustomEvent('cancelled'));
+    }
+
+    render() {
+        return html`
+            <div class="dialog">
+                <h2>Choose screen or window to share</h2>
+                <div class="sources-grid">
+                    ${this.sources.map(
+                        source => html`
+                            <div
+                                class="source-item ${this.selectedSource?.id === source.id ? 'selected' : ''}"
+                                @click=${() => this.selectSource(source)}
+                            >
+                                <img class="source-thumbnail" src="${source.thumbnail}" alt="${source.name}" />
+                                <div class="source-name">${source.name}</div>
+                            </div>
+                        `
+                    )}
+                </div>
+                <div class="buttons">
+                    <button @click=${this.cancel}>Cancel</button>
+                    <button class="primary" @click=${this.confirm} ?disabled=${!this.selectedSource}>Share</button>
+                </div>
+            </div>
+        `;
+    }
+}
+
+customElements.define('screen-picker-dialog', ScreenPickerDialog);

src/utils/openai-sdk.js

@@ -281,6 +281,7 @@ async function sendImageMessage(base64Image, prompt) {
 let audioChunks = [];
 let lastAudioTime = 0;
 const SILENCE_THRESHOLD_MS = 1500; // 1.5 seconds of silence
+let silenceCheckTimer = null;
 
 async function processAudioChunk(base64Audio, mimeType) {
     if (!openaiClient) {
@@ -294,8 +295,20 @@ async function processAudioChunk(base64Audio, mimeType) {
     audioChunks.push(buffer);
     lastAudioTime = now;
 
-    // Check for silence (no new audio for SILENCE_THRESHOLD_MS)
-    // This is a simple approach - in production you'd want proper VAD
+    // Clear existing timer
+    if (silenceCheckTimer) {
+        clearTimeout(silenceCheckTimer);
+    }
+
+    // Set timer to check for silence
+    silenceCheckTimer = setTimeout(async () => {
+        const silenceDuration = Date.now() - lastAudioTime;
+        if (silenceDuration >= SILENCE_THRESHOLD_MS && audioChunks.length > 0) {
+            console.log('Silence detected, flushing audio for transcription...');
+            await flushAudioAndTranscribe();
+        }
+    }, SILENCE_THRESHOLD_MS);
+
     return { success: true, buffering: true };
 }
 

src/utils/renderer.js

@@ -294,9 +294,20 @@ async function startCapture(screenshotIntervalSeconds = 5, imageQuality = 'mediu
 
             console.log('Linux capture started - system audio:', mediaStream.getAudioTracks().length > 0, 'microphone mode:', audioMode);
         } else {
-            // Windows - use display media with loopback for system audio
+            // Windows - show custom screen picker first
             logToMain('info', '=== Starting Windows audio capture ===');
-            cheatingDaddy.setStatus('Requesting screen & audio...');
+            cheatingDaddy.setStatus('Choose screen to share...');
+            
+            // Show screen picker dialog
+            const appElement = document.querySelector('cheating-daddy-app');
+            const pickerResult = await appElement.showScreenPickerDialog();
+            
+            if (pickerResult.cancelled) {
+                cheatingDaddy.setStatus('Cancelled');
+                return;
+            }
+            
+            cheatingDaddy.setStatus('Starting capture...');
             
             mediaStream = await navigator.mediaDevices.getDisplayMedia({
                 video: {

src/utils/window.js

@@ -34,90 +34,54 @@ function createWindow(sendToRenderer, geminiSessionRef) {
 
     const { session, desktopCapturer } = require('electron');
     
-    // Setup display media request handler for screen capture
+    // Store selected source for Windows custom picker
+    let selectedSourceId = null;
+    
+    // Setup display media handler based on platform
     if (process.platform === 'darwin') {
-        // On macOS, use SystemAudioDump for audio (not browser loopback)
-        // So we just need to capture the screen
+        // macOS: Use native system picker
         session.defaultSession.setDisplayMediaRequestHandler(
-            async (request, callback) => {
-                try {
-                    const sources = await desktopCapturer.getSources({ 
-                        types: ['screen'],
-                        thumbnailSize: { width: 0, height: 0 } // Skip thumbnail generation for speed
-                    });
-                    
-                    if (sources.length === 0) {
-                        console.error('No screen sources available');
-                        callback(null);
-                        return;
-                    }
-                    
-                    // On macOS, directly use the first screen (system already granted permission)
-                    // Audio is handled separately by SystemAudioDump
-                    console.log('Screen capture source:', sources[0].name);
+            (request, callback) => {
+                desktopCapturer.getSources({ types: ['screen'] }).then(sources => {
                     callback({ video: sources[0], audio: 'loopback' });
-                } catch (error) {
-                    console.error('Error getting screen sources:', error);
-                    callback(null);
-                }
+                });
             },
-            { useSystemPicker: false } // Disable system picker, use our source directly
-        );
-    } else if (process.platform === 'win32') {
-        // On Windows, use desktopCapturer with loopback audio
-        // This captures system audio via WASAPI without needing user interaction
-        session.defaultSession.setDisplayMediaRequestHandler(
-            async (request, callback) => {
-                try {
-                    console.log('Windows: Getting screen sources with loopback audio...');
-                    const sources = await desktopCapturer.getSources({ 
-                        types: ['screen'],
-                        thumbnailSize: { width: 0, height: 0 }
-                    });
-                    
-                    if (sources.length === 0) {
-                        console.error('No screen sources available on Windows');
-                        callback(null);
-                        return;
-                    }
-                    
-                    console.log('Windows: Using screen source:', sources[0].name, 'with loopback audio');
-                    // 'loopback' enables system audio capture via WASAPI on Windows
-                    callback({ video: sources[0], audio: 'loopback' });
-                } catch (error) {
-                    console.error('Error getting screen sources on Windows:', error);
-                    callback(null);
-                }
-            },
-            { useSystemPicker: false }
+            { useSystemPicker: true }
         );
     } else {
-        // On Linux, try to get system audio via loopback
-        session.defaultSession.setDisplayMediaRequestHandler(
-            async (request, callback) => {
-                try {
-                    const sources = await desktopCapturer.getSources({ 
-                        types: ['screen'],
-                        thumbnailSize: { width: 0, height: 0 }
-                    });
-                    
-                    if (sources.length === 0) {
-                        console.error('No screen sources available');
-                        callback(null);
-                        return;
-                    }
-                    
-                    console.log('Linux: Using screen source with loopback audio');
-                    callback({ video: sources[0], audio: 'loopback' });
-                } catch (error) {
-                    console.error('Error getting screen sources:', error);
-                    callback(null);
+        // Windows/Linux: Use selected source from custom picker
+        session.defaultSession.setDisplayMediaRequestHandler(async (request, callback) => {
+            try {
+                const sources = await desktopCapturer.getSources({
+                    types: ['screen', 'window'],
+                    thumbnailSize: { width: 0, height: 0 },
+                });
+
+                // Find the selected source or use first screen
+                let source = sources[0];
+                if (selectedSourceId) {
+                    const found = sources.find(s => s.id === selectedSourceId);
+                    if (found) source = found;
                 }
-            },
-            { useSystemPicker: false }
-        );
+
+                if (source) {
+                    callback({ video: source, audio: 'loopback' });
+                } else {
+                    callback({});
+                }
+            } catch (error) {
+                console.error('Error in display media handler:', error);
+                callback({});
+            }
+        });
     }
 
+    // IPC handler to set selected source
+    ipcMain.handle('set-selected-source', async (event, sourceId) => {
+        selectedSourceId = sourceId;
+        return { success: true };
+    });
+
     mainWindow.setResizable(false);
     mainWindow.setContentProtection(true);
     mainWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
@@ -791,6 +755,29 @@ function setupWindowIpcHandlers(mainWindow, sendToRenderer, geminiSessionRef) {
             return { success: false, error: error.message };
         }
     });
+
+    // Get available screen sources for picker
+    ipcMain.handle('get-screen-sources', async () => {
+        try {
+            const { desktopCapturer } = require('electron');
+            const sources = await desktopCapturer.getSources({
+                types: ['screen', 'window'],
+                thumbnailSize: { width: 150, height: 150 },
+            });
+
+            return {
+                success: true,
+                sources: sources.map(source => ({
+                    id: source.id,
+                    name: source.name,
+                    thumbnail: source.thumbnail.toDataURL(),
+                })),
+            };
+        } catch (error) {
+            console.error('Error getting screen sources:', error);
+            return { success: false, error: error.message };
+        }
+    });
 }
 
 module.exports = {