desktop app fixed to new setup

Author: josancamon19

desktop_app/README.md

@@ -11,21 +11,42 @@ This folder contains a Tkinter-based desktop application that mirrors the origin
 2. Install project dependencies if you have not already:
    ```bash
    python -m pip install -r requirements.txt
-   playwright install
+   playwright install chromium
    ```
-3. Start the desktop app:
+3. Start the desktop app using the launch script (recommended):
    ```bash
-   python desktop_app/task_collector_app.py
+   ./desktop_app/launch_task_collector.sh
+   ```
+   
+   Or manually with the correct PYTHONPATH:
+   ```bash
+   cd /path/to/web-environments
+   source .venv/bin/activate
+   PYTHONPATH="$(pwd)/src:$(pwd):$PYTHONPATH" python desktop_app/task_collector_app.py
    ```
 
 The GUI will prompt for the same inputs as the CLI (source, task type, description). After clicking **Launch Task**, a Chromium browser starts recording. When the task is done, click **Complete Task** to close the browser and persist recordings/answers.
 
 ## Building a distributable bundle (PyInstaller)
 
-The simplest way to ship the app to volunteers is to package it with [PyInstaller](https://pyinstaller.org/). Run the following from the project root on the platform you're building for (Mac builds on macOS, Windows builds on Windows, etc.):
+The simplest way to ship the app to collectors is to package it with [PyInstaller](https://pyinstaller.org/). Run the following from the project root on the platform you're building for (Mac builds on macOS, Windows builds on Windows, etc.):
 
 ```bash
 python -m pip install pyinstaller
+python desktop_app/build_release.py --target macos  # or --target windows
+```
+
+This script automatically:
+- Installs Playwright browsers into the bundle
+- Configures all necessary hidden imports
+- Packages everything into a ready-to-distribute ZIP file
+- Includes installation instructions for end users
+
+The final ZIP will be created in `desktop_app/dist/` and can be shared directly with collaborators.
+
+Alternatively, you can build manually with PyInstaller:
+
+```bash
 pyinstaller desktop_app/task_collector_app.py \
   --name TaskCollector \
   --windowed \

desktop_app/build_release.py

@@ -132,19 +132,25 @@ def build_with_pyinstaller(
         "multiprocessing.connection",
         # Hidden imports for src modules
         "--hidden-import",
-        "src.config.storage_config",
+        "config.storage",
         "--hidden-import",
-        "src.config.browser_config",
+        "config.browser_config",
         "--hidden-import",
-        "src.config.initial_tasks",
+        "config.start",
         "--hidden-import",
-        "src.browser.stealth_browser",
+        "browser.browser",
         "--hidden-import",
-        "src.source_data.database",
+        "browser.recorder",
         "--hidden-import",
-        "src.tasks.task",
+        "db.database",
+        "--hidden-import",
+        "db.task",
+        "--hidden-import",
+        "db.models",
         "--hidden-import",
         "desktop_app.task_worker",
+        "--hidden-import",
+        "peewee",
         # Collect all submodules
         "--collect-all",
         "google.cloud",
@@ -159,6 +165,15 @@ def build_with_pyinstaller(
         # macOS specific
     ]
 
+    # Add optional imports if available
+    if module_importable("google.cloud._storage_v2"):
+        cmd.extend(["--hidden-import", "google.cloud._storage_v2"])
+
+    if module_importable("grpc"):
+        cmd.extend(["--hidden-import", "grpc", "--collect-all", "grpc"])
+        if module_importable("grpc._cython.cygrpc"):
+            cmd.extend(["--hidden-import", "grpc._cython.cygrpc"])
+
     if target == "macos":
         cmd.extend(
             [
@@ -302,10 +317,3 @@ def main() -> None:
     except BuildError as exc:
         print(f"ERROR: {exc}", file=sys.stderr)
         sys.exit(1)
-    if module_importable("google.cloud._storage_v2"):
-        cmd.extend(["--hidden-import", "google.cloud._storage_v2"])
-
-    if module_importable("grpc"):
-        cmd.extend(["--hidden-import", "grpc", "--collect-all", "grpc"])
-        if module_importable("grpc._cython.cygrpc"):
-            cmd.extend(["--hidden-import", "grpc._cython.cygrpc"])

desktop_app/launch_task_collector.sh

@@ -5,14 +5,14 @@
 cd "$(dirname "$0")/.."
 
 # Activate the virtual environment
-source venv/bin/activate
+source .venv/bin/activate
 
 # Set environment variables to prevent bus errors
 export DISPLAY=:0.0
 export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES
 export PYTHON_COREAUDIO_ALLOW_INSECURE_REQUESTS=1
-# Set Python path to include the project root
-export PYTHONPATH="$(pwd):$PYTHONPATH"
+# Set Python path to include the project root and src directory
+export PYTHONPATH="$(pwd)/src:$(pwd):$PYTHONPATH"
 echo "PYTHONPATH: $PYTHONPATH"
 
 # Set Playwright browsers path

desktop_app/task_worker.py

@@ -8,8 +8,10 @@
 from typing import Any, Dict, Optional
 
 from browser.browser import StealthBrowser
+from browser.recorder import get_video_path
 from config.start import InitialTasks
-from src.db.task import CreateTaskDto, Task, TaskManager
+from db.task import CreateTaskDto, TaskManager
+from db.models import TaskModel
 
 logger = logging.getLogger(__name__)
 
@@ -53,8 +55,9 @@ async def runner() -> None:
             task_manager = TaskManager.get_instance()
             new_task = CreateTaskDto(description, task_type, source, website)
             task_id = task_manager.create_task(new_task)
-            task = Task(task_id, description, task_type, source, website)
-            task_manager.set_current_task(task)
+            # Get the task we just created
+            task_model = TaskModel.get_by_id(task_id)
+            task_manager.set_current_task(task_model)
             _send_safe(pipe, {"type": "task_started", "task_id": task_id})
             _send_safe(
                 pipe,
@@ -90,7 +93,7 @@ async def runner() -> None:
         finally:
             try:
                 if task_manager and answer_to_save is not None:
-                    task_manager.save_task_answer(answer_to_save)
+                    task_manager.set_current_task_answer(answer_to_save)
             except Exception as answer_error:  # pylint: disable=broad-except
                 logger.warning("Failed to persist task answer: %s", answer_error)
 
@@ -99,11 +102,9 @@ async def runner() -> None:
                     current_task = task_manager.get_current_task()
                     if current_task:
                         # Save video path to database
-                        import os
-                        from config.storage import VIDEOS_DIR
-
-                        video_path = os.path.join(VIDEOS_DIR, f"task_{current_task.id}")
-                        task_manager.set_current_task_video_path(video_path)
+                        task_manager.set_current_task_video_path(
+                            get_video_path(current_task.id)
+                        )
                     task_manager.end_current_task()
                     task_manager.set_current_task(None)  # type: ignore[arg-type]
             except Exception as mgr_error:  # pylint: disable=broad-except

src/browser/browser.py

@@ -83,6 +83,8 @@ async def console_handler(msg):
                 return
             if "Blocked script execution in" in text:
                 return
+            if "Failed to load resource: net::ERR_NAME_NOT_RESOLVED" in text:
+                return
             print(f"🌐 Browser console: {text}")
 
         self.page.on("console", console_handler)
@@ -211,7 +213,6 @@ async def launch_browser(self, task_id: int) -> BrowserContext:
 
         # TODO: collect env with further n steps depth, using replay to bypass auths sections
         # TODO: eval runs in parallel containers, or ran on kernel, hosting tunneled versions locally while it runs?
-        # TODO: Fix collection tool with new changes
         # TODO: websockets? like e.g. ChatGPT doesn't allow for collecting anything
 
         browser = await self.playwright.chromium.launch(

src/environments/launch.py

@@ -241,10 +241,12 @@ async def handle_routes_manually(self, route, request):
         # TODO: do we need to obsfucate in a more clever way?
         # - ?? Normalize JSON (remove volatile fields; sort keys) and hash; tolerate multipart boundary changes; ignore known nonce/timestamp params.
         # TODO: what if the request is sent twice, we'll be selecting the first one all the time.
+        # semhash matching URL at times if they vary?
 
         # TODO: this requires LM postprocessing selection of URL's to match or some dumb way for all POST? or smth
         # TODO: why when collecting, increasing/decreasing cart stuff fails
         # TODO: some assets in GET are also dynamic?, bunch of js/stylesheets are not found in HAR
+
         urls_to_ignore_post_data = {
             "https://www.amazon.com/ax/claim",
             "https://www.amazon.com/aaut/verify/ap",
@@ -292,7 +294,7 @@ async def handle_routes_manually(self, route, request):
             return
 
         logger.warning(
-            "⚠️ No matching HAR entry found for %s, aborting",
+            "⚠️  No matching HAR entry found for %s, aborting",
             request.url[:100] + "..." if len(request.url) > 100 else request.url,
         )
         await route.abort()