Fixed alot of stuff and added the github actions

Author: BarricadeBandit

.github/workflows/build.yml

@@ -0,0 +1,59 @@
+name: Build
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  workflow_dispatch:
+
+jobs:
+  build:
+    name: Build on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [windows-latest, ubuntu-latest, macos-latest]
+
+    steps:
+      - name: Check out Git repository
+        uses: actions/checkout@v4
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Build TypeScript
+        run: npm run build
+
+      - name: Build & Release (Windows)
+        if: runner.os == 'Windows'
+        run: npm run package:win -- -p always
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build & Release (macOS)
+        if: runner.os == 'macOS'
+        run: npm run package:mac -- -p always
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build & Release (Linux)
+        if: runner.os == 'Linux'
+        run: npm run package:linux -- -p always
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: OctoBrowser-${{ runner.os }}
+          path: |
+            release/*.exe
+            release/*.dmg
+            release/*.AppImage

assets/github-copilot-icon.svg

@@ -31,6 +31,7 @@ export interface BrowserToolCallbacks {
     searchInPage: (text: string) => Promise<{ found: boolean; matches: string[] }>;
     getVisualDescription: () => Promise<string>;
     saveScreenshotToFile: () => Promise<string | null>;
+    pressKey: (key: string) => Promise<boolean>;
 }
 
 // Wrap tool handlers with timeout
@@ -76,6 +77,7 @@ export class CopilotService {
     private onToolResult: ((toolName: string, result: string) => void) | null = null;
     private sessionErrorCount: number = 0;
     private readonly MAX_SESSION_ERRORS = 3;
+    private activeStreamCleanup: (() => void) | null = null;
 
     async initialize(): Promise<boolean> {
         try {
@@ -199,6 +201,10 @@ If you've opened multiple tabs trying to find something please close the old unu
 - **YouTube Videos**: YouTube videos automatically play when opened, theres no need to click play.
 - **Tab management**: If you have more than 2 tabs open, close any that are not needed using browser_close_tabs to keep your workspace tidy. Make sure to not continue opening new tabs without closing old ones. and dont close the active tab unless instructed. and dont close tabs opened by the user. Make sure after completing a task to list open tabs using browser_get_open_tabs and close any unneeded ones.
 </best_practices>
+
+<never_do>
+Never use any tools or take any actions outside of the provided browser tools. You ARE a BROWSER AUTOMATION AGENT.
+</never_do>
 `,
             },
         });
@@ -474,6 +480,32 @@ If you've opened multiple tabs trying to find something please close the old unu
                     }
                 },
             }),
+            defineToolFn('browser_press_key', {
+                description: 'Press a specific key or key combination (e.g., "Enter", "Tab", "ArrowDown", "Control+C"). Use this for navigation, shortcuts, or submitting forms without a submit button.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        key: {
+                            type: 'string',
+                            description: 'The key or combination to press (e.g. "Enter", "a", "Control+a")',
+                        },
+                    },
+                    required: ['key'],
+                },
+                handler: async (args: { key: string }) => {
+                    if (!callbacks || !callbacks.pressKey) return 'Press key capability not available';
+                    try {
+                        const success = await withTimeout(callbacks.pressKey(args.key), 5000);
+                        const msg = success ? `Pressed key: "${args.key}"` : `Failed to press key: "${args.key}"`;
+                        reportResult('browser_press_key', msg);
+                        return msg;
+                    } catch (error: any) {
+                        const msg = `Failed to press key: ${error.message || 'unknown error'}`;
+                        reportResult('browser_press_key', msg);
+                        return msg;
+                    }
+                },
+            }),
             defineToolFn('browser_find_in_page', {
                 description: 'Find and highlight text on the current page.',
                 parameters: {
@@ -885,6 +917,12 @@ If you've opened multiple tabs trying to find something please close the old unu
             throw new Error('Session not created');
         }
 
+        // Ensure any previous stream is cleaned up to prevent duplicate listeners
+        if (this.activeStreamCleanup) {
+            console.log('Cleaning up previous active stream before starting new one');
+            this.activeStreamCleanup();
+        }
+
         this.conversationHistory.push({ role: 'user', content: message });
 
         return new Promise((resolve, reject) => {
@@ -936,6 +974,14 @@ If you've opened multiple tabs trying to find something please close the old unu
                     idleTimeout = null;
                 }
                 this.onToolResult = null;
+                this.activeStreamCleanup = null;
+            };
+
+            // Register global cleanup for abort/new stream
+            this.activeStreamCleanup = () => {
+                cleanup();
+                // Resolve with partial content if aborted/interrupted
+                resolve(fullContent);
             };
 
             // Set up tool result listener to capture exact output from handlers
@@ -1109,7 +1155,32 @@ If you've opened multiple tabs trying to find something please close the old unu
         this.conversationHistory = [];
     }
 
+    async resetSession(): Promise<void> {
+        // Clear conversation history
+        this.conversationHistory = [];
+        
+        // Destroy existing session and create a fresh one
+        if (this.session) {
+            try {
+                await this.session.destroy();
+            } catch (e) {
+                // Ignore session cleanup errors
+            }
+            this.session = null;
+        }
+        
+        // Create a fresh session
+        await this.createSession();
+        console.log('Copilot session reset - context cleared');
+    }
+
     async abort(): Promise<void> {
+        // First cleanup any active stream listeners
+        if (this.activeStreamCleanup) {
+            console.log('Aborting active stream listener...');
+            this.activeStreamCleanup();
+        }
+
         if (this.session) {
             try {
                 await this.session.abort();

src/main/copilot-service.ts

@@ -125,6 +125,9 @@ function setupIpcHandlers() {
                 takeScreenshot: async () => {
                     return tabManager?.takeScreenshot() || null;
                 },
+                pressKey: async (key) => {
+                    return tabManager?.pressKey(key) || false;
+                },
             });
         }
         return copilotService.initialize();
@@ -227,7 +230,19 @@ function createMenu() {
                 { type: 'separator' },
                 { role: 'togglefullscreen' },
                 { type: 'separator' },
-                { role: 'toggleDevTools' }
+                { 
+                    label: 'Toggle Developer Tools',
+                    accelerator: 'F12',
+                    click: () => mainWindow?.webContents.toggleDevTools()
+                },
+                { type: 'separator' },
+                {
+                    label: 'Toggle Sidebar',
+                    accelerator: 'Ctrl+Shift+I',
+                    click: () => {
+                        mainWindow?.webContents.send('sidebar:toggle');
+                    }
+                }
             ]
         },
         {

src/main/main.js

@@ -58,6 +58,14 @@ function createMainWindow(): BrowserWindow {
         // Dev tools disabled by default - use Ctrl+Shift+I or View menu
     });
 
+    // Listen for window state changes
+    mainWindow.on('maximize', () => {
+        mainWindow?.webContents.send('window:state-changed', { isMaximized: true });
+    });
+    mainWindow.on('unmaximize', () => {
+        mainWindow?.webContents.send('window:state-changed', { isMaximized: false });
+    });
+
     // Save window bounds on close
     mainWindow.on('close', () => {
         if (mainWindow) {
@@ -223,6 +231,9 @@ function setupIpcHandlers(): void {
                 saveScreenshotToFile: async () => {
                     return tabManager?.saveScreenshotToFile() || null;
                 },
+                pressKey: async (key: string) => {
+                    return tabManager?.pressKey(key) || false;
+                },
             });
         }
         return copilotService.initialize();
@@ -275,6 +286,11 @@ function setupIpcHandlers(): void {
         copilotService?.abort();
     });
 
+    ipcMain.handle('copilot:resetSession', async () => {
+        await copilotService?.resetSession();
+        return true;
+    });
+
     // Settings
     ipcMain.handle('settings:get', (_event, key: string) => settingsStore.get(key));
     ipcMain.handle('settings:set', (_event, key: string, value: unknown) => {
@@ -405,7 +421,19 @@ function createMenu(): void {
                 { type: 'separator' },
                 { role: 'togglefullscreen' },
                 { type: 'separator' },
-                { role: 'toggleDevTools' }
+                { 
+                    label: 'Toggle Developer Tools',
+                    accelerator: 'F12',
+                    click: () => mainWindow?.webContents.toggleDevTools()
+                },
+                { type: 'separator' },
+                {
+                    label: 'Toggle Sidebar',
+                    accelerator: 'Ctrl+Shift+I',
+                    click: () => {
+                        mainWindow?.webContents.send('sidebar:toggle');
+                    }
+                }
             ]
         },
         {

src/main/main.ts

@@ -1119,4 +1119,66 @@ export class TabManager {
             return null;
         }
     }
+
+    async pressKey(key: string): Promise<boolean> {
+        if (!this.activeTabId) return false;
+        
+        const view = this.tabs.get(this.activeTabId);
+        if (!view) return false;
+
+        try {
+            // Parse modifiers (e.g. "Control+Shift+A")
+            const parts = key.split('+');
+            let inputKey = parts.pop() || ''; // The last part is the key
+            const modifiers: string[] = [];
+            
+            parts.forEach(part => {
+                const p = part.toLowerCase().trim();
+                if (['ctrl', 'control'].includes(p)) modifiers.push('control');
+                if (['shift'].includes(p)) modifiers.push('shift');
+                if (['alt', 'option'].includes(p)) modifiers.push('alt');
+                if (['meta', 'cmd', 'command', 'super'].includes(p)) modifiers.push('meta'); // 'meta' is Command on Mac
+            });
+
+            // Map common keys to Electron accelerator format
+            const keyMap: {[key: string]: string} = {
+                 'arrowdown': 'Down', 'down': 'Down',
+                 'arrowup': 'Up', 'up': 'Up',
+                 'arrowleft': 'Left', 'left': 'Left',
+                 'arrowright': 'Right', 'right': 'Right',
+                 'enter': 'Enter', 'return': 'Enter',
+                 'tab': 'Tab',
+                 'space': 'Space',
+                 'backspace': 'Backspace',
+                 'delete': 'Delete',
+                 'escape': 'Escape', 'esc': 'Escape',
+                 'pagedown': 'PageDown', 'pgdn': 'PageDown',
+                 'pageup': 'PageUp', 'pgup': 'PageUp',
+                 'home': 'Home',
+                 'end': 'End',
+                 'insert': 'Insert'
+            };
+
+            const lowerKey = inputKey.toLowerCase();
+            const finalKeyCode = keyMap[lowerKey] || inputKey;
+            
+            // Send keyDown then keyUp with modifiers
+            view.webContents.sendInputEvent({ 
+                type: 'keyDown', 
+                keyCode: finalKeyCode,
+                modifiers: modifiers as any
+            });
+            
+            view.webContents.sendInputEvent({ 
+                type: 'keyUp', 
+                keyCode: finalKeyCode,
+                modifiers: modifiers as any
+            });
+            
+            return true;
+        } catch (error) {
+            console.error('Failed to press key:', error);
+            return false;
+        }
+    }
 }

src/main/tab-manager.ts

@@ -53,6 +53,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
     startStream: (message: string, model?: string) => 
         ipcRenderer.send('copilot:stream-start', message, model),
     abortStream: () => ipcRenderer.send('copilot:abort'),
+    resetSession: () => ipcRenderer.invoke('copilot:resetSession'),
     sendAnswer: (answers: any) => ipcRenderer.invoke('copilot:answer-user', answers),
 
     // Settings
@@ -110,6 +111,16 @@ contextBridge.exposeInMainWorld('electronAPI', {
         ipcRenderer.on('show:about', () => callback());
     },
 
+    // Sidebar Toggle Event
+    onSidebarToggle: (callback: () => void) => {
+        ipcRenderer.on('sidebar:toggle', () => callback());
+    },
+    
+    // Window State Event
+    onWindowStateChanged: (callback: (state: { isMaximized: boolean }) => void) => {
+        ipcRenderer.on('window:state-changed', (_event, state) => callback(state));
+    },
+    
     // Zero State Event
     onZeroStateChanged: (callback: (isZeroState: boolean) => void) => {
         ipcRenderer.on('tab:zero-state', (_event, isZeroState) => callback(isZeroState));
@@ -147,6 +158,7 @@ declare global {
             searchWeb: (query: string) => Promise<{ success: boolean; url: string }>;
             startStream: (message: string, model?: string) => void;
             abortStream: () => void;
+            resetSession: () => Promise<boolean>;
             sendAnswer: (answers: any) => Promise<boolean>;
             getSetting: (key: string) => Promise<unknown>;
             setSetting: (key: string, value: unknown) => Promise<boolean>;