From cd70cb77962afc59603bfe503c9d73a28d54f718 Mon Sep 17 00:00:00 2001 From: FatihMakes Date: Sun, 19 Apr 2026 15:22:49 +0300 Subject: [PATCH] Add files via upload --- actions/browser_control.py | 1131 ++++++++++++++++++++++++---------- actions/code_helper.py | 14 - actions/computer_control.py | 741 +++++++++++----------- actions/computer_settings.py | 735 +++++++++++----------- actions/desktop.py | 505 ++++++++------- actions/dev_agent.py | 574 ++++++++++------- actions/file_controller.py | 459 ++++++++------ actions/flight_finder.py | 280 ++++----- actions/game_updater.py | 1048 +++++++++++++++++++++++++++++++ actions/open_app.py | 253 +++++--- actions/reminder.py | 450 ++++++++++---- actions/screen_processor.py | 558 +++++++++-------- actions/send_message.py | 365 ++++++----- actions/weather_report.py | 53 +- actions/web_search.py | 89 +-- actions/youtube_video.py | 344 ++++------- agent/error_handler.py | 1 - agent/executor.py | 8 +- agent/planner.py | 60 +- config/__init__.py | 17 + core/prompt.txt | 36 +- main.py | 919 +++++++++++++-------------- memory/config_manager.py | 8 - memory/memory_manager.py | 195 ++++-- readme.md | 88 ++- requirements.txt | Bin 229 -> 634 bytes ui.py | 414 +++++++++++-- 27 files changed, 5807 insertions(+), 3538 deletions(-) create mode 100644 actions/game_updater.py diff --git a/actions/browser_control.py b/actions/browser_control.py index 2cf9878..3e4a5fd 100644 --- a/actions/browser_control.py +++ b/actions/browser_control.py @@ -1,93 +1,235 @@ +""" +browser_control.py — JARVIS Browser Action Module +==================================================== +Desteklenen tarayıcılar : chrome, edge, firefox, opera, operagx, brave, vivaldi, safari (macOS) +Desteklenen platformlar : Windows · macOS · Linux + +Her tarayıcı için bağımsız _BrowserSession örneği tutulur. +"switch" action ile aktif tarayıcı değiştirilebilir. + +NOT: Tüm tarayıcılar kullanıcının gerçek profiliyle açılır (hesaplar, çerezler korunur). + Gizli/incognito mod kullanılmaz. +""" + +from __future__ import annotations + import asyncio -import threading import concurrent.futures +import os import platform import shutil import subprocess +import threading from pathlib import Path -from playwright.async_api import async_playwright, TimeoutError as PlaywrightTimeout +from typing import Optional + +from playwright.async_api import ( + async_playwright, + BrowserContext, + Page, + Playwright, + TimeoutError as PlaywrightTimeout, +) + +# ── Platform ────────────────────────────────────────────────────────────────── +_OS = platform.system() # "Windows" | "Darwin" | "Linux" + + +# ── URL normalizer ──────────────────────────────────────────────────────────── +def _normalize_url(url: str) -> str: + """ + Bare words like "instagram" → "https://instagram.com" + Domains like "instagram.com" → "https://instagram.com" + Full URLs pass through unchanged. + """ + url = url.strip() + if not url: + return "about:blank" + if "://" in url: + return url + # No dot at all → assume .com (e.g. "instagram" → "instagram.com") + if "." not in url: + url = url + ".com" + return "https://" + url + + +# ── User-Agent ──────────────────────────────────────────────────────────────── +def _user_agent() -> str: + if _OS == "Windows": + return ( + "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " + "AppleWebKit/537.36 (KHTML, like Gecko) " + "Chrome/124.0.0.0 Safari/537.36" + ) + if _OS == "Darwin": + return ( + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " + "AppleWebKit/537.36 (KHTML, like Gecko) " + "Chrome/124.0.0.0 Safari/537.36" + ) + return ( + "Mozilla/5.0 (X11; Linux x86_64) " + "AppleWebKit/537.36 (KHTML, like Gecko) " + "Chrome/124.0.0.0 Safari/537.36" + ) + + +# ── Gerçek kullanıcı profil dizini (tüm tarayıcılar) ───────────────────────── +def _real_profile_dir(browser: str) -> str: + home = Path.home() + local = os.environ.get("LOCALAPPDATA", "") + roam = os.environ.get("APPDATA", "") + + candidates: list[Path] = [] + + if _OS == "Windows": + m = { + "chrome": [Path(local) / "Google" / "Chrome" / "User Data"], + "edge": [Path(local) / "Microsoft" / "Edge" / "User Data"], + "brave": [Path(local) / "BraveSoftware" / "Brave-Browser" / "User Data"], + "vivaldi": [Path(local) / "Vivaldi" / "User Data"], + "opera": [Path(roam) / "Opera Software" / "Opera Stable", + Path(local) / "Opera Software" / "Opera Stable"], + "operagx": [Path(roam) / "Opera Software" / "Opera GX Stable", + Path(local) / "Opera Software" / "Opera GX Stable"], + } + candidates = m.get(browser, []) + + elif _OS == "Darwin": + lib = home / "Library" / "Application Support" + m = { + "chrome": [lib / "Google" / "Chrome"], + "edge": [lib / "Microsoft Edge"], + "brave": [lib / "BraveSoftware" / "Brave-Browser"], + "vivaldi": [lib / "Vivaldi"], + "opera": [lib / "com.operasoftware.Opera"], + "operagx": [lib / "com.operasoftware.OperaGX"], + } + candidates = m.get(browser, []) + + elif _OS == "Linux": + cfg = home / ".config" + m = { + "chrome": [cfg / "google-chrome", cfg / "chromium"], + "edge": [cfg / "microsoft-edge"], + "brave": [cfg / "BraveSoftware" / "Brave-Browser"], + "vivaldi": [cfg / "vivaldi"], + "opera": [cfg / "opera"], + "operagx": [cfg / "opera-gx"], + } + candidates = m.get(browser, []) + + for p in candidates: + if p.exists(): + print(f"[Browser] ✅ Real profile found for {browser}: {p}") + return str(p) + + fallback = home / ".jarvis_profiles" / browser + fallback.mkdir(parents=True, exist_ok=True) + print(f"[Browser] ⚠️ Real profile not found for {browser}, using: {fallback}") + return str(fallback) + + +# ── Firefox gerçek profil dizini ────────────────────────────────────────────── +def _firefox_profile_dir() -> Optional[str]: + home = Path.home() + + if _OS == "Windows": + base = Path(os.environ.get("APPDATA", "")) / "Mozilla" / "Firefox" + elif _OS == "Darwin": + base = home / "Library" / "Application Support" / "Firefox" + else: + base = home / ".mozilla" / "firefox" + + ini = base / "profiles.ini" + if not ini.exists(): + return None + + current: dict[str, str] = {} + default_path: Optional[str] = None + + for line in ini.read_text(encoding="utf-8", errors="ignore").splitlines(): + line = line.strip() + if line.startswith("["): + p = current.get("Path", "") + if p and current.get("Default") == "1": + is_rel = current.get("IsRelative", "1") == "1" + default_path = str(base / p) if is_rel else p + current = {} + elif "=" in line: + k, _, v = line.partition("=") + current[k.strip()] = v.strip() + + p = current.get("Path", "") + if p and current.get("Default") == "1": + is_rel = current.get("IsRelative", "1") == "1" + default_path = str(base / p) if is_rel else p + + if default_path and Path(default_path).exists(): + print(f"[Browser] Firefox real profile: {default_path}") + return default_path + return None + + +# ── Windows: Opera exe tespiti ──────────────────────────────────────────────── +def _find_opera_windows() -> Optional[str]: + local = os.environ.get("LOCALAPPDATA", "") + prog = os.environ.get("PROGRAMFILES", "") + prog86 = os.environ.get("PROGRAMFILES(X86)", "") + + candidates = [ + Path(local) / "Programs" / "Opera" / "opera.exe", + Path(local) / "Programs" / "Opera GX" / "opera.exe", + Path(prog) / "Opera" / "opera.exe", + Path(prog86) / "Opera" / "opera.exe", + ] + for p in candidates: + if p.exists(): + print(f"[Browser] Opera found at: {p}") + return str(p) -def _get_default_browser_id() -> str: - """Returns raw default browser identifier string for current OS.""" - system = platform.system() try: - if system == "Windows": - import winreg - key = winreg.OpenKey( - winreg.HKEY_CURRENT_USER, - r"Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice" - ) - prog_id = winreg.QueryValueEx(key, "ProgId")[0].lower() - winreg.CloseKey(key) - return prog_id - - elif system == "Darwin": - result = subprocess.run( - ["defaults", "read", - "com.apple.LaunchServices/com.apple.launchservices.secure", - "LSHandlers"], - capture_output=True, text=True, timeout=5 - ) - return result.stdout.lower() - - elif system == "Linux": - result = subprocess.run( - ["xdg-settings", "get", "default-web-browser"], - capture_output=True, text=True, timeout=5 - ) - return result.stdout.lower() - + import winreg + keys = [ + r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\opera.exe", + r"SOFTWARE\Clients\StartMenuInternet\OperaStable\shell\open\command", + r"SOFTWARE\Clients\StartMenuInternet\OperaGXStable\shell\open\command", + r"SOFTWARE\Clients\StartMenuInternet\opera\shell\open\command", + ] + for key_path in keys: + for hive in (winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER): + try: + k = winreg.OpenKey(hive, key_path) + val = winreg.QueryValue(k, None) + winreg.CloseKey(k) + exe = val.strip().strip('"').split('"')[0].split(" --")[0].strip() + if exe and Path(exe).exists(): + print(f"[Browser] Opera found via registry: {exe}") + return exe + except Exception: + continue except Exception: pass - return "" - -_BROWSER_BINARIES = { - "Windows": { - "opera": ["opera.exe"], - "brave": ["brave.exe"], - "vivaldi": ["vivaldi.exe"], - "chrome": ["chrome.exe"], - "firefox": ["firefox.exe"], - }, - "Darwin": { - "opera": ["opera"], - "brave": ["brave browser", "brave"], - "vivaldi": ["vivaldi"], - "chrome": ["google chrome", "google-chrome"], - "firefox": ["firefox"], - }, - "Linux": { - "opera": ["opera", "opera-stable"], - "brave": ["brave-browser", "brave"], - "vivaldi": ["vivaldi-stable", "vivaldi"], - "chrome": ["google-chrome", "google-chrome-stable", "chromium-browser", "chromium"], - "firefox": ["firefox"], - }, -} + return shutil.which("opera") or None -def _get_opera_executable() -> str | None: - if platform.system() != "Windows": - return None +# ── Genel exe arama (Windows registry) ─────────────────────────────────────── +def _find_exe_windows(prog_name: str) -> Optional[str]: try: import winreg - candidate_keys = [ - r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\opera.exe", - r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\launcher.exe", - r"SOFTWARE\Clients\StartMenuInternet\OperaStable\shell\open\command", - r"SOFTWARE\Clients\StartMenuInternet\OperaGXStable\shell\open\command", + paths_to_try = [ + rf"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\{prog_name}.exe", + rf"SOFTWARE\Clients\StartMenuInternet\{prog_name}\shell\open\command", ] - for key_path in candidate_keys: - for hive in [winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER]: + for key_path in paths_to_try: + for hive in (winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER): try: - key = winreg.OpenKey(hive, key_path) - val = winreg.QueryValue(key, None) - winreg.CloseKey(key) - # Strip quotes and args - exe = val.strip().strip('"').split('"')[0].split(" --")[0].strip() + k = winreg.OpenKey(hive, key_path) + val = winreg.QueryValue(k, None) + winreg.CloseKey(k) + exe = val.strip().strip('"').split('"')[0].split(" --")[0].strip() if exe and Path(exe).exists(): - print(f"[Browser] 🔍 Opera found via registry: {exe}") return exe except Exception: continue @@ -96,189 +238,410 @@ def _get_opera_executable() -> str | None: return None -def _find_browser_executable(prog_id: str) -> tuple: - system = platform.system() - os_bins = _BROWSER_BINARIES.get(system, {}) +# ── Tarayıcı tanım tablosu ──────────────────────────────────────────────────── +_BROWSER_SPECS: dict[str, dict] = { + "Windows": { + "chrome": {"engine": "chromium", "channel": "chrome", "bins": []}, + "edge": {"engine": "chromium", "channel": "msedge", "bins": []}, + "firefox": {"engine": "firefox", "channel": None, "bins": ["firefox.exe"]}, + "opera": {"engine": "chromium", "channel": None, "bins": ["opera.exe"], "special": "opera_windows"}, + "operagx": {"engine": "chromium", "channel": None, "bins": [], "special": "opera_windows"}, + "brave": {"engine": "chromium", "channel": None, "bins": ["brave.exe"]}, + "vivaldi": {"engine": "chromium", "channel": None, "bins": ["vivaldi.exe"]}, + "safari": None, + }, + "Darwin": { + "chrome": {"engine": "chromium", "channel": "chrome", "bins": []}, + "edge": {"engine": "chromium", "channel": "msedge", "bins": ["microsoft-edge"]}, + "firefox": {"engine": "firefox", "channel": None, "bins": ["firefox"]}, + "opera": {"engine": "chromium", "channel": None, "bins": ["opera"]}, + "operagx": {"engine": "chromium", "channel": None, "bins": ["opera"]}, + "brave": {"engine": "chromium", "channel": None, "bins": ["brave browser", "brave"]}, + "vivaldi": {"engine": "chromium", "channel": None, "bins": ["vivaldi"]}, + "safari": {"engine": "webkit", "channel": None, "bins": []}, + }, + "Linux": { + "chrome": {"engine": "chromium", "channel": None, + "bins": ["google-chrome", "google-chrome-stable", "chromium-browser", "chromium"]}, + "edge": {"engine": "chromium", "channel": None, + "bins": ["microsoft-edge", "microsoft-edge-stable"]}, + "firefox": {"engine": "firefox", "channel": None, "bins": ["firefox"]}, + "opera": {"engine": "chromium", "channel": None, "bins": ["opera", "opera-stable"]}, + "operagx": {"engine": "chromium", "channel": None, "bins": ["opera", "opera-stable"]}, + "brave": {"engine": "chromium", "channel": None, "bins": ["brave-browser", "brave"]}, + "vivaldi": {"engine": "chromium", "channel": None, "bins": ["vivaldi-stable", "vivaldi"]}, + "safari": None, + }, +} - if any(x in prog_id for x in ["firefox", "mozilla"]): - return "firefox", None, None - - if "safari" in prog_id: - return "webkit", None, None - - if "edge" in prog_id: - return "chromium", None, "msedge" - - if "opera" in prog_id: - exe = _get_opera_executable() - if exe: - return "chromium", exe, None - for binary in os_bins.get("opera", []): - path = shutil.which(binary) - if path: - return "chromium", path, None - - browser_patterns = { - "brave": ["brave"], - "vivaldi": ["vivaldi"], - "chrome": ["chrome"], - } - for browser_name, patterns in browser_patterns.items(): - if not any(p in prog_id for p in patterns): - continue - binaries = os_bins.get(browser_name, []) - for binary in binaries: - path = shutil.which(binary) - if path: - print(f"[Browser] 🔍 Found {browser_name} at: {path}") - return "chromium", path, None - - if "chrome" in prog_id or not prog_id: - return "chromium", None, "chrome" +_ALIASES: dict[str, str] = { + "google chrome": "chrome", + "google-chrome": "chrome", + "microsoft edge": "edge", + "ms edge": "edge", + "msedge": "edge", + "mozilla firefox": "firefox", + "opera gx": "operagx", + "opera_gx": "operagx", +} - return "chromium", None, None +def _resolve_browser(name: str) -> dict | None: + name = _ALIASES.get(name.lower().strip(), name.lower().strip()) + os_map = _BROWSER_SPECS.get(_OS, {}) + spec = os_map.get(name) + if spec is None: + return None + + engine = spec["engine"] + channel = spec.get("channel") + bins = spec.get("bins", []) + exe = None + + if spec.get("special") == "opera_windows": + exe = _find_opera_windows() + if not exe: + print(f"[Browser] ⚠️ Opera executable not found on Windows.") + return {"engine": engine, "exe": exe, "channel": channel} + + for b in bins: + found = shutil.which(b) + if found: + exe = found + break + + if not exe and _OS == "Darwin": + app_names = { + "chrome": ["Google Chrome.app"], + "edge": ["Microsoft Edge.app"], + "firefox": ["Firefox.app"], + "opera": ["Opera.app", "Opera GX.app"], + "brave": ["Brave Browser.app"], + "vivaldi": ["Vivaldi.app"], + } + for app in app_names.get(name, []): + app_dir = Path("/Applications") / app / "Contents" / "MacOS" + if app_dir.exists(): + found_bins = list(app_dir.iterdir()) + if found_bins: + exe = str(found_bins[0]) + break + + if not exe and _OS == "Windows" and not channel: + exe = _find_exe_windows(name) + + return {"engine": engine, "exe": exe, "channel": channel} -class _BrowserThread: +def _detect_default_browser() -> str: + try: + if _OS == "Windows": + import winreg + k = winreg.OpenKey( + winreg.HKEY_CURRENT_USER, + r"Software\Microsoft\Windows\Shell\Associations" + r"\UrlAssociations\http\UserChoice", + ) + prog_id = winreg.QueryValueEx(k, "ProgId")[0].lower() + winreg.CloseKey(k) + for kw in ("edge", "firefox", "opera", "brave", "vivaldi", "chrome"): + if kw in prog_id: + return kw + elif _OS == "Darwin": + out = subprocess.run( + ["defaults", "read", + "com.apple.LaunchServices/com.apple.launchservices.secure", + "LSHandlers"], + capture_output=True, text=True, timeout=5, + ).stdout.lower() + for kw in ("firefox", "opera", "brave", "vivaldi", "safari", "chrome", "edge"): + if kw in out: + return kw + elif _OS == "Linux": + out = subprocess.run( + ["xdg-settings", "get", "default-web-browser"], + capture_output=True, text=True, timeout=5, + ).stdout.lower() + for kw in ("firefox", "opera", "brave", "vivaldi", "chrome", "edge"): + if kw in out: + return kw + except Exception: + pass + return "chrome" - def __init__(self): - self._loop = None - self._thread = None - self._ready = threading.Event() - self._playwright = None - self._browser = None - self._context = None - self._page = None +# ── Tek tarayıcı oturumu ────────────────────────────────────────────────────── + +class _BrowserSession: + """ + Bir tarayıcı örneği için tam oturum. + Tüm tarayıcılar launch_persistent_context ile gerçek profil üzerinde açılır. + """ + + def __init__(self, browser_name: str): + self.browser_name = browser_name + self._spec = _resolve_browser(browser_name) + + self._loop: asyncio.AbstractEventLoop | None = None + self._thread: threading.Thread | None = None + self._ready = threading.Event() + + self._pw: Playwright | None = None + self._context: BrowserContext | None = None + self._page: Page | None = None + + # ── Yaşam döngüsü ───────────────────────────────────────────────────────── def start(self): if self._thread and self._thread.is_alive(): return self._thread = threading.Thread( - target=self._run_loop, daemon=True, name="BrowserThread" + target=self._run_loop, + daemon=True, + name=f"BrowserThread-{self.browser_name}", ) self._thread.start() - self._ready.wait(timeout=15) + self._ready.wait(timeout=20) def _run_loop(self): self._loop = asyncio.new_event_loop() asyncio.set_event_loop(self._loop) - self._loop.run_until_complete(self._init()) + self._loop.run_until_complete(self._async_init()) self._ready.set() self._loop.run_forever() - async def _init(self): - self._playwright = await async_playwright().start() + async def _async_init(self): + self._pw = await async_playwright().start() - def run(self, coro, timeout: int = 30): + def run(self, coro, timeout: int = 60) -> str: if not self._loop: - raise RuntimeError("BrowserThread not started.") + raise RuntimeError(f"Session for '{self.browser_name}' not started.") future = asyncio.run_coroutine_threadsafe(coro, self._loop) return future.result(timeout=timeout) - - async def _get_page(self): - if self._page is None or self._page.is_closed(): - await self._launch() - return self._page + + def close(self): + if self._loop: + asyncio.run_coroutine_threadsafe(self._async_close(), self._loop).result(10) + + async def _async_close(self): + if self._context: + try: + await self._context.close() + except Exception: + pass + if self._pw: + try: + await self._pw.stop() + except Exception: + pass + self._context = self._page = None + + # ── Tarayıcı başlatma ────────────────────────────────────────────────────── async def _launch(self): - prog_id = _get_default_browser_id() - engine_name, exe_path, channel = _find_browser_executable(prog_id) - engine = getattr(self._playwright, engine_name) + """ + Tarayıcıyı gerçek kullanıcı profiliyle başlatır. + Context zaten açıksa hiçbir şey yapmaz. + """ + if self._context is not None: + return - launch_kwargs = {"headless": False} - - if engine_name == "chromium": - launch_kwargs["args"] = ["--start-maximized"] - - if exe_path: - launch_kwargs["executable_path"] = exe_path - elif channel: - launch_kwargs["channel"] = channel - - try: - if self._browser is None or not self._browser.is_connected(): - self._browser = await engine.launch(**launch_kwargs) - print( - f"[Browser] ✅ Launched ({engine_name}" - f"{' / ' + channel if channel else ''}" - f"{' / ' + exe_path if exe_path else ''})" - ) - except Exception as e: - print(f"[Browser] ⚠️ Launch failed ({e}), falling back to built-in Chromium") - self._browser = await self._playwright.chromium.launch( - headless=False, - args=["--start-maximized"] + if self._spec is None: + raise RuntimeError( + f"'{self.browser_name}' bu platformda ({_OS}) desteklenmiyor." ) - self._context = await self._browser.new_context( - viewport=None, - user_agent=( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/120.0.0.0 Safari/537.36" + engine_name = self._spec["engine"] + exe = self._spec["exe"] + channel = self._spec["channel"] + engine_obj = getattr(self._pw, engine_name) + + # ── Firefox ─────────────────────────────────────────────────────────── + if engine_name == "firefox": + profile = _firefox_profile_dir() or str( + Path.home() / ".jarvis_profiles" / "firefox" ) - ) - self._page = await self._context.new_page() + kwargs: dict = { + "headless": False, + "slow_mo": 0, + "viewport": None, + "no_viewport": True, + } + if exe: + kwargs["executable_path"] = exe + try: + self._context = await engine_obj.launch_persistent_context(profile, **kwargs) + except Exception as e: + print(f"[Browser] Firefox real profile failed ({e}), using JARVIS profile") + jarvis = str(Path.home() / ".jarvis_profiles" / "firefox_jarvis") + Path(jarvis).mkdir(parents=True, exist_ok=True) + self._context = await engine_obj.launch_persistent_context(jarvis, **kwargs) - async def _close(self): - if self._browser: - await self._browser.close() - self._browser = None - self._page = None - if self._playwright: - await self._playwright.stop() - self._playwright = None + await asyncio.sleep(0.5) # let the browser settle + # Always open a dedicated JARVIS tab instead of grabbing pages[0], + # which may already be about:blank or a stale restored tab. + self._page = await self._context.new_page() + print(f"[Browser] ✅ Firefox launched") + return - async def _go_to(self, url: str) -> str: - if not url.startswith("http"): - url = "https://" + url - page = await self._get_page() - try: - await page.goto(url, wait_until="domcontentloaded", timeout=15000) - return f"Opened: {page.url}" - except PlaywrightTimeout: - return f"Timeout loading: {url}" - except Exception as e: - return f"Navigation error: {e}" + # ── Safari (webkit) ─────────────────────────────────────────────────── + if engine_name == "webkit": + safari_profile = str(Path.home() / ".jarvis_profiles" / "safari") + Path(safari_profile).mkdir(parents=True, exist_ok=True) + kwargs = { + "headless": False, + "slow_mo": 0, + "viewport": None, + "no_viewport": True, + } + self._context = await engine_obj.launch_persistent_context(safari_profile, **kwargs) + await asyncio.sleep(0.5) + self._page = await self._context.new_page() + print(f"[Browser] ✅ Safari launched") + return - async def _search(self, query: str, engine: str = "google") -> str: - engines = { - "google": f"https://www.google.com/search?q={query.replace(' ', '+')}", - "bing": f"https://www.bing.com/search?q={query.replace(' ', '+')}", - "duckduckgo": f"https://duckduckgo.com/?q={query.replace(' ', '+')}", + # ── Chromium tabanlı ────────────────────────────────────────────────── + profile = _real_profile_dir(self.browser_name) + + kwargs = { + "headless": False, + "slow_mo": 0, + "viewport": None, + "no_viewport": True, + "args": [ + "--start-maximized", + "--disable-blink-features=AutomationControlled", + "--no-first-run", + "--disable-default-apps", + "--no-default-browser-check", + ], } - url = engines.get(engine.lower(), engines["google"]) - return await self._go_to(url) - async def _click(self, selector=None, text=None) -> str: + if exe: + kwargs["executable_path"] = exe + elif channel: + kwargs["channel"] = channel + + label = ( + f"{self.browser_name}" + + (f"/{channel}" if channel else "") + + (f" @ {exe}" if exe else "") + ) + + # 1) Gerçek profil + try: + self._context = await engine_obj.launch_persistent_context(profile, **kwargs) + await asyncio.sleep(0.5) # let the browser settle before any navigation + self._page = await self._context.new_page() + print(f"[Browser] ✅ Launched [{label}] profile={profile}") + return + except Exception as e: + print(f"[Browser] ⚠️ Real profile failed for {label}: {e}") + + # 2) JARVIS fallback profili + jarvis_profile = str(Path.home() / ".jarvis_profiles" / self.browser_name) + Path(jarvis_profile).mkdir(parents=True, exist_ok=True) + print(f"[Browser] Retrying with JARVIS profile: {jarvis_profile}") + + try: + self._context = await engine_obj.launch_persistent_context(jarvis_profile, **kwargs) + await asyncio.sleep(0.5) + self._page = await self._context.new_page() + print(f"[Browser] ✅ Launched [{label}] with JARVIS profile") + except Exception as e2: + raise RuntimeError(f"Could not launch {self.browser_name}: {e2}") from e2 + + # ── Sayfa erişimi ───────────────────────────────────────────────────────── + + async def _get_page(self) -> Page: + await self._launch() + # If somehow page got closed, open a fresh one + if self._page is None or self._page.is_closed(): + self._page = await self._context.new_page() + await asyncio.sleep(0.2) + return self._page + + # ── Action'lar ──────────────────────────────────────────────────────────── + + async def go_to(self, url: str) -> str: + """ + Navigate to a URL. + + • Uses a 30-second timeout to handle heavy sites like YouTube. + • On PlaywrightTimeout we check whether the URL actually changed; + if it did, treat it as success so JARVIS won't retry endlessly. + • If the page is still about:blank after navigation, open a fresh tab + and try once more (covers stale-page edge cases in Opera GX etc.). + """ + url = _normalize_url(url) + page = await self._get_page() + prev_url = page.url + + async def _do_goto(p: Page) -> str: + """Attempt navigation and return the resulting URL (may still be blank).""" + try: + await p.goto(url, wait_until="domcontentloaded", timeout=30_000) + await asyncio.sleep(0.3) + except PlaywrightTimeout: + pass # page may have partially loaded — check URL below + except Exception as e: + print(f"[Browser] goto exception (non-fatal): {e}") + return p.url + + result_url = await _do_goto(page) + + # If page didn't move away from blank, retry on a brand-new tab + if result_url in ("about:blank", "", None, prev_url) and prev_url in ("about:blank", "", None): + print(f"[Browser] Still blank after goto — retrying on new tab: {url}") + try: + new_page = await self._context.new_page() + self._page = new_page + result_url = await _do_goto(new_page) + except Exception as e: + print(f"[Browser] New-tab retry failed: {e}") + + if result_url and result_url not in ("about:blank", "", None): + return f"Opened: {result_url}" + return f"Could not open: {url}" + + async def search(self, query: str, engine: str = "google") -> str: + _engines = { + "google": "https://www.google.com/search?q=", + "bing": "https://www.bing.com/search?q=", + "duckduckgo": "https://duckduckgo.com/?q=", + "yandex": "https://yandex.com/search/?text=", + } + base = _engines.get(engine.lower(), _engines["google"]) + return await self.go_to(base + query.replace(" ", "+")) + + async def click(self, selector: str = None, text: str = None) -> str: page = await self._get_page() try: if text: - await page.get_by_text(text, exact=False).first.click(timeout=8000) - return f"Clicked: '{text}'" - elif selector: - await page.click(selector, timeout=8000) - return f"Clicked: {selector}" + await page.get_by_text(text, exact=False).first.click(timeout=8_000) + return f"Clicked text: '{text}'" + if selector: + await page.click(selector, timeout=8_000) + return f"Clicked selector: {selector}" return "No selector or text provided." except PlaywrightTimeout: - return "Element not found or not clickable." + return "Element not found (timeout)." except Exception as e: return f"Click error: {e}" - async def _type(self, selector=None, text: str = "", clear_first: bool = True) -> str: + async def type_text(self, selector: str = None, text: str = "", + clear_first: bool = True) -> str: page = await self._get_page() try: - element = page.locator(selector).first if selector else page.locator(":focus") + el = page.locator(selector).first if selector else page.locator(":focus") if clear_first: - await element.clear() - await element.type(text, delay=50) + await el.clear() + await el.type(text, delay=50) return "Text typed." except Exception as e: return f"Type error: {e}" - async def _scroll(self, direction: str = "down", amount: int = 500) -> str: + async def scroll(self, direction: str = "down", amount: int = 500) -> str: page = await self._get_page() try: y = amount if direction == "down" else -amount @@ -287,7 +650,7 @@ class _BrowserThread: except Exception as e: return f"Scroll error: {e}" - async def _press(self, key: str) -> str: + async def press(self, key: str) -> str: page = await self._get_page() try: await page.keyboard.press(key) @@ -295,15 +658,19 @@ class _BrowserThread: except Exception as e: return f"Key error: {e}" - async def _get_text(self) -> str: + async def get_text(self) -> str: page = await self._get_page() try: text = await page.inner_text("body") - return text[:4000] if len(text) > 4000 else text + return text[:4_000] except Exception as e: return f"Could not get page text: {e}" - async def _fill_form(self, fields: dict) -> str: + async def get_url(self) -> str: + page = await self._get_page() + return page.url + + async def fill_form(self, fields: dict) -> str: page = await self._get_page() results = [] for selector, value in fields.items(): @@ -316,161 +683,279 @@ class _BrowserThread: results.append(f"✗ {selector}: {e}") return "Form filled: " + ", ".join(results) - async def _smart_click(self, description: str) -> str: - page = await self._get_page() - desc_lower = description.lower() - - role_hints = { - "button": ["button", "buton", "btn"], - "link": ["link", "bağlantı"], - "searchbox": ["search", "arama"], - "textbox": ["input", "field", "alan"], - } - for role, keywords in role_hints.items(): - if any(k in desc_lower for k in keywords): - try: - await page.get_by_role(role).first.click(timeout=5000) - return f"Clicked ({role}): '{description}'" - except Exception: - pass - - try: - await page.get_by_text(description, exact=False).first.click(timeout=5000) - return f"Clicked (text): '{description}'" - except Exception: - pass - - try: - await page.get_by_placeholder(description, exact=False).first.click(timeout=5000) - return f"Clicked (placeholder): '{description}'" - except Exception: - pass - - return f"Could not find: '{description}'" - - async def _smart_type(self, description: str, text: str) -> str: + async def smart_click(self, description: str) -> str: page = await self._get_page() + for role in ("button", "link", "searchbox", "textbox", "menuitem", "tab"): + try: + loc = page.get_by_role(role, name=description) + if await loc.count() > 0: + await loc.first.click(timeout=5_000) + return f"Clicked ({role}): '{description}'" + except Exception: + pass + for attempt in ( + lambda: page.get_by_text(description, exact=False).first.click(timeout=5_000), + lambda: page.get_by_placeholder(description, exact=False).first.click(timeout=5_000), + lambda: page.locator( + f'[alt*="{description}" i],[title*="{description}" i],' + f'[aria-label*="{description}" i]' + ).first.click(timeout=5_000), + ): + try: + await attempt() + return f"Clicked: '{description}'" + except Exception: + pass + return f"Could not find element: '{description}'" - for method, locator in [ + async def smart_type(self, description: str, text: str) -> str: + page = await self._get_page() + candidates = [ ("placeholder", page.get_by_placeholder(description, exact=False)), ("label", page.get_by_label(description, exact=False)), - ("role", page.get_by_role("textbox")), - ]: + ("role", page.get_by_role("textbox", name=description)), + ("searchbox", page.get_by_role("searchbox")), + ("combobox", page.get_by_role("combobox", name=description)), + ] + for method, loc in candidates: try: - el = locator.first + el = loc.first + if await el.count() == 0: + continue await el.clear() await el.type(text, delay=50) return f"Typed into ({method}): '{description}'" except Exception: continue - return f"Could not find input: '{description}'" - async def _close_browser(self) -> str: - await self._close() - return "Browser closed." + async def new_tab(self, url: str = "") -> str: + page = await self._get_page() + ctx = page.context + new = await ctx.new_page() + self._page = new + if url: + return await self.go_to(url) + return "New tab opened." -_bt = _BrowserThread() -_bt_started = False -_bt_lock = threading.Lock() + async def close_tab(self) -> str: + page = self._page + if page and not page.is_closed(): + ctx = page.context + await page.close() + pages = ctx.pages + self._page = pages[-1] if pages else None + return "Tab closed." + return "No active tab to close." + + async def screenshot(self, path: str = None) -> str: + page = await self._get_page() + try: + save_path = path or str(Path.home() / "Desktop" / "jarvis_screenshot.png") + await page.screenshot(path=save_path, full_page=False) + return f"Screenshot saved: {save_path}" + except Exception as e: + return f"Screenshot error: {e}" + + async def back(self) -> str: + page = await self._get_page() + try: + await page.go_back(timeout=10_000) + return f"Navigated back: {page.url}" + except Exception as e: + return f"Back error: {e}" + + async def forward(self) -> str: + page = await self._get_page() + try: + await page.go_forward(timeout=10_000) + return f"Navigated forward: {page.url}" + except Exception as e: + return f"Forward error: {e}" + + async def reload(self) -> str: + page = await self._get_page() + try: + await page.reload(timeout=15_000) + return f"Page reloaded: {page.url}" + except Exception as e: + return f"Reload error: {e}" + + async def close_browser(self) -> str: + await self._async_close() + return f"{self.browser_name} closed." -def _ensure_started(): - global _bt_started - with _bt_lock: - if not _bt_started: - _bt.start() - _bt_started = True +# ── Session registry ────────────────────────────────────────────────────────── + +class _SessionRegistry: + """Tüm aktif tarayıcı oturumlarını yönetir.""" + + def __init__(self): + self._sessions: dict[str, _BrowserSession] = {} + self._active_browser: str = "" + self._lock = threading.Lock() + + def _get_or_create(self, browser_name: str) -> _BrowserSession: + with self._lock: + if browser_name not in self._sessions: + sess = _BrowserSession(browser_name) + sess.start() + self._sessions[browser_name] = sess + print(f"[Registry] New session: {browser_name}") + return self._sessions[browser_name] + + def get(self, browser_name: str | None = None) -> _BrowserSession: + if not browser_name: + browser_name = self._active_browser or _detect_default_browser() + browser_name = _ALIASES.get(browser_name.lower().strip(), browser_name.lower().strip()) + sess = self._get_or_create(browser_name) + self._active_browser = browser_name + return sess + + def switch(self, browser_name: str) -> str: + browser_name = _ALIASES.get(browser_name.lower().strip(), browser_name.lower().strip()) + self._get_or_create(browser_name) + self._active_browser = browser_name + return f"Active browser → {browser_name}" + + def close_one(self, browser_name: str) -> str: + with self._lock: + sess = self._sessions.pop(browser_name, None) + if sess: + sess.close() + if self._active_browser == browser_name: + self._active_browser = "" + return f"{browser_name} closed." + return f"No active session for: {browser_name}" + + def close_all(self) -> str: + with self._lock: + names = list(self._sessions.keys()) + sessions = list(self._sessions.values()) + self._sessions.clear() + self._active_browser = "" + for s in sessions: + try: + s.close() + except Exception: + pass + return "All browsers closed: " + (", ".join(names) if names else "none") + + def list_sessions(self) -> str: + with self._lock: + if not self._sessions: + return "No active browser sessions." + lines = [] + for name in self._sessions: + marker = " ◀ active" if name == self._active_browser else "" + lines.append(f" • {name}{marker}") + return "Open browsers:\n" + "\n".join(lines) + + +_registry = _SessionRegistry() + + +# ── Ana fonksiyon ───────────────────────────────────────────────────────────── def browser_control( - parameters: dict, + parameters: dict = None, response=None, player=None, - session_memory=None + session_memory=None, ) -> str: """ - Browser controller — auto-detects and uses system default browser. + Desteklenen action'lar: + go_to, search, click, type, scroll, fill_form, + smart_click, smart_type, get_text, get_url, press, + new_tab, close_tab, screenshot, back, forward, reload, + switch, list_browsers, close, close_all - parameters: - action : go_to | search | click | type | scroll | fill_form | - smart_click | smart_type | get_text | press | close - url : URL for go_to - query : search query - engine : google | bing | duckduckgo (default: google) - selector : CSS selector for click/type - text : text to click or type - description : element description for smart_click/smart_type - direction : up | down for scroll - amount : scroll amount in pixels (default: 500) - key : key name for press (e.g. Enter, Escape, Tab) - fields : {selector: value} dict for fill_form - clear_first : bool, clear input before typing (default: True) + Parametre: + browser : chrome | edge | firefox | opera | operagx | brave | vivaldi | safari + (belirtilmezse aktif tarayıcı kullanılır) """ - _ensure_started() + params = parameters or {} + action = params.get("action", "").lower().strip() + browser = params.get("browser", "").lower().strip() or None + result = "Unknown action." - action = (parameters or {}).get("action", "").lower().strip() - result = "Unknown action." + if action == "switch": + target = browser or params.get("target", "").lower().strip() + result = _registry.switch(target) if target else "Please specify a browser." + _log(player, result) + return result + + if action == "list_browsers": + result = _registry.list_sessions() + _log(player, result) + return result + + if action == "close_all": + result = _registry.close_all() + _log(player, result) + return result + + try: + sess = _registry.get(browser) + except Exception as e: + result = f"Could not start browser session: {e}" + _log(player, result) + return result try: if action == "go_to": - result = _bt.run(_bt._go_to(parameters.get("url", ""))) - + result = sess.run(sess.go_to(params.get("url", ""))) elif action == "search": - result = _bt.run(_bt._search( - parameters.get("query", ""), - parameters.get("engine", "google") - )) - + result = sess.run(sess.search(params.get("query", ""), params.get("engine", "google"))) elif action == "click": - result = _bt.run(_bt._click( - selector=parameters.get("selector"), - text=parameters.get("text") - )) - + result = sess.run(sess.click(params.get("selector"), params.get("text"))) elif action == "type": - result = _bt.run(_bt._type( - selector=parameters.get("selector"), - text=parameters.get("text", ""), - clear_first=parameters.get("clear_first", True) - )) - + result = sess.run(sess.type_text( + params.get("selector"), params.get("text", ""), params.get("clear_first", True))) elif action == "scroll": - result = _bt.run(_bt._scroll( - direction=parameters.get("direction", "down"), - amount=parameters.get("amount", 500) - )) - + result = sess.run(sess.scroll(params.get("direction", "down"), int(params.get("amount", 500)))) elif action == "fill_form": - result = _bt.run(_bt._fill_form(parameters.get("fields", {}))) - + result = sess.run(sess.fill_form(params.get("fields", {}))) elif action == "smart_click": - result = _bt.run(_bt._smart_click(parameters.get("description", ""))) - + result = sess.run(sess.smart_click(params.get("description", ""))) elif action == "smart_type": - result = _bt.run(_bt._smart_type( - parameters.get("description", ""), - parameters.get("text", "") - )) - + result = sess.run(sess.smart_type(params.get("description", ""), params.get("text", ""))) elif action == "get_text": - result = _bt.run(_bt._get_text()) - + result = sess.run(sess.get_text()) + elif action == "get_url": + result = sess.run(sess.get_url()) elif action == "press": - result = _bt.run(_bt._press(parameters.get("key", "Enter"))) - + result = sess.run(sess.press(params.get("key", "Enter"))) + elif action == "new_tab": + result = sess.run(sess.new_tab(params.get("url", ""))) + elif action == "close_tab": + result = sess.run(sess.close_tab()) + elif action == "screenshot": + result = sess.run(sess.screenshot(params.get("path"))) + elif action == "back": + result = sess.run(sess.back()) + elif action == "forward": + result = sess.run(sess.forward()) + elif action == "reload": + result = sess.run(sess.reload()) elif action == "close": - result = _bt.run(_bt._close_browser()) - + target = browser or _registry._active_browser + result = _registry.close_one(target) if target else "No browser specified." else: - result = f"Unknown action: {action}" + result = f"Unknown browser action: '{action}'" except concurrent.futures.TimeoutError: - result = "Browser action timed out." + result = f"Browser action '{action}' timed out (60s)." except Exception as e: - result = f"Browser error: {e}" + result = f"Browser error ({action}): {e}" - print(f"[Browser] {result[:80]}") + _log(player, result) + return result + + +def _log(player, text: str): + short = str(text)[:80] + print(f"[Browser] {short}") if player: - player.write_log(f"[browser] {result[:60]}") - - return result \ No newline at end of file + player.write_log(f"[browser] {short[:60]}") \ No newline at end of file diff --git a/actions/code_helper.py b/actions/code_helper.py index 7247aa1..c163537 100644 --- a/actions/code_helper.py +++ b/actions/code_helper.py @@ -1,16 +1,3 @@ -# actions/code_helper.py -# AI-powered code assistant — writes, edits, explains, runs, builds, debugs, and optimizes code. -# -# Actions: -# write → Describe what you want, Gemini writes it, saves to file -# edit → Read existing file, apply natural language change -# explain → Explain what a piece of code or file does -# run → Execute a script file, return output -# build → Write → Run → Fix loop (max 3 attempts), speaks when done -# screen_debug → Screenshot al, ekrandaki kodu/hatayı Gemini ile analiz et ve düzelt -# optimize → Mevcut kodu Gemini ile optimize et (performans, okunabilirlik, best practices) -# auto → (default) Intent auto-detected from context - import subprocess import sys import json @@ -126,7 +113,6 @@ def _detect_intent(description: str, file_path: str, code: str) -> str: if any(k in desc for k in screen_kw): return "screen_debug" - # Optimize keywords optimize_kw = ["optimize", "refactor", "clean up", "improve", "temizle", "iyileştir", "daha iyi", "make it better", "hızlandır"] if any(k in desc for k in optimize_kw) and (code or file_path): diff --git a/actions/computer_control.py b/actions/computer_control.py index 90db975..30cb072 100644 --- a/actions/computer_control.py +++ b/actions/computer_control.py @@ -1,29 +1,11 @@ -# actions/computer_control.py -# MARK XXV — Computer Control -# -# Atomic computer control functions using PyAutoGUI + keyboard + clipboard. -# Used by the agent when no existing action file covers the task. -# -# Capabilities: -# - Type text anywhere (active window, forms, fields) -# - Mouse click, double-click, right-click, drag -# - Keyboard shortcuts and key combinations -# - Scroll (up/down/left/right) -# - Window management (minimize, maximize, close, focus) -# - Clipboard (copy, paste, get content) -# - Screenshot + locate element on screen -# - Wait / smart wait for element to appear -# - Random data generation (name, email, username, password, phone, address) -# - Hotkey sequences -# - Find and click image/element on screen - +import io import json +import re +import string +import subprocess import sys import time import random -import string -import subprocess -import platform from pathlib import Path try: @@ -40,282 +22,135 @@ try: except ImportError: _PYPERCLIP = False - -def get_base_dir() -> Path: +def _base_dir() -> Path: if getattr(sys, "frozen", False): return Path(sys.executable).parent return Path(__file__).resolve().parent.parent -BASE_DIR = get_base_dir() -API_CONFIG_PATH = BASE_DIR / "config" / "api_keys.json" +_BASE = _base_dir() +_CONFIG_PATH = _BASE / "config" / "api_keys.json" +_MEMORY_PATH = _BASE / "memory" / "long_term.json" - -def _load_user_profile() -> dict: - """Load user profile from long_term.json for form filling.""" - memory_path = BASE_DIR / "memory" / "long_term.json" +def _load_config() -> dict: try: - if memory_path.exists(): - data = json.loads(memory_path.read_text(encoding="utf-8")) - identity = data.get("identity", {}) - return { - "name": identity.get("name", {}).get("value", ""), - "age": identity.get("age", {}).get("value", ""), - "city": identity.get("city", {}).get("value", ""), - "email": identity.get("email", {}).get("value", ""), - } + return json.loads(_CONFIG_PATH.read_text(encoding="utf-8")) + except Exception: + return {} + +def _get_os() -> str: + return _load_config().get("os_system", "windows").lower() + + +def _get_api_key() -> str: + return _load_config().get("gemini_api_key", "") + +_SAFE_SCREENSHOT_ROOTS = ( + Path.home(), +) + +def _safe_screenshot_path(requested: str | None) -> Path: + fallback = Path.home() / "Desktop" / "jarvis_screenshot.png" + if not requested: + return fallback + try: + p = Path(requested).expanduser().resolve() + for root in _SAFE_SCREENSHOT_ROOTS: + if p.is_relative_to(root.resolve()): + p.parent.mkdir(parents=True, exist_ok=True) + return p except Exception: pass - return {} + return fallback - -def _ensure_pyautogui(): +def _require_pyautogui(): if not _PYAUTOGUI: - raise RuntimeError( - "PyAutoGUI not installed. Run: pip install pyautogui" - ) - + raise RuntimeError("PyAutoGUI not installed. Run: pip install pyautogui") _FIRST_NAMES = [ "Alex", "Jordan", "Taylor", "Morgan", "Casey", "Riley", "Drew", "Quinn", - "Avery", "Blake", "Cameron", "Dakota", "Emerson", "Finley", "Harper" + "Avery", "Blake", "Cameron", "Dakota", "Emerson", "Finley", "Harper", ] _LAST_NAMES = [ "Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", - "Davis", "Wilson", "Moore", "Taylor", "Anderson", "Thomas", "Jackson" + "Davis", "Wilson", "Moore", "Taylor", "Anderson", "Thomas", "Jackson", ] _DOMAINS = ["gmail.com", "yahoo.com", "outlook.com", "proton.me", "mail.com"] -def generate_random_data(data_type: str) -> str: - """ - Generates random realistic data for form filling. - - Types: name | first_name | last_name | email | username | - password | phone | birthday | address | zip_code - """ +def _random_data(data_type: str) -> str: dt = data_type.lower().strip() if dt == "first_name": return random.choice(_FIRST_NAMES) - elif dt == "last_name": + if dt == "last_name": return random.choice(_LAST_NAMES) - elif dt == "name": + if dt == "name": return f"{random.choice(_FIRST_NAMES)} {random.choice(_LAST_NAMES)}" - elif dt == "email": + if dt == "email": first = random.choice(_FIRST_NAMES).lower() last = random.choice(_LAST_NAMES).lower() num = random.randint(10, 999) return f"{first}.{last}{num}@{random.choice(_DOMAINS)}" - elif dt == "username": - first = random.choice(_FIRST_NAMES).lower() - num = random.randint(100, 9999) - return f"{first}{num}" + if dt == "username": + return f"{random.choice(_FIRST_NAMES).lower()}{random.randint(100, 9999)}" - elif dt == "password": + if dt == "password": chars = string.ascii_letters + string.digits + "!@#$%" - pwd = ( - random.choice(string.ascii_uppercase) + - random.choice(string.digits) + - random.choice("!@#$%") + - "".join(random.choices(chars, k=9)) + raw = ( + random.choice(string.ascii_uppercase) + + random.choice(string.digits) + + random.choice("!@#$%") + + "".join(random.choices(chars, k=9)) ) - return "".join(random.sample(pwd, len(pwd))) + return "".join(random.sample(raw, len(raw))) - elif dt == "phone": - return f"+1{random.randint(200,999)}{random.randint(1000000,9999999)}" + if dt == "phone": + return f"+1{random.randint(200,999)}{random.randint(1_000_000, 9_999_999)}" - elif dt == "birthday": - year = random.randint(1980, 2000) - month = random.randint(1, 12) - day = random.randint(1, 28) - return f"{month:02d}/{day:02d}/{year}" + if dt == "birthday": + y = random.randint(1980, 2000) + m = random.randint(1, 12) + d = random.randint(1, 28) + return f"{m:02d}/{d:02d}/{y}" - elif dt == "address": + if dt == "address": num = random.randint(100, 9999) street = random.choice(["Main St", "Oak Ave", "Park Blvd", "Elm St", "Cedar Ln"]) return f"{num} {street}" - elif dt == "zip_code": + if dt == "zip_code": return str(random.randint(10000, 99999)) - elif dt == "city": + if dt == "city": return random.choice(["New York", "Los Angeles", "Chicago", "Houston", "Phoenix"]) - return f"random_{data_type}_{random.randint(1000,9999)}" + return f"random_{data_type}_{random.randint(1000, 9999)}" +def _user_profile() -> dict: + """Read identity fields from long-term memory.""" + try: + if _MEMORY_PATH.exists(): + data = json.loads(_MEMORY_PATH.read_text(encoding="utf-8")) + identity = data.get("identity", {}) + return {k: v.get("value", "") for k, v in identity.items()} + except Exception: + pass + return {} -def _type_text(text: str, interval: float = 0.03) -> str: - """Types text at the current cursor position.""" - _ensure_pyautogui() +def _type(text: str, interval: float = 0.03) -> str: + _require_pyautogui() time.sleep(0.3) pyautogui.typewrite(text, interval=interval) - return f"Typed: {text[:50]}{'...' if len(text) > 50 else ''}" - - -def _click(x: int = None, y: int = None, button: str = "left", - clicks: int = 1, image: str = None) -> str: - """ - Clicks at coordinates or on a screen image. - If image path given, locates it on screen and clicks. - """ - _ensure_pyautogui() - - if image: - try: - loc = pyautogui.locateCenterOnScreen(image, confidence=0.8) - if loc: - pyautogui.click(loc.x, loc.y, button=button, clicks=clicks) - return f"Clicked image: {image}" - return f"Image not found on screen: {image}" - except Exception as e: - return f"Image click failed: {e}" - - if x is not None and y is not None: - pyautogui.click(x, y, button=button, clicks=clicks) - return f"Clicked ({x}, {y}) with {button} button" - - pyautogui.click(button=button, clicks=clicks) - return f"Clicked at current position" - - -def _hotkey(*keys) -> str: - """Presses a key combination. E.g. hotkey('ctrl', 'c')""" - _ensure_pyautogui() - pyautogui.hotkey(*keys) - return f"Hotkey: {'+'.join(keys)}" - - -def _press(key: str) -> str: - """Presses a single key.""" - _ensure_pyautogui() - pyautogui.press(key) - return f"Pressed: {key}" - - -def _scroll(direction: str = "down", amount: int = 3) -> str: - """Scrolls in the specified direction.""" - _ensure_pyautogui() - clicks = amount if direction in ("up", "right") else -amount - if direction in ("up", "down"): - pyautogui.scroll(clicks) - else: - pyautogui.hscroll(clicks) - return f"Scrolled {direction} {amount} times" - - -def _move_mouse(x: int, y: int, duration: float = 0.3) -> str: - """Moves mouse to coordinates.""" - _ensure_pyautogui() - pyautogui.moveTo(x, y, duration=duration) - return f"Mouse moved to ({x}, {y})" - - -def _drag(x1: int, y1: int, x2: int, y2: int, duration: float = 0.5) -> str: - """Drags from (x1,y1) to (x2,y2).""" - _ensure_pyautogui() - pyautogui.drag(x1 - pyautogui.position()[0], y1 - pyautogui.position()[1]) - pyautogui.dragTo(x2, y2, duration=duration) - return f"Dragged from ({x1},{y1}) to ({x2},{y2})" - - -def _clipboard_copy() -> str: - """Gets current clipboard content.""" - if _PYPERCLIP: - return pyperclip.paste() - _hotkey("ctrl", "c") - time.sleep(0.2) - return "Copied to clipboard" - - -def _clipboard_set(text: str) -> str: - """Sets clipboard content and pastes it.""" - if _PYPERCLIP: - pyperclip.copy(text) - time.sleep(0.1) - _hotkey("ctrl", "v") - return f"Pasted: {text[:50]}" - return "pyperclip not available" - - -def _screenshot(save_path: str = None) -> str: - """Takes a screenshot.""" - _ensure_pyautogui() - if not save_path: - save_path = str(Path.home() / "Desktop" / "screenshot.png") - img = pyautogui.screenshot() - img.save(save_path) - return f"Screenshot saved: {save_path}" - - -def _wait(seconds: float) -> str: - """Waits for specified seconds.""" - time.sleep(seconds) - return f"Waited {seconds}s" - - -def _wait_for_image(image_path: str, timeout: int = 10) -> str: - """Waits until an image appears on screen (up to timeout seconds).""" - _ensure_pyautogui() - start = time.time() - while time.time() - start < timeout: - try: - loc = pyautogui.locateCenterOnScreen(image_path, confidence=0.8) - if loc: - return f"Image found at ({loc.x}, {loc.y})" - except Exception: - pass - time.sleep(0.5) - return f"Image not found within {timeout}s: {image_path}" - - -def _get_screen_size() -> str: - """Returns current screen resolution.""" - _ensure_pyautogui() - w, h = pyautogui.size() - return f"{w}x{h}" - - -def _focus_window(title: str) -> str: - """Brings a window to focus by title (Windows).""" - if platform.system() == "Windows": - try: - script = f'(New-Object -ComObject WScript.Shell).AppActivate("{title}")' - subprocess.run( - ["powershell", "-NoProfile", "-Command", script], - capture_output=True, timeout=5 - ) - time.sleep(0.3) - return f"Focused window: {title}" - except Exception as e: - return f"Could not focus window: {e}" - return "Window focus only supported on Windows" - - -def _select_all() -> str: - return _hotkey("ctrl", "a") - - -def _clear_field() -> str: - """Selects all and deletes — clears an input field.""" - _hotkey("ctrl", "a") - time.sleep(0.1) - _press("delete") - return "Field cleared" + return f"Typed: {text[:60]}{'…' if len(text) > 60 else ''}" def _smart_type(text: str, clear_first: bool = True) -> str: - """ - Types text into the currently focused field. - Optionally clears the field first. - Uses clipboard for long text (faster, more reliable). - """ - _ensure_pyautogui() - + _require_pyautogui() if clear_first: _clear_field() time.sleep(0.1) @@ -324,231 +159,341 @@ def _smart_type(text: str, clear_first: bool = True) -> str: pyperclip.copy(text) time.sleep(0.1) pyautogui.hotkey("ctrl", "v") - return f"Smart-typed (clipboard): {text[:50]}" - else: - pyautogui.typewrite(text, interval=0.04) - return f"Smart-typed: {text[:50]}" + return f"Smart-typed (clipboard): {text[:60]}{'…' if len(text) > 60 else ''}" + + pyautogui.typewrite(text, interval=0.04) + return f"Smart-typed: {text[:60]}{'…' if len(text) > 60 else ''}" -def _analyze_screen_for_element(description: str) -> tuple[int, int] | None: - """ - Takes a screenshot and asks Gemini to find the coordinates - of a described element on screen. Returns (x, y) or None. - """ +def _click(x=None, y=None, button: str = "left", clicks: int = 1) -> str: + _require_pyautogui() + if x is not None and y is not None: + pyautogui.click(x, y, button=button, clicks=clicks) + return f"{'Double-c' if clicks == 2 else 'C'}licked ({x}, {y}) [{button}]" + pyautogui.click(button=button, clicks=clicks) + return f"Clicked at current position [{button}]" + + +def _hotkey(*keys) -> str: + _require_pyautogui() + pyautogui.hotkey(*keys) + return f"Hotkey: {'+'.join(keys)}" + + +def _press(key: str) -> str: + _require_pyautogui() + pyautogui.press(key) + return f"Pressed: {key}" + + +def _scroll(direction: str = "down", amount: int = 3) -> str: + _require_pyautogui() + vertical = direction in ("up", "down") + clicks = amount if direction in ("up", "right") else -amount + pyautogui.scroll(clicks) if vertical else pyautogui.hscroll(clicks) + return f"Scrolled {direction} ×{amount}" + + +def _move(x: int, y: int, duration: float = 0.3) -> str: + _require_pyautogui() + pyautogui.moveTo(x, y, duration=duration) + return f"Mouse → ({x}, {y})" + + +def _drag(x1: int, y1: int, x2: int, y2: int, duration: float = 0.5) -> str: + _require_pyautogui() + pyautogui.moveTo(x1, y1, duration=0.2) + pyautogui.dragTo(x2, y2, duration=duration, button="left") + return f"Dragged ({x1},{y1}) → ({x2},{y2})" + + +def _clipboard_get() -> str: + if _PYPERCLIP: + return pyperclip.paste() + _hotkey("ctrl", "c") + time.sleep(0.2) + return "(copied — pyperclip unavailable for read)" + + +def _clipboard_paste(text: str) -> str: + if _PYPERCLIP: + pyperclip.copy(text) + time.sleep(0.1) + _require_pyautogui() + pyautogui.hotkey("ctrl", "v") + return f"Pasted: {text[:60]}{'…' if len(text) > 60 else ''}" + return "pyperclip not available" + + +def _screenshot(save_path: str | None = None) -> str: + _require_pyautogui() + path = _safe_screenshot_path(save_path) + img = pyautogui.screenshot() + img.save(str(path)) + return f"Screenshot saved: {path}" + + +def _clear_field() -> str: + _require_pyautogui() + pyautogui.hotkey("ctrl", "a") + time.sleep(0.1) + pyautogui.press("delete") + return "Field cleared" + +def _focus_window(title: str) -> str: + os_name = _get_os() + + if os_name == "windows": + try: + script = f'(New-Object -ComObject WScript.Shell).AppActivate("{title}")' + subprocess.run( + ["powershell", "-NoProfile", "-NonInteractive", "-Command", script], + capture_output=True, timeout=5, + ) + time.sleep(0.3) + return f"Focused window: {title}" + except Exception as e: + return f"focus_window (Windows) failed: {e}" + + if os_name == "mac": + script = ( + f'tell application "System Events" to ' + f'set frontmost of (first process whose name contains "{title}") to true' + ) + try: + subprocess.run( + ["osascript", "-e", script], + capture_output=True, timeout=5, + ) + time.sleep(0.3) + return f"Focused window: {title}" + except Exception as e: + return f"focus_window (macOS) failed: {e}" + + if os_name == "linux": + try: + result = subprocess.run( + ["wmctrl", "-a", title], + capture_output=True, timeout=5, + ) + if result.returncode == 0: + time.sleep(0.3) + return f"Focused window: {title}" + except FileNotFoundError: + pass + try: + result = subprocess.run( + ["xdotool", "search", "--name", title, "windowactivate"], + capture_output=True, timeout=5, + ) + time.sleep(0.3) + return f"Focused window: {title}" + except FileNotFoundError: + return "focus_window (Linux) requires wmctrl or xdotool" + except Exception as e: + return f"focus_window (Linux) failed: {e}" + + return f"focus_window: unknown OS '{os_name}'" + +def _screen_find(description: str) -> tuple[int, int] | None: + api_key = _get_api_key() + if not api_key: + print("[ComputerControl] ⚠️ No API key for screen_find") + return None + try: - import google.generativeai as genai - import io + from google import genai + from google.genai import types as gtypes - cfg_path = API_CONFIG_PATH - with open(cfg_path, "r") as f: - api_key = json.load(f)["gemini_api_key"] - - genai.configure(api_key=api_key) - model = genai.GenerativeModel("gemini-2.5-flash-lite") - - - _ensure_pyautogui() + _require_pyautogui() w, h = pyautogui.size() img = pyautogui.screenshot() buf = io.BytesIO() img.save(buf, format="PNG") - buf.seek(0) + image_bytes = buf.getvalue() + client = genai.Client(api_key=api_key) prompt = ( - f"This is a screenshot of a computer screen ({w}x{h} pixels). " - f"Find the element: '{description}'. " - f"Return ONLY: x,y (the center coordinates of the element). " - f"If not found, return: NOT_FOUND" + f"This is a screenshot of a {w}×{h} pixel screen. " + f"Locate the UI element described as: '{description}'. " + f"Reply with ONLY the center coordinates as: x,y " + f"If the element is not visible, reply: NOT_FOUND" ) - response = model.generate_content([ - {"mime_type": "image/png", "data": buf.getvalue()}, - prompt - ]) + response = client.models.generate_content( + model="gemini-2.5-flash-lite", + contents=[ + gtypes.Part.from_bytes(data=image_bytes, mime_type="image/png"), + prompt, + ], + ) - text = response.text.strip() - if "NOT_FOUND" in text: + text = (response.text or "").strip() + if "NOT_FOUND" in text.upper(): return None - import re match = re.search(r"(\d+)\s*,\s*(\d+)", text) if match: return int(match.group(1)), int(match.group(2)) except Exception as e: - print(f"[ComputerControl] ⚠️ Screen analysis failed: {e}") + print(f"[ComputerControl] ⚠️ screen_find failed: {e}") return None def computer_control( - parameters: dict, + parameters: dict, response=None, player=None, session_memory=None, ) -> str: """ - Universal computer control action. + Dispatch table for all computer control actions. + + parameters keys (all optional unless noted): + action : (required) one of the actions listed below + text : text to type or paste + x, y : screen coordinates + button : 'left' | 'right' (default: left) + keys : hotkey string, e.g. 'ctrl+c' + key : single key name, e.g. 'enter' + direction : 'up' | 'down' | 'left' | 'right' + amount : scroll amount (default: 3) + seconds : wait duration + title : window title fragment for focus_window + description : natural-language element description for screen_find/click + type : data type for random_data + field : memory field name for user_data + clear_first : bool, clear field before typing (default: true) + path : save path for screenshot (must be inside home dir) Actions: - type : Type text at current cursor position - smart_type : Clear field + type (clipboard-based for long text) - click : Click at coordinates or on image - double_click : Double click - right_click : Right click - hotkey : Key combination (e.g. ctrl+c) - press : Single key press - scroll : Scroll up/down/left/right - move : Move mouse to coordinates - drag : Drag from one point to another - copy : Get clipboard content - paste : Set and paste clipboard content - screenshot : Take a screenshot - wait : Wait N seconds - wait_image : Wait for image to appear on screen - clear_field : Select all + delete in current field - focus_window : Bring window to foreground - screen_find : AI-powered element finder — returns coordinates - screen_click : AI-powered element finder + click - random_data : Generate random data for forms - user_data : Get user's real data from memory + type — type text at cursor + smart_type — clear field + type (clipboard-backed) + click — left click + double_click — double left click + right_click — right click + move — move mouse + drag — click-drag between two points + hotkey — key combination + press — single key + scroll — scroll the wheel + copy — read clipboard + paste — write + paste clipboard + screenshot — capture screen (safe path only) + wait — sleep N seconds + clear_field — select-all + delete + focus_window — bring window to foreground + screen_find — AI element finder (returns x,y) + screen_click — AI element finder + click + random_data — generate fake form data + user_data — pull real data from memory """ - action = (parameters or {}).get("action", "").lower().strip() + params = parameters or {} + action = params.get("action", "").lower().strip() if not action: - return "Please specify an action for computer_control, sir." + return "No action specified for computer_control." if player: player.write_log(f"[Computer] {action}") - print(f"[ComputerControl] ▶️ Action: {action} Params: {parameters}") + print(f"[ComputerControl] ▶ {action} {params}") try: + if action == "type": - text = parameters.get("text", "") - return _type_text(text) + return _type(params.get("text", "")) - elif action == "smart_type": - text = parameters.get("text", "") - clear_first = parameters.get("clear_first", True) - return _smart_type(text, clear_first=clear_first) - - elif action in ("click", "left_click"): - return _click( - x=parameters.get("x"), - y=parameters.get("y"), - button="left", - clicks=1, - image=parameters.get("image") + if action == "smart_type": + return _smart_type( + params.get("text", ""), + clear_first=params.get("clear_first", True), ) - elif action == "double_click": - return _click( - x=parameters.get("x"), - y=parameters.get("y"), - button="left", - clicks=2, - image=parameters.get("image") - ) + if action in ("click", "left_click"): + return _click(params.get("x"), params.get("y"), "left", 1) - elif action == "right_click": - return _click( - x=parameters.get("x"), - y=parameters.get("y"), - button="right", - clicks=1 - ) + if action == "double_click": + return _click(params.get("x"), params.get("y"), "left", 2) - elif action == "move": - return _move_mouse( - x=int(parameters.get("x", 0)), - y=int(parameters.get("y", 0)), - duration=float(parameters.get("duration", 0.3)) - ) + if action == "right_click": + return _click(params.get("x"), params.get("y"), "right", 1) - elif action == "drag": + if action == "move": + return _move(int(params.get("x", 0)), int(params.get("y", 0))) + + if action == "drag": return _drag( - x1=int(parameters.get("x1", 0)), - y1=int(parameters.get("y1", 0)), - x2=int(parameters.get("x2", 0)), - y2=int(parameters.get("y2", 0)) + int(params.get("x1", 0)), int(params.get("y1", 0)), + int(params.get("x2", 0)), int(params.get("y2", 0)), ) - elif action == "hotkey": - keys = parameters.get("keys", "") - if isinstance(keys, str): - keys = [k.strip() for k in keys.split("+")] + if action == "hotkey": + raw = params.get("keys", "") + keys = [k.strip() for k in raw.split("+")] if isinstance(raw, str) else raw return _hotkey(*keys) - elif action == "press": - return _press(parameters.get("key", "enter")) + if action == "press": + return _press(params.get("key", "enter")) - elif action == "scroll": + if action == "scroll": return _scroll( - direction=parameters.get("direction", "down"), - amount=int(parameters.get("amount", 3)) + direction=params.get("direction", "down"), + amount=int(params.get("amount", 3)), ) - elif action == "copy": - return _clipboard_copy() + if action == "copy": + return _clipboard_get() - elif action == "paste": - return _clipboard_set(parameters.get("text", "")) + if action == "paste": + return _clipboard_paste(params.get("text", "")) - elif action == "screenshot": - return _screenshot(parameters.get("path")) + if action == "screenshot": + return _screenshot(params.get("path")) - elif action == "wait": - return _wait(float(parameters.get("seconds", 1.0))) + if action == "screen_find": + coords = _screen_find(params.get("description", "")) + return f"{coords[0]},{coords[1]}" if coords else "NOT_FOUND" - elif action == "wait_image": - return _wait_for_image( - parameters.get("image", ""), - timeout=int(parameters.get("timeout", 10)) - ) - - elif action == "clear_field": - return _clear_field() - - elif action == "focus_window": - return _focus_window(parameters.get("title", "")) - - elif action == "screen_size": - return _get_screen_size() - - elif action == "screen_find": - description = parameters.get("description", "") - coords = _analyze_screen_for_element(description) - if coords: - return f"{coords[0]},{coords[1]}" - return "NOT_FOUND" - - elif action == "screen_click": - description = parameters.get("description", "") - coords = _analyze_screen_for_element(description) + if action == "screen_click": + desc = params.get("description", "") + coords = _screen_find(desc) if coords: time.sleep(0.2) _click(x=coords[0], y=coords[1]) - return f"Found and clicked: {description} at {coords}" - return f"Could not find on screen: {description}" + return f"Clicked '{desc}' at {coords}" + return f"Element not found on screen: '{desc}'" - elif action == "random_data": - data_type = parameters.get("type", "name") - result = generate_random_data(data_type) - print(f"[ComputerControl] 🎲 Random {data_type}: {result}") + if action == "wait": + secs = float(params.get("seconds", 1.0)) + secs = min(secs, 30.0) + time.sleep(secs) + return f"Waited {secs}s" + + if action == "clear_field": + return _clear_field() + + if action == "focus_window": + return _focus_window(params.get("title", "")) + + if action == "random_data": + dt = params.get("type", "name") + result = _random_data(dt) + print(f"[ComputerControl] 🎲 random {dt} → {result}") return result - elif action == "user_data": - field = parameters.get("field", "name") - profile = _load_user_profile() + if action == "user_data": + field = params.get("field", "name") + profile = _user_profile() value = profile.get(field, "") if not value: - value = generate_random_data(field) - print(f"[ComputerControl] ⚠️ No user {field} in memory, using random: {value}") + value = _random_data(field) + print(f"[ComputerControl] ⚠️ No '{field}' in memory, using random: {value}") return value - else: - return f"Unknown computer_control action: '{action}'" + return f"Unknown action: '{action}'" except Exception as e: - print(f"[ComputerControl] ❌ Error: {e}") - return f"computer_control failed: {e}" \ No newline at end of file + print(f"[ComputerControl] ❌ {action}: {e}") + return f"computer_control '{action}' failed: {e}" \ No newline at end of file diff --git a/actions/computer_settings.py b/actions/computer_settings.py index 3325eb5..8cb0bb0 100644 --- a/actions/computer_settings.py +++ b/actions/computer_settings.py @@ -1,16 +1,8 @@ -# actions/computer_settings.py -# MARK XXV — Computer Settings & UI Controls -# -# Kullanıcı "sesi aç", "uygulamayı kapat", "tam ekran yap", "şunu yaz" gibi -# bilgisayar kontrol komutları verdiğinde bu dosya devreye girer. -# -# - Intent detection: Gemini ile (multi-language, hardcoded keyword yok) -# - Cross-platform: Windows / macOS / Linux -# - pyautogui + platform-specific API'ler - +import json +import re +import sys import time import subprocess -import sys import platform from pathlib import Path @@ -28,139 +20,211 @@ try: except ImportError: _PYPERCLIP = False -_OS = platform.system() +_OS = platform.system() # "Windows" | "Darwin" | "Linux" -def get_base_dir() -> Path: + +def _get_base_dir() -> Path: if getattr(sys, "frozen", False): return Path(sys.executable).parent return Path(__file__).resolve().parent.parent -BASE_DIR = get_base_dir() -API_CONFIG_PATH = BASE_DIR / "config" / "api_keys.json" - -import json def _get_api_key() -> str: - with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: + path = _get_base_dir() / "config" / "api_keys.json" + with open(path, "r", encoding="utf-8") as f: return json.load(f)["gemini_api_key"] +def _get_macos_wifi_interface() -> str: + try: + result = subprocess.run( + ["networksetup", "-listallhardwareports"], + capture_output=True, text=True, timeout=5 + ) + lines = result.stdout.splitlines() + for i, line in enumerate(lines): + if "Wi-Fi" in line or "AirPort" in line: + for j in range(i, min(i + 4, len(lines))): + if lines[j].startswith("Device:"): + return lines[j].split(":", 1)[1].strip() + except Exception: + pass + return "en0" def volume_up(): if _OS == "Windows": for _ in range(5): pyautogui.press("volumeup") elif _OS == "Darwin": - subprocess.run(["osascript", "-e", "set volume output volume (output volume of (get volume settings) + 10)"]) + subprocess.run(["osascript", "-e", + "set volume output volume (output volume of (get volume settings) + 10)"], + capture_output=True) else: - subprocess.run(["pactl", "set-sink-volume", "@DEFAULT_SINK@", "+10%"]) + subprocess.run(["pactl", "set-sink-volume", "@DEFAULT_SINK@", "+10%"], + capture_output=True) def volume_down(): if _OS == "Windows": for _ in range(5): pyautogui.press("volumedown") elif _OS == "Darwin": - subprocess.run(["osascript", "-e", "set volume output volume (output volume of (get volume settings) - 10)"]) + subprocess.run(["osascript", "-e", + "set volume output volume (output volume of (get volume settings) - 10)"], + capture_output=True) else: - subprocess.run(["pactl", "set-sink-volume", "@DEFAULT_SINK@", "-10%"]) + subprocess.run(["pactl", "set-sink-volume", "@DEFAULT_SINK@", "-10%"], + capture_output=True) def volume_mute(): if _OS == "Windows": pyautogui.press("volumemute") elif _OS == "Darwin": - subprocess.run(["osascript", "-e", "set volume with output muted"]) + subprocess.run(["osascript", "-e", "set volume with output muted"], + capture_output=True) else: - subprocess.run(["pactl", "set-sink-mute", "@DEFAULT_SINK@", "toggle"]) + subprocess.run(["pactl", "set-sink-mute", "@DEFAULT_SINK@", "toggle"], + capture_output=True) def volume_set(value: int): - value = max(0, min(100, value)) + value = max(0, min(100, int(value))) if _OS == "Windows": try: + import math from ctypes import cast, POINTER from comtypes import CLSCTX_ALL from pycaw.pycaw import AudioUtilities, IAudioEndpointVolume - import math devices = AudioUtilities.GetSpeakers() interface = devices.Activate(IAudioEndpointVolume._iid_, CLSCTX_ALL, None) vol = cast(interface, POINTER(IAudioEndpointVolume)) vol_db = -65.25 if value == 0 else max(-65.25, 20 * math.log10(value / 100)) vol.SetMasterVolumeLevel(vol_db, None) - print(f"[Settings] 🔊 Volume → {value}%") return except Exception as e: - print(f"[Settings] ⚠️ pycaw failed: {e}") + print(f"[Settings] pycaw failed, using keypress fallback: {e}") + pyautogui.press("volumemute") + pyautogui.press("volumemute") elif _OS == "Darwin": - subprocess.run(["osascript", "-e", f"set volume output volume {value}"]) + subprocess.run(["osascript", "-e", f"set volume output volume {value}"], + capture_output=True) return else: - subprocess.run(["pactl", "set-sink-volume", "@DEFAULT_SINK@", f"{value}%"]) + subprocess.run(["pactl", "set-sink-volume", "@DEFAULT_SINK@", f"{value}%"], + capture_output=True) return def brightness_up(): - if _OS == "Windows": - pyautogui.hotkey("win", "a") - time.sleep(0.3) - elif _OS == "Darwin": - subprocess.run(["osascript", "-e", "tell application \"System Events\" to key code 144"]) + if _OS == "Darwin": + subprocess.run(["osascript", "-e", + 'tell application "System Events" to key code 144'], + capture_output=True) + elif _OS == "Linux": + if subprocess.run(["which", "brightnessctl"], + capture_output=True).returncode == 0: + subprocess.run(["brightnessctl", "set", "+10%"], capture_output=True) + else: + subprocess.run( + 'xrandr --output $(xrandr | grep " connected" | head -1 | cut -d " " -f1)' + ' --brightness $(python3 -c "import subprocess; ' + 'b=float(subprocess.check_output([\"xrandr\",\"--verbose\"]).decode()' + '.split(\"Brightness:\")[1].split()[0]); print(min(1.0,b+0.1))")', + shell=True, capture_output=True + ) else: - subprocess.run(["brightnessctl", "set", "+10%"]) + try: + subprocess.run( + ["powershell", "-Command", + "(Get-WmiObject -Namespace root/wmi -Class WmiMonitorBrightnessMethods)" + ".WmiSetBrightness(1, [math]::Min(100, " + "(Get-WmiObject -Namespace root/wmi -Class WmiMonitorBrightness).CurrentBrightness + 10))"], + capture_output=True, timeout=5 + ) + except Exception as e: + print(f"[Settings] Brightness up failed on Windows: {e}") def brightness_down(): - if _OS == "Windows": - pyautogui.hotkey("win", "a") - time.sleep(0.3) - elif _OS == "Darwin": - subprocess.run(["osascript", "-e", "tell application \"System Events\" to key code 145"]) + if _OS == "Darwin": + subprocess.run(["osascript", "-e", + 'tell application "System Events" to key code 145'], + capture_output=True) + elif _OS == "Linux": + if subprocess.run(["which", "brightnessctl"], + capture_output=True).returncode == 0: + subprocess.run(["brightnessctl", "set", "10%-"], capture_output=True) + else: + subprocess.run( + 'xrandr --output $(xrandr | grep " connected" | head -1 | cut -d " " -f1)' + ' --brightness $(python3 -c "import subprocess; ' + 'b=float(subprocess.check_output([\"xrandr\",\"--verbose\"]).decode()' + '.split(\"Brightness:\")[1].split()[0]); print(max(0.1,b-0.1))")', + shell=True, capture_output=True + ) else: - subprocess.run(["brightnessctl", "set", "10%-"]) - + try: + subprocess.run( + ["powershell", "-Command", + "(Get-WmiObject -Namespace root/wmi -Class WmiMonitorBrightnessMethods)" + ".WmiSetBrightness(1, [math]::Max(0, " + "(Get-WmiObject -Namespace root/wmi -Class WmiMonitorBrightness).CurrentBrightness - 10))"], + capture_output=True, timeout=5 + ) + except Exception as e: + print(f"[Settings] Brightness down failed on Windows: {e}") def close_app(): - if _OS == "Darwin": - pyautogui.hotkey("command", "q") - else: - pyautogui.hotkey("alt", "f4") + if _OS == "Darwin": pyautogui.hotkey("command", "q") + else: pyautogui.hotkey("alt", "f4") def close_window(): - if _OS == "Darwin": - pyautogui.hotkey("command", "w") - else: - pyautogui.hotkey("ctrl", "w") + if _OS == "Darwin": pyautogui.hotkey("command", "w") + else: pyautogui.hotkey("ctrl", "w") def full_screen(): - if _OS == "Darwin": - pyautogui.hotkey("ctrl", "command", "f") - else: - pyautogui.press("f11") + if _OS == "Darwin": pyautogui.hotkey("ctrl", "command", "f") + else: pyautogui.press("f11") def minimize_window(): - if _OS == "Darwin": - pyautogui.hotkey("command", "m") - else: - pyautogui.hotkey("win", "down") + if _OS == "Darwin": pyautogui.hotkey("command", "m") + else: pyautogui.hotkey("win", "down") def maximize_window(): if _OS == "Darwin": subprocess.run(["osascript", "-e", - 'tell application "System Events" to keystroke "f" using {control down, command down}']) - else: + 'tell application "System Events" to keystroke "f" ' + 'using {control down, command down}'], + capture_output=True) + elif _OS == "Windows": pyautogui.hotkey("win", "up") + else: + try: + subprocess.run(["wmctrl", "-r", ":ACTIVE:", "-b", "add,maximized_vert,maximized_horz"], + capture_output=True) + except Exception: + pyautogui.hotkey("super", "up") def snap_left(): - if _OS == "Windows": pyautogui.hotkey("win", "left") + if _OS == "Windows": + pyautogui.hotkey("win", "left") + elif _OS == "Linux": + try: + subprocess.run(["wmctrl", "-r", ":ACTIVE:", "-e", "0,0,0,960,1080"], + capture_output=True) + except Exception: + pass def snap_right(): - if _OS == "Windows": pyautogui.hotkey("win", "right") + if _OS == "Windows": + pyautogui.hotkey("win", "right") + elif _OS == "Linux": + try: + subprocess.run(["wmctrl", "-r", ":ACTIVE:", "-e", "0,960,0,960,1080"], + capture_output=True) + except Exception: + pass def switch_window(): - if _OS == "Darwin": - pyautogui.hotkey("command", "tab") - else: - pyautogui.hotkey("alt", "tab") + if _OS == "Darwin": pyautogui.hotkey("command", "tab") + else: pyautogui.hotkey("alt", "tab") def show_desktop(): - if _OS == "Darwin": - pyautogui.hotkey("fn", "f11") - elif _OS == "Windows": - pyautogui.hotkey("win", "d") - else: - pyautogui.hotkey("super", "d") + if _OS == "Darwin": pyautogui.hotkey("fn", "f11") + elif _OS == "Windows": pyautogui.hotkey("win", "d") + else: pyautogui.hotkey("super", "d") def open_task_manager(): if _OS == "Windows": @@ -168,11 +232,10 @@ def open_task_manager(): elif _OS == "Darwin": subprocess.Popen(["open", "-a", "Activity Monitor"]) else: - subprocess.Popen(["gnome-system-monitor"]) - -def open_task_view(): - if _OS == "Windows": - pyautogui.hotkey("win", "tab") + for cmd in [["gnome-system-monitor"], ["xfce4-taskmanager"], ["htop"]]: + if subprocess.run(["which", cmd[0]], capture_output=True).returncode == 0: + subprocess.Popen(cmd) + break def focus_search(): @@ -180,6 +243,7 @@ def focus_search(): else: pyautogui.hotkey("ctrl", "l") def pause_video(): pyautogui.press("space") + def refresh_page(): if _OS == "Darwin": pyautogui.hotkey("command", "r") else: pyautogui.press("f5") @@ -225,17 +289,24 @@ def find_on_page(): else: pyautogui.hotkey("ctrl", "f") def reload_page_n(n: int): - for _ in range(n): + for _ in range(max(1, n)): refresh_page() time.sleep(0.8) -def scroll_up(amount: int = 500): pyautogui.scroll(amount) -def scroll_down(amount: int = 500): pyautogui.scroll(-amount) -def scroll_top(): pyautogui.hotkey("ctrl", "home") if _OS != "Darwin" else pyautogui.hotkey("command", "up") -def scroll_bottom(): pyautogui.hotkey("ctrl", "end") if _OS != "Darwin" else pyautogui.hotkey("command", "down") -def page_up(): pyautogui.press("pageup") -def page_down(): pyautogui.press("pagedown") +def scroll_up(amount: int = 500): pyautogui.scroll(amount) +def scroll_down(amount: int = 500): pyautogui.scroll(-amount) + +def scroll_top(): + if _OS == "Darwin": pyautogui.hotkey("command", "up") + else: pyautogui.hotkey("ctrl", "home") + +def scroll_bottom(): + if _OS == "Darwin": pyautogui.hotkey("command", "down") + else: pyautogui.hotkey("ctrl", "end") + +def page_up(): pyautogui.press("pageup") +def page_down(): pyautogui.press("pagedown") def copy(): @@ -266,16 +337,16 @@ def save_file(): if _OS == "Darwin": pyautogui.hotkey("command", "s") else: pyautogui.hotkey("ctrl", "s") -def press_enter(): pyautogui.press("enter") -def press_escape(): pyautogui.press("escape") +def press_enter(): pyautogui.press("enter") +def press_escape(): pyautogui.press("escape") def press_key(key: str): pyautogui.press(key) def type_text(text: str, press_enter_after: bool = False): if not text: return if _PYPERCLIP: - pyperclip.copy(text) - time.sleep(0.1) + pyperclip.copy(str(text)) + time.sleep(0.15) paste() else: pyautogui.write(str(text), interval=0.03) @@ -283,24 +354,32 @@ def type_text(text: str, press_enter_after: bool = False): time.sleep(0.1) pyautogui.press("enter") -def write_on_screen(text: str): - type_text(text) - def take_screenshot(): if _OS == "Windows": pyautogui.hotkey("win", "shift", "s") elif _OS == "Darwin": pyautogui.hotkey("command", "shift", "3") else: + for cmd in [["scrot"], ["gnome-screenshot"], ["import", "-window", "root", "screenshot.png"]]: + if subprocess.run(["which", cmd[0]], capture_output=True).returncode == 0: + subprocess.Popen(cmd) + return pyautogui.hotkey("ctrl", "print_screen") def lock_screen(): if _OS == "Windows": pyautogui.hotkey("win", "l") elif _OS == "Darwin": - subprocess.run(["pmset", "displaysleepnow"]) + subprocess.run(["pmset", "displaysleepnow"], capture_output=True) else: - subprocess.run(["gnome-screensaver-command", "-l"]) + for cmd in [ + ["gnome-screensaver-command", "-l"], + ["xdg-screensaver", "lock"], + ["loginctl", "lock-session"], + ]: + if subprocess.run(["which", cmd[0]], capture_output=True).returncode == 0: + subprocess.run(cmd, capture_output=True) + return def open_system_settings(): if _OS == "Windows": @@ -308,306 +387,227 @@ def open_system_settings(): elif _OS == "Darwin": subprocess.Popen(["open", "-a", "System Preferences"]) else: - subprocess.Popen(["gnome-control-center"]) + for cmd in [["gnome-control-center"], ["xfce4-settings-manager"], ["kcmshell5"]]: + if subprocess.run(["which", cmd[0]], capture_output=True).returncode == 0: + subprocess.Popen(cmd) + return def open_file_explorer(): if _OS == "Windows": pyautogui.hotkey("win", "e") elif _OS == "Darwin": - subprocess.Popen(["open", Path.home()]) + subprocess.Popen(["open", str(Path.home())]) else: - subprocess.Popen(["xdg-open", Path.home()]) - -def open_run(): - if _OS == "Windows": - pyautogui.hotkey("win", "r") + for cmd in [["nautilus"], ["thunar"], ["dolphin"], ["nemo"]]: + if subprocess.run(["which", cmd[0]], capture_output=True).returncode == 0: + subprocess.Popen(cmd) + return + subprocess.Popen(["xdg-open", str(Path.home())]) def sleep_display(): if _OS == "Windows": try: import ctypes ctypes.windll.user32.SendMessageW(0xFFFF, 0x0112, 0xF170, 2) - except Exception: - pass + except Exception as e: + print(f"[Settings] sleep_display failed: {e}") elif _OS == "Darwin": - subprocess.run(["pmset", "displaysleepnow"]) + subprocess.run(["pmset", "displaysleepnow"], capture_output=True) else: - subprocess.run(["xset", "dpms", "force", "off"]) + subprocess.run(["xset", "dpms", "force", "off"], capture_output=True) + +def open_run(): + if _OS == "Windows": + pyautogui.hotkey("win", "r") + +def dark_mode(): + if _OS == "Darwin": + subprocess.run(["osascript", "-e", + 'tell app "System Events" to tell appearance preferences ' + 'to set dark mode to not dark mode'], + capture_output=True) + elif _OS == "Windows": + try: + import winreg + key_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Themes\Personalize" + key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path, 0, winreg.KEY_ALL_ACCESS) + current, _ = winreg.QueryValueEx(key, "AppsUseLightTheme") + winreg.SetValueEx(key, "AppsUseLightTheme", 0, winreg.REG_DWORD, 1 - current) + winreg.SetValueEx(key, "SystemUsesLightTheme", 0, winreg.REG_DWORD, 1 - current) + winreg.CloseKey(key) + except Exception as e: + print(f"[Settings] dark_mode registry failed: {e}") + else: + try: + result = subprocess.run( + ["gsettings", "get", "org.gnome.desktop.interface", "color-scheme"], + capture_output=True, text=True + ) + current = result.stdout.strip() + new_scheme = "'default'" if "dark" in current else "'prefer-dark'" + subprocess.run( + ["gsettings", "set", "org.gnome.desktop.interface", "color-scheme", new_scheme], + capture_output=True + ) + except Exception as e: + print(f"[Settings] dark_mode Linux failed: {e}") + +def toggle_wifi(): + if _OS == "Darwin": + iface = _get_macos_wifi_interface() + result = subprocess.run( + ["networksetup", "-getairportpower", iface], + capture_output=True, text=True + ) + state = "off" if "On" in result.stdout else "on" + subprocess.run(["networksetup", "-setairportpower", iface, state], + capture_output=True) + elif _OS == "Windows": + try: + subprocess.run( + ["powershell", "-Command", + "$adapter = Get-NetAdapter | Where-Object {$_.PhysicalMediaType -eq 'Native 802.11'};" + "if ($adapter.Status -eq 'Up') { Disable-NetAdapter -Name $adapter.Name -Confirm:$false }" + "else { Enable-NetAdapter -Name $adapter.Name -Confirm:$false }"], + capture_output=True, timeout=10 + ) + except Exception as e: + print(f"[Settings] toggle_wifi Windows failed: {e}") + else: + try: + result = subprocess.run(["nmcli", "radio", "wifi"], capture_output=True, text=True) + state = "off" if "enabled" in result.stdout else "on" + subprocess.run(["nmcli", "radio", "wifi", state], capture_output=True) + except Exception as e: + print(f"[Settings] toggle_wifi Linux failed: {e}") def restart_computer(): if _OS == "Windows": - subprocess.run(["shutdown", "/r", "/t", "5"]) + subprocess.run(["shutdown", "/r", "/t", "10"], capture_output=True) elif _OS == "Darwin": - subprocess.run(["osascript", "-e", 'tell application "System Events" to restart']) + subprocess.run(["osascript", "-e", + 'tell application "System Events" to restart'], + capture_output=True) else: - subprocess.run(["sudo", "reboot"]) + subprocess.run(["systemctl", "reboot"], capture_output=True) def shutdown_computer(): if _OS == "Windows": - subprocess.run(["shutdown", "/s", "/t", "5"]) - elif _OS == "Darwin": - subprocess.run(["osascript", "-e", 'tell application "System Events" to shut down']) - else: - subprocess.run(["sudo", "shutdown", "-h", "now"]) - -def dark_mode(): - if _OS == "Windows": - pyautogui.hotkey("win", "a") - time.sleep(0.3) + subprocess.run(["shutdown", "/s", "/t", "10"], capture_output=True) elif _OS == "Darwin": subprocess.run(["osascript", "-e", - 'tell app "System Events" to tell appearance preferences to set dark mode to not dark mode']) - -def toggle_wifi(): - if _OS == "Windows": - pyautogui.hotkey("win", "a") - time.sleep(0.3) - elif _OS == "Darwin": - subprocess.run(["networksetup", "-setairportpower", "en0", "toggle"]) + 'tell application "System Events" to shut down'], + capture_output=True) else: - subprocess.run(["nmcli", "radio", "wifi"]) + subprocess.run(["systemctl", "poweroff"], capture_output=True) -ACTION_MAP = { - "volume_up": volume_up, - "volume_down": volume_down, - "mute": volume_mute, - "unmute": volume_mute, - "volume_increase": volume_up, - "volume_decrease": volume_down, - "increase_volume": volume_up, - "decrease_volume": volume_down, - "turn_up_volume": volume_up, - "turn_down_volume": volume_down, - "louder": volume_up, - "quieter": volume_down, - "silence": volume_mute, - "toggle_mute": volume_mute, - "brightness_up": brightness_up, - "brightness_down": brightness_down, - "increase_brightness": brightness_up, - "decrease_brightness": brightness_down, - "brighter": brightness_up, - "dimmer": brightness_down, - "dim_screen": brightness_down, - "brighten_screen": brightness_up, - "sleep_display": sleep_display, - "turn_off_screen": sleep_display, - "screen_off": sleep_display, - "display_off": sleep_display, - "change_screen": sleep_display, - "screen_sleep": sleep_display, - "monitor_off": sleep_display, - "turn_off_monitor": sleep_display, - "pause_video": pause_video, - "play_video": pause_video, - "pause": pause_video, - "play": pause_video, - "toggle_play": pause_video, - "stop_video": pause_video, - "resume_video": pause_video, - "close_app": close_app, - "close_window": close_window, - "quit_app": close_app, - "exit_app": close_app, - "kill_app": close_app, - "full_screen": full_screen, - "fullscreen": full_screen, - "toggle_fullscreen": full_screen, - "minimize": minimize_window, - "minimize_window": minimize_window, - "maximize": maximize_window, - "maximize_window": maximize_window, - "restore_window": maximize_window, - "snap_left": snap_left, - "snap_right": snap_right, - "window_left": snap_left, - "window_right": snap_right, - "switch_window": switch_window, - "alt_tab": switch_window, - "next_window": switch_window, - "show_desktop": show_desktop, - "desktop": show_desktop, - "hide_windows": show_desktop, - "task_manager": open_task_manager, - "open_task_manager": open_task_manager, - "task_view": open_task_view, - "screenshot": take_screenshot, - "take_screenshot": take_screenshot, - "capture_screen": take_screenshot, - "lock_screen": lock_screen, - "lock": lock_screen, - "open_settings": open_system_settings, - "system_settings": open_system_settings, - "settings": open_system_settings, - "preferences": open_system_settings, - "file_explorer": open_file_explorer, - "open_explorer": open_file_explorer, - "explorer": open_file_explorer, - "open_files": open_file_explorer, - "run": open_run, - "open_run": open_run, - "restart": restart_computer, - "restart_computer": restart_computer, - "reboot": restart_computer, - "reboot_computer": restart_computer, - "shutdown": shutdown_computer, - "shut_down": shutdown_computer, - "power_off": shutdown_computer, - "turn_off_computer": shutdown_computer, - "dark_mode": dark_mode, - "toggle_dark_mode": dark_mode, - "night_mode": dark_mode, - "toggle_wifi": toggle_wifi, - "wifi": toggle_wifi, - "wifi_toggle": toggle_wifi, - "focus_search": focus_search, - "address_bar": focus_search, - "url_bar": focus_search, - "refresh_page": refresh_page, - "reload_page": refresh_page, - "reload": refresh_page, - "refresh": refresh_page, - "close_tab": close_tab, - "new_tab": new_tab, - "open_tab": new_tab, - "next_tab": next_tab, - "prev_tab": prev_tab, - "previous_tab": prev_tab, - "go_back": go_back, - "back": go_back, - "go_forward": go_forward, - "forward": go_forward, - "zoom_in": zoom_in, - "zoom_out": zoom_out, - "zoom_reset": zoom_reset, - "reset_zoom": zoom_reset, - "find_on_page": find_on_page, - "search_page": find_on_page, - "scroll_up": scroll_up, - "scroll_down": scroll_down, - "scroll_top": scroll_top, - "scroll_bottom": scroll_bottom, - "top_of_page": scroll_top, - "bottom_of_page": scroll_bottom, - "page_up": page_up, - "page_down": page_down, - "copy": copy, - "paste": paste, - "cut": cut, - "undo": undo, - "redo": redo, - "select_all": select_all, - "save": save_file, - "save_file": save_file, - "enter": press_enter, - "press_enter": press_enter, - "escape": press_escape, - "press_escape": press_escape, - "cancel": press_escape, +ACTION_MAP: dict[str, callable] = { + "volume_up": volume_up, + "volume_down": volume_down, + "mute": volume_mute, + "unmute": volume_mute, + "toggle_mute": volume_mute, + "brightness_up": brightness_up, + "brightness_down": brightness_down, + "sleep_display": sleep_display, + "screen_off": sleep_display, + "pause_video": pause_video, + "play_pause": pause_video, + "close_app": close_app, + "close_window": close_window, + "full_screen": full_screen, + "fullscreen": full_screen, + "minimize": minimize_window, + "maximize": maximize_window, + "snap_left": snap_left, + "snap_right": snap_right, + "switch_window": switch_window, + "show_desktop": show_desktop, + "task_manager": open_task_manager, + "focus_search": focus_search, + "refresh_page": refresh_page, + "reload": refresh_page, + "close_tab": close_tab, + "new_tab": new_tab, + "next_tab": next_tab, + "prev_tab": prev_tab, + "go_back": go_back, + "go_forward": go_forward, + "zoom_in": zoom_in, + "zoom_out": zoom_out, + "zoom_reset": zoom_reset, + "find_on_page": find_on_page, + "scroll_up": scroll_up, + "scroll_down": scroll_down, + "scroll_top": scroll_top, + "scroll_bottom": scroll_bottom, + "page_up": page_up, + "page_down": page_down, + "copy": copy, + "paste": paste, + "cut": cut, + "undo": undo, + "redo": redo, + "select_all": select_all, + "save": save_file, + "enter": press_enter, + "escape": press_escape, + "screenshot": take_screenshot, + "lock_screen": lock_screen, + "open_settings": open_system_settings, + "file_explorer": open_file_explorer, + "open_run": open_run, + "dark_mode": dark_mode, + "toggle_wifi": toggle_wifi, + "restart": restart_computer, + "shutdown": shutdown_computer, } +_DANGEROUS_ACTIONS = {"restart", "shutdown"} + + + def _detect_action(description: str) -> dict: - """ - Gemini ile kullanıcının ne yapmak istediğini anlar. - Herhangi bir dilde çalışır. - Döner: {"action": str, "value": optional} - """ + import google.generativeai as genai genai.configure(api_key=_get_api_key()) model = genai.GenerativeModel("gemini-2.5-flash-lite") - available = ", ".join(sorted(ACTION_MAP.keys())) + ", volume_set, type_text, write_on_screen, reload_n, press_key" + available = ", ".join(sorted(ACTION_MAP.keys())) + \ + ", volume_set, type_text, press_key, reload_n" - prompt = f"""The user wants to control their computer. Detect their intent. + prompt = f"""You are an intent detector for a computer control assistant. -User said (in any language): "{description}" +The user issued a command (possibly in any language): "{description}" Available actions: {available} -Return ONLY valid JSON: +Return ONLY a valid JSON object: {{"action": "action_name", "value": null_or_value}} -Examples: -- "turn up the volume" → {{"action": "volume_up", "value": null}} -- "set volume to 60" → {{"action": "volume_set", "value": 60}} -- "sesi 80 yap" → {{"action": "volume_set", "value": 80}} -- "close the app" → {{"action": "close_app", "value": null}} -- "uygulamayı kapat" → {{"action": "close_app", "value": null}} -- "type hello world" → {{"action": "type_text", "value": "hello world"}} -- "write good morning on screen" → {{"action": "write_on_screen", "value": "good morning"}} -- "reload page 3 times" → {{"action": "reload_n", "value": 3}} -- "tam ekran yap" → {{"action": "full_screen", "value": null}} -- "sesi kıs" → {{"action": "volume_down", "value": null}} -- "sesi aç" → {{"action": "volume_up", "value": null}} -- "sustur" → {{"action": "mute", "value": null}} -- "monte le son" → {{"action": "volume_up", "value": null}} -- "ekranı kapat" → {{"action": "sleep_display", "value": null}} -- "monitörü kapat" → {{"action": "sleep_display", "value": null}} -- "turn off screen" → {{"action": "sleep_display", "value": null}} -- "turn off monitor" → {{"action": "sleep_display", "value": null}} -- "bilgisayarı yeniden başlat" → {{"action": "restart", "value": null}} -- "restart the computer" → {{"action": "restart", "value": null}} -- "bilgisayarı kapat" → {{"action": "shutdown", "value": null}} -- "shut down" → {{"action": "shutdown", "value": null}} -- "ekranı kilitle" → {{"action": "lock_screen", "value": null}} -- "lock the screen" → {{"action": "lock_screen", "value": null}} -- "küçült" → {{"action": "minimize", "value": null}} -- "minimize the window" → {{"action": "minimize", "value": null}} -- "büyüt" → {{"action": "maximize", "value": null}} -- "parlaklığı artır" → {{"action": "brightness_up", "value": null}} -- "parlaklığı azalt" → {{"action": "brightness_down", "value": null}} -- "increase brightness" → {{"action": "brightness_up", "value": null}} -- "wifi'yi aç" → {{"action": "toggle_wifi", "value": null}} -- "toggle wifi" → {{"action": "toggle_wifi", "value": null}} -- "masaüstünü göster" → {{"action": "show_desktop", "value": null}} -- "show desktop" → {{"action": "show_desktop", "value": null}} -- "yeni sekme aç" → {{"action": "new_tab", "value": null}} -- "sekmeyi kapat" → {{"action": "close_tab", "value": null}} -- "geri git" → {{"action": "go_back", "value": null}} -- "ileri git" → {{"action": "go_forward", "value": null}} -- "sayfayı yenile" → {{"action": "refresh_page", "value": null}} -- "yakınlaştır" → {{"action": "zoom_in", "value": null}} -- "uzaklaştır" → {{"action": "zoom_out", "value": null}} -- "kaydet" → {{"action": "save", "value": null}} -- "geri al" → {{"action": "undo", "value": null}} -- "screenshot al" → {{"action": "screenshot", "value": null}} -- "ekran görüntüsü al" → {{"action": "screenshot", "value": null}} -- "aşağı kaydır" → {{"action": "scroll_down", "value": null}} -- "yukarı kaydır" → {{"action": "scroll_up", "value": null}} -- "karanlık mod" → {{"action": "dark_mode", "value": null}} -- "press f5" → {{"action": "press_key", "value": "f5"}} -- "enter'a bas" → {{"action": "enter", "value": null}} -- "escape'e bas" → {{"action": "escape", "value": null}} - -IMPORTANT: -- Always return one of the available actions listed above. -- If the user's intent is clear but uses different wording, map it to the closest action. -- Never invent new action names not in the available list. -- Return ONLY the JSON object, no explanation, no markdown.""" +Rules: +- Pick the single best matching action from the available list. +- For volume_set: value is an integer 0-100. +- For type_text: value is the exact text to type. +- For press_key: value is the key name (e.g. "f5", "tab", "enter"). +- For reload_n: value is an integer (number of times to reload). +- If no clear match, pick the closest action. +- Return ONLY the JSON, no explanation, no markdown.""" try: - response = model.generate_content(prompt) - text = response.text.strip() - text = __import__("re").sub(r"```(?:json)?", "", text).strip().rstrip("`").strip() + resp = model.generate_content(prompt) + text = re.sub(r"```(?:json)?", "", resp.text).strip().rstrip("`").strip() return json.loads(text) except Exception as e: - print(f"[Settings] ⚠️ Intent detection failed: {e}") + print(f"[Settings] Intent detection failed: {e}") return {"action": description.lower().replace(" ", "_"), "value": None} def computer_settings( - parameters: dict, + parameters: dict = None, response=None, player=None, session_memory=None, ) -> str: - """ - Bilgisayar ayarları ve UI kontrolleri. - - parameters: - action : İşlem adı (verilmezse description'dan Gemini ile tespit edilir) - description : Kullanıcının doğal dil komutu (herhangi bir dilde) - value : İşleme özgü değer (ses seviyesi, yazılacak metin, tekrar sayısı vb.) - """ if not _PYAUTOGUI: return "pyautogui is not installed. Run: pip install pyautogui" @@ -625,10 +625,19 @@ def computer_settings( action = raw_action.lower().strip().replace(" ", "_").replace("-", "_") if not action: - return "No action could be determined, sir." + return "No action could be determined." - print(f"[Settings] ⚙️ Action: {action} Value: {value}") + print(f"[Settings] Action: {action} Value: {value} OS: {_OS}") + if player: + player.write_log(f"[Settings] {action}") + if action in _DANGEROUS_ACTIONS: + confirmed = str(params.get("confirmed", "")).lower() + if confirmed not in ("yes", "true", "1", "confirm"): + return ( + f"This will {action} the computer. " + f"Please confirm by calling again with confirmed=yes." + ) if action == "volume_set": try: @@ -638,42 +647,42 @@ def computer_settings( return f"Could not set volume: {e}" if action in ("type_text", "write_on_screen", "type", "write"): - text = str(value or params.get("text", "")) + text = str(value or params.get("text", "")).strip() if not text: - return "No text provided to type, sir." - enter_after = bool(params.get("press_enter", False)) + return "No text provided to type." + enter_after = str(params.get("press_enter", "false")).lower() in ("true", "1", "yes") type_text(text, press_enter_after=enter_after) - return f"Typed: {text[:60]}" + return f"Typed: {text[:80]}" if action == "press_key": - key = str(value or params.get("key", "")) + key = str(value or params.get("key", "")).strip() if not key: - return "No key specified, sir." + return "No key specified." press_key(key) return f"Pressed: {key}" if action in ("reload_n", "refresh_n", "reload_page_n"): try: - n = int(value or 1) - reload_page_n(n) - return f"Reloaded page {n} time{'s' if n > 1 else ''}." + reload_page_n(int(value or 1)) + return f"Reloaded {value or 1} time(s)." except Exception as e: - return f"Could not reload: {e}" + return f"Reload failed: {e}" - if action in ("scroll_up", "scroll_down"): - try: - amount = int(value or 500) - scroll_up(amount) if action == "scroll_up" else scroll_down(amount) - return f"Scrolled {'up' if action == 'scroll_up' else 'down'}." - except Exception as e: - return f"Scroll failed: {e}" + if action == "scroll_up": + scroll_up(int(value or 500)) + return "Scrolled up." + + if action == "scroll_down": + scroll_down(int(value or 500)) + return "Scrolled down." func = ACTION_MAP.get(action) if not func: - return f"Unknown action: '{raw_action}', sir." + return f"Unknown action: '{raw_action}'." try: func() return f"Done: {action}." except Exception as e: + print(f"[Settings] Action failed ({action}): {e}") return f"Action failed ({action}): {e}" \ No newline at end of file diff --git a/actions/desktop.py b/actions/desktop.py index a5cfeba..32b1736 100644 --- a/actions/desktop.py +++ b/actions/desktop.py @@ -1,244 +1,325 @@ -# actions/desktop.py -# AI-powered desktop & wallpaper management -# -# Flow for unknown tasks: -# User request → Gemini generates Python/pyautogui code → Safety check → Execute -# -# Built-in: wallpaper change, icon arrangement, desktop cleanup, organize by type - import os import sys import json import shutil import subprocess -import ctypes import tempfile -import pyautogui +import platform from pathlib import Path from datetime import datetime +try: + import pyautogui + _PYAUTOGUI = True +except ImportError: + _PYAUTOGUI = False -def get_base_dir(): +_OS = platform.system() # "Windows" | "Darwin" | "Linux" + + +def _get_base_dir() -> Path: if getattr(sys, "frozen", False): return Path(sys.executable).parent return Path(__file__).resolve().parent.parent -BASE_DIR = get_base_dir() -API_CONFIG_PATH = BASE_DIR / "config" / "api_keys.json" - - def _get_api_key() -> str: - with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: + path = _get_base_dir() / "config" / "api_keys.json" + with open(path, "r", encoding="utf-8") as f: return json.load(f)["gemini_api_key"] - - + def _get_desktop() -> Path: + if _OS == "Linux": + xdg = os.environ.get("XDG_DESKTOP_DIR", "") + if xdg and Path(xdg).exists(): + return Path(xdg) return Path.home() / "Desktop" +def _build_sandbox() -> dict: + import time -BLOCKED_KEYWORDS = [ - "os.remove", "shutil.rmtree", "shutil.rm", - "subprocess.run", "subprocess.Popen", "subprocess.call", - "os.system", "exec(", "eval(", - "import os", "import subprocess", - "__import__", "open(", - "sys.exit", "quit()", -] + safe_builtins = { + "print": print, + "len": len, "str": str, "int": int, "float": float, + "bool": bool, "list": list, "dict": dict, "tuple": tuple, + "range": range, "enumerate": enumerate, "sorted": sorted, + "isinstance": isinstance, "hasattr": hasattr, "getattr": getattr, + "max": max, "min": min, "sum": sum, "abs": abs, + "zip": zip, "map": map, "filter": filter, + } + + sandbox = { + "__builtins__": safe_builtins, + "Path": Path, + "time": time, + "shutil": type("shutil", (), { + "copy2": shutil.copy2, + "copytree": shutil.copytree, + "disk_usage": shutil.disk_usage, + })(), + "os_path": os.path, + } + + if _PYAUTOGUI: + sandbox["pyautogui"] = pyautogui + + if _OS == "Windows": + try: + import ctypes + import winreg + sandbox["ctypes"] = ctypes + sandbox["winreg"] = type("winreg", (), { + # Sadece okuma + "OpenKey": winreg.OpenKey, + "QueryValueEx": winreg.QueryValueEx, + "HKEY_CURRENT_USER": winreg.HKEY_CURRENT_USER, + })() + except ImportError: + pass + + return sandbox -def _is_safe_code(code: str) -> tuple[bool, str]: - code_lower = code.lower() - for keyword in BLOCKED_KEYWORDS: - if keyword.lower() in code_lower: - return False, f"Blocked operation: '{keyword}'" - return True, "OK" +def _execute_generated_code(code: str, player=None) -> str: + if not code or code.strip() == "UNSAFE": + return "This action cannot be performed safely." + + # Kod temizleme + if code.startswith("```"): + lines = code.split("\n") + code = "\n".join(lines[1:-1]).strip() + + sandbox = _build_sandbox() + output_lines = [] + sandbox["__builtins__"]["print"] = lambda *a: output_lines.append(" ".join(str(x) for x in a)) + + try: + exec(compile(code, "", "exec"), sandbox) + return "\n".join(output_lines) if output_lines else "Done." + except Exception as e: + print(f"[Desktop] Exec error: {e}\nCode:\n{code[:300]}") + return f"Execution error: {e}" def _ask_gemini_for_desktop_action(task: str) -> str: - """ - Asks Gemini to generate safe Python/pyautogui code - to accomplish a desktop-related task. - """ - import google.generativeai as genai + import google.generativeai as genai genai.configure(api_key=_get_api_key()) model = genai.GenerativeModel("gemini-2.5-flash") desktop = str(_get_desktop()) - prompt = f"""You are a Windows desktop automation expert. -Generate safe Python code using ONLY these allowed modules: -- pyautogui (mouse, keyboard, screenshots) -- pathlib.Path (already imported as Path) -- shutil (ONLY: copy2, copytree, move, disk_usage) -- os.path (ONLY: exists, join, dirname, basename, splitext) -- time (sleep only) -- ctypes (Windows API calls only) -- winreg (registry READ only) + os_specific = "" + if _OS == "Windows": + os_specific = "- ctypes (Windows API calls, read-only)\n- winreg (registry READ only)" + elif _OS == "Darwin": + os_specific = "- subprocess is NOT available; use pyautogui or Path only" + else: + os_specific = "- subprocess is NOT available; use pyautogui or Path only" + prompt = f"""You are a desktop automation assistant. +Current OS: {_OS} Desktop path: {desktop} -Rules: -- Output ONLY the Python code. No explanation, no markdown, no backticks. -- NO file deletion (os.remove, shutil.rmtree, unlink, etc.) +Generate safe Python code to accomplish the task below. +Allowed modules ONLY: +- pyautogui (mouse, keyboard — if needed) +- pathlib.Path (file/folder inspection only, no deletion) +- shutil.copy2, shutil.copytree, shutil.disk_usage (NO move, NO rmtree) +- os_path (os.path equivalent, read-only) +- time.sleep +{os_specific} + +Hard rules: +- NO file deletion (no unlink, no rmtree, no remove) - NO subprocess calls -- NO exec() or eval() -- NO file write operations -- If task cannot be done safely, output exactly: UNSAFE +- NO exec() or eval() inside the code +- NO import statements (modules are pre-injected) +- NO file write operations except explicitly requested +- If task cannot be done safely with these tools, output exactly: UNSAFE -Task: {task} +Output ONLY the Python code. No explanation, no markdown, no backticks. -Python code:""" +Task: {task}""" try: response = model.generate_content(prompt) code = response.text.strip() if code.startswith("```"): lines = code.split("\n") - code = "\n".join(lines[1:-1]).strip() + code = "\n".join(lines[1:-1]).strip() return code except Exception as e: return f"ERROR: {e}" - -def _execute_generated_code(code: str) -> str: - """Safely executes Gemini-generated desktop automation code.""" - safe, reason = _is_safe_code(code) - if not safe: - return f"⛔ Blocked for safety: {reason}" - - allowed_globals = { - "pyautogui": pyautogui, - "Path": Path, - "shutil": shutil, - "ctypes": ctypes, - "time": __import__("time"), - "os": type("os", (), { - "path": os.path, - "listdir": os.listdir, - "getcwd": os.getcwd, - "environ": os.environ, - })(), - "__builtins__": { - "print": print, - "len": len, - "str": str, - "int": int, - "float": float, - "bool": bool, - "list": list, - "dict": dict, - "range": range, - "enumerate": enumerate, - "sorted": sorted, - "isinstance": isinstance, - "hasattr": hasattr, - "getattr": getattr, - "max": max, - "min": min, - "sum": sum, - } - } - - output_lines = [] - allowed_globals["print"] = lambda *args: output_lines.append(" ".join(str(a) for a in args)) - - try: - exec(code, allowed_globals) - return "\n".join(output_lines) if output_lines else "Task completed successfully." - except Exception as e: - return f"Execution error: {e}\n\nCode attempted:\n{code[:200]}" - def set_wallpaper(image_path: str) -> str: - """Sets desktop wallpaper from a local image path.""" path = Path(image_path).expanduser().resolve() if not path.exists(): return f"Image not found: {image_path}" - if path.suffix.lower() not in [".jpg", ".jpeg", ".png", ".bmp"]: - return f"Unsupported format: {path.suffix}. Use jpg, png or bmp." + if path.suffix.lower() not in {".jpg", ".jpeg", ".png", ".bmp", ".webp"}: + return f"Unsupported format: {path.suffix}. Use jpg, png, bmp or webp." try: - if sys.platform == "win32": - - abs_path = str(path.resolve()) - ctypes.windll.user32.SystemParametersInfoW(20, 0, abs_path, 3) + if _OS == "Windows": + import ctypes + if path.suffix.lower() in {".webp", ".png"}: + try: + from PIL import Image + bmp_path = Path(tempfile.mktemp(suffix=".bmp")) + Image.open(path).convert("RGB").save(bmp_path, "BMP") + path = bmp_path + except ImportError: + pass + ctypes.windll.user32.SystemParametersInfoW(20, 0, str(path), 3) return f"Wallpaper set: {path.name}" - elif sys.platform == "darwin": - script = f'tell application "Finder" to set desktop picture to POSIX file "{path}"' - subprocess.run(["osascript", "-e", script]) + elif _OS == "Darwin": + script = ( + f'tell application "System Events" to tell every desktop to ' + f'set picture to POSIX file "{path}"' + ) + subprocess.run(["osascript", "-e", script], capture_output=True) return f"Wallpaper set: {path.name}" else: - subprocess.run(["gsettings", "set", "org.gnome.desktop.background", - "picture-uri", f"file://{path}"]) + desktop_env = os.environ.get("XDG_CURRENT_DESKTOP", "").lower() + uri = f"file://{path}" + + if "gnome" in desktop_env or "unity" in desktop_env: + subprocess.run([ + "gsettings", "set", "org.gnome.desktop.background", + "picture-uri", uri + ], capture_output=True) + subprocess.run([ + "gsettings", "set", "org.gnome.desktop.background", + "picture-uri-dark", uri + ], capture_output=True) + + elif "kde" in desktop_env: + # KDE Plasma + script = f""" +var allDesktops = desktops(); +for (var i = 0; i < allDesktops.length; i++) {{ + d = allDesktops[i]; + d.wallpaperPlugin = "org.kde.image"; + d.currentConfigGroup = ["Wallpaper", "org.kde.image", "General"]; + d.writeConfig("Image", "file://{path}"); +}} +""" + subprocess.run( + ["qdbus", "org.kde.plasmashell", "/PlasmaShell", + "org.kde.PlasmaShell.evaluateScript", script], + capture_output=True + ) + + elif "xfce" in desktop_env: + subprocess.run([ + "xfconf-query", "-c", "xfce4-desktop", + "-p", "/backdrop/screen0/monitor0/workspace0/last-image", + "-s", str(path) + ], capture_output=True) + + else: + result = subprocess.run( + ["feh", "--bg-scale", str(path)], + capture_output=True + ) + if result.returncode != 0: + return ( + f"Could not set wallpaper automatically on {desktop_env}. " + f"Try manually or install 'feh'." + ) + return f"Wallpaper set: {path.name}" except Exception as e: return f"Could not set wallpaper: {e}" -def set_wallpaper_from_web(url: str) -> str: - """Downloads an image from URL and sets it as wallpaper.""" +def set_wallpaper_from_url(url: str) -> str: try: import urllib.request suffix = Path(url.split("?")[0]).suffix or ".jpg" tmp = Path(tempfile.mktemp(suffix=suffix)) urllib.request.urlretrieve(url, str(tmp)) result = set_wallpaper(str(tmp)) + try: + tmp.unlink() + except Exception: + pass return result except Exception as e: return f"Could not download wallpaper: {e}" def get_current_wallpaper() -> str: - """Returns the current wallpaper path.""" try: - if sys.platform == "win32": + if _OS == "Windows": import winreg - key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, - r"Control Panel\Desktop") + key = winreg.OpenKey( + winreg.HKEY_CURRENT_USER, r"Control Panel\Desktop" + ) val, _ = winreg.QueryValueEx(key, "Wallpaper") + winreg.CloseKey(key) return f"Current wallpaper: {val}" + + elif _OS == "Darwin": + script = ( + 'tell application "System Events" to get picture of desktop 1' + ) + result = subprocess.run( + ["osascript", "-e", script], + capture_output=True, text=True + ) + return f"Current wallpaper: {result.stdout.strip()}" + else: - return "Wallpaper path retrieval not supported on this OS." + desktop_env = os.environ.get("XDG_CURRENT_DESKTOP", "").lower() + if "gnome" in desktop_env or "unity" in desktop_env: + result = subprocess.run( + ["gsettings", "get", "org.gnome.desktop.background", "picture-uri"], + capture_output=True, text=True + ) + return f"Current wallpaper: {result.stdout.strip()}" + return "Wallpaper path retrieval not supported for this desktop environment." + except Exception as e: return f"Could not get wallpaper: {e}" - FILE_TYPE_MAP = { - "Images": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".svg", ".ico", ".heic"], - "Documents": [".pdf", ".doc", ".docx", ".txt", ".xls", ".xlsx", ".ppt", ".pptx", ".csv", ".odt"], - "Videos": [".mp4", ".avi", ".mkv", ".mov", ".wmv", ".flv", ".webm", ".m4v"], - "Music": [".mp3", ".wav", ".flac", ".aac", ".ogg", ".wma", ".m4a"], - "Archives": [".zip", ".rar", ".7z", ".tar", ".gz", ".bz2"], - "Code": [".py", ".js", ".html", ".css", ".json", ".xml", ".ts", ".cpp", ".java", ".cs", ".php"], - "Executables": [".exe", ".msi", ".bat", ".cmd", ".sh"], + "Images": {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".svg", ".ico", ".heic"}, + "Documents": {".pdf", ".doc", ".docx", ".txt", ".xls", ".xlsx", + ".ppt", ".pptx", ".csv", ".odt", ".ods", ".odp"}, + "Videos": {".mp4", ".avi", ".mkv", ".mov", ".wmv", ".flv", ".webm", ".m4v"}, + "Music": {".mp3", ".wav", ".flac", ".aac", ".ogg", ".wma", ".m4a"}, + "Archives": {".zip", ".rar", ".7z", ".tar", ".gz", ".bz2", ".xz"}, + "Code": {".py", ".js", ".ts", ".html", ".css", ".json", ".xml", + ".cpp", ".java", ".cs", ".go", ".rs", ".sh", ".php"}, + "Executables": {".exe", ".msi", ".bat", ".cmd", ".sh", ".appimage", ".deb", ".rpm"}, +} + +_SKIP_EXTENSIONS = { + "Windows": {".lnk", ".url"}, + "Darwin": {".webloc"}, + "Linux": {".desktop"}, } def organize_desktop(mode: str = "by_type") -> str: - """ - Organizes desktop files. - mode: 'by_type' — groups by file type (Images, Documents, etc.) - 'by_date' — groups by month (2024-01, 2024-02, etc.) - """ - desktop = _get_desktop() - moved = [] - skipped = [] + desktop = _get_desktop() + skip_exts = _SKIP_EXTENSIONS.get(_OS, set()) + moved, skipped = [], [] for item in desktop.iterdir(): if item.is_dir() or item.name.startswith("."): continue - - if item.suffix.lower() == ".lnk": + if item.suffix.lower() in skip_exts: continue if mode == "by_date": - mtime = datetime.fromtimestamp(item.stat().st_mtime) + mtime = datetime.fromtimestamp(item.stat().st_mtime) folder_name = mtime.strftime("%Y-%m") else: - ext = item.suffix.lower() + ext = item.suffix.lower() folder_name = "Others" for folder, exts in FILE_TYPE_MAP.items(): if ext in exts: @@ -256,31 +337,34 @@ def organize_desktop(mode: str = "by_type") -> str: shutil.move(str(item), str(new_path)) moved.append(f"{item.name} → {folder_name}/") - result = f"Desktop organized ({mode}). {len(moved)} files moved." + result = f"Desktop organized ({mode}): {len(moved)} files moved." if moved: - preview = moved[:8] - result += "\n" + "\n".join(preview) + result += "\n" + "\n".join(moved[:8]) if len(moved) > 8: - result += f"\n... and {len(moved)-8} more." + result += f"\n... and {len(moved) - 8} more." if skipped: - result += f"\n{len(skipped)} files skipped (name conflict)." + result += f"\n{len(skipped)} file(s) skipped (name conflict)." return result def list_desktop() -> str: - """Lists everything on the desktop.""" desktop = _get_desktop() items = [] - for item in sorted(desktop.iterdir()): if item.name.startswith("."): continue if item.is_dir(): - count = len(list(item.iterdir())) + try: + count = len(list(item.iterdir())) + except PermissionError: + count = "?" items.append(f"📁 {item.name}/ ({count} items)") else: - size = item.stat().st_size - size_str = f"{size/1024:.1f} KB" if size < 1024*1024 else f"{size/1024/1024:.1f} MB" + size = item.stat().st_size + size_str = ( + f"{size / 1024:.1f} KB" if size < 1024 * 1024 + else f"{size / 1024 / 1024:.1f} MB" + ) items.append(f"📄 {item.name} ({size_str})") if not items: @@ -289,11 +373,8 @@ def list_desktop() -> str: def clean_desktop() -> str: - """ - Moves all files on desktop into a 'Desktop Archive' folder - with today's date — fast cleanup without deleting anything. - """ desktop = _get_desktop() + skip_exts = _SKIP_EXTENSIONS.get(_OS, set()) today = datetime.now().strftime("%Y-%m-%d") archive_dir = desktop / f"Desktop Archive {today}" archive_dir.mkdir(exist_ok=True) @@ -302,116 +383,98 @@ def clean_desktop() -> str: for item in desktop.iterdir(): if item.is_dir() or item.name.startswith("."): continue - if item.suffix.lower() == ".lnk": + if item.suffix.lower() in skip_exts: continue new_path = archive_dir / item.name if not new_path.exists(): shutil.move(str(item), str(new_path)) moved += 1 - return f"Desktop cleaned. {moved} files moved to '{archive_dir.name}'." + return f"Desktop cleaned: {moved} files archived to '{archive_dir.name}'." def get_desktop_stats() -> str: - """Returns stats about the desktop.""" - desktop = _get_desktop() - files = [i for i in desktop.iterdir() if i.is_file()] - folders = [i for i in desktop.iterdir() if i.is_dir()] - total_size = sum(f.stat().st_size for f in files) - size_str = f"{total_size/1024:.1f} KB" if total_size < 1024*1024 else f"{total_size/1024/1024:.1f} MB" - + desktop = _get_desktop() + files = [i for i in desktop.iterdir() if i.is_file()] + folders = [i for i in desktop.iterdir() if i.is_dir()] + total_size = sum(f.stat().st_size for f in files if f.exists()) + size_str = ( + f"{total_size / 1024:.1f} KB" if total_size < 1024 * 1024 + else f"{total_size / 1024 / 1024:.1f} MB" + ) return ( - f"Desktop stats:\n" + f"Desktop stats ({_OS}):\n" f" Files : {len(files)}\n" f" Folders : {len(folders)}\n" - f" Total size: {size_str}" + f" Size : {size_str}\n" + f" Path : {desktop}" ) - def desktop_control( - parameters: dict, + parameters: dict = None, response=None, player=None, - session_memory=None + session_memory=None, ) -> str: """ - Called from main.py. - parameters: - action : wallpaper | wallpaper_url | current_wallpaper | - organize | clean | list | stats | - task (AI-powered — anything else) - - path : image path for 'wallpaper' - url : image URL for 'wallpaper_url' - mode : 'by_type' or 'by_date' for 'organize' - task : Natural language description for AI-powered actions. - Example: "arrange icons by size" - "show me what's on my desktop" - "move all screenshots to a folder" + action : wallpaper | wallpaper_url | current_wallpaper | + organize | clean | list | stats | + task (AI-powered) + path : image path for 'wallpaper' + url : image URL for 'wallpaper_url' + mode : 'by_type' or 'by_date' for 'organize' + task : natural language description for AI-powered actions """ - action = (parameters or {}).get("action", "").lower().strip() - task = (parameters or {}).get("task", "").strip() + params = parameters or {} + action = params.get("action", "").lower().strip() + task = params.get("task", "").strip() - result = "Unknown action." + if player: + player.write_log(f"[desktop] {action or task[:40]}") try: if action == "wallpaper": - path = parameters.get("path", "") - result = set_wallpaper(path) if path else "No image path provided." + path = params.get("path", "") + return set_wallpaper(path) if path else "No image path provided." elif action == "wallpaper_url": - url = parameters.get("url", "") - result = set_wallpaper_from_web(url) if url else "No URL provided." + url = params.get("url", "") + return set_wallpaper_from_url(url) if url else "No URL provided." elif action == "current_wallpaper": - result = get_current_wallpaper() + return get_current_wallpaper() elif action == "organize": - mode = parameters.get("mode", "by_type") - result = organize_desktop(mode) + return organize_desktop(params.get("mode", "by_type")) elif action == "clean": - result = clean_desktop() + return clean_desktop() elif action == "list": - result = list_desktop() + return list_desktop() elif action == "stats": - result = get_desktop_stats() + return get_desktop_stats() elif action == "task" or task: - actual_task = task or parameters.get("description", "") + actual_task = task or params.get("description", "") if not actual_task: - return "Please describe what you want to do on the desktop, sir." + return "Please describe what you want to do on the desktop." - print(f"[Desktop] 🤖 Asking Gemini: {actual_task}") + print(f"[Desktop] Asking Gemini: {actual_task}") if player: player.write_log("[Desktop] Generating action...") code = _ask_gemini_for_desktop_action(actual_task) - - if code == "UNSAFE": - result = "I cannot perform that desktop action safely, sir." - elif code.startswith("ERROR:"): - result = f"Could not generate action: {code}" - else: - print(f"[Desktop] ✅ Generated code:\n{code[:200]}") - result = _execute_generated_code(code) + return _execute_generated_code(code, player=player) else: - full_task = task or action - if full_task: - code = _ask_gemini_for_desktop_action(full_task) - result = _execute_generated_code(code) if code not in ("UNSAFE",) else "Cannot do that safely." - else: - result = "No action or task specified." + if action: + code = _ask_gemini_for_desktop_action(action) + return _execute_generated_code(code, player=player) + return "No action or task specified." except Exception as e: - result = f"Desktop control error: {e}" - - print(f"[Desktop] {result[:100]}") - if player: - player.write_log(f"[desktop] {result[:60]}") - - return result \ No newline at end of file + print(f"[Desktop] Error: {e}") + return f"Desktop control error: {e}" \ No newline at end of file diff --git a/actions/dev_agent.py b/actions/dev_agent.py index cce8f4f..67a10fe 100644 --- a/actions/dev_agent.py +++ b/actions/dev_agent.py @@ -1,15 +1,3 @@ -# actions/dev_agent.py -# AI-powered development agent — plans, builds, and debugs full projects. -# -# Flow: -# Describe project → Gemini plans file structure → Files written one by one -# → VSCode opened → Entry point executed → Error? → Identify file → Fix → Retry -# → Speaks only when done (success or failure) -# -# Models: -# Planning : gemini-2.5-flash (architecture, structure, debugging) -# Writing : gemini-2.5-flash-lite (fast file generation) - import subprocess import sys import json @@ -17,18 +5,19 @@ import re import time from pathlib import Path + def get_base_dir(): if getattr(sys, "frozen", False): return Path(sys.executable).parent return Path(__file__).resolve().parent.parent -BASE_DIR = get_base_dir() -API_CONFIG_PATH = BASE_DIR / "config" / "api_keys.json" -PROJECTS_DIR = Path.home() / "Desktop" / "JarvisProjects" -MAX_FIX_ATTEMPTS = 4 -MODEL_PLANNER = "gemini-2.5-flash" -MODEL_WRITER = "gemini-2.5-flash-lite" +BASE_DIR = get_base_dir() +API_CONFIG_PATH = BASE_DIR / "config" / "api_keys.json" +PROJECTS_DIR = Path.home() / "Desktop" / "JarvisProjects" +MAX_FIX_ATTEMPTS = 5 +MODEL_PLANNER = "gemini-2.5-flash" +MODEL_WRITER = "gemini-2.5-flash" def _get_api_key() -> str: with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: @@ -41,157 +30,198 @@ def _get_model(model_name: str): return genai.GenerativeModel(model_name) -def _clean_code(text: str) -> str: +def _strip_fences(text: str) -> str: text = text.strip() - text = re.sub(r"^```[a-zA-Z]*\n?", "", text) - text = re.sub(r"\n?```$", "", text) - return text.strip() - - -def _clean_json(text: str) -> str: - text = text.strip() - text = re.sub(r"^```[a-zA-Z]*\n?", "", text) - text = re.sub(r"\n?```$", "", text) + text = re.sub(r"^```[a-zA-Z]*\r?\n?", "", text) + text = re.sub(r"\r?\n?```\s*$", "", text) return text.strip() def _is_rate_limit(error: Exception) -> bool: - return "429" in str(error) or "quota" in str(error).lower() + msg = str(error).lower() + return "429" in msg or "quota" in msg or "resource_exhausted" in msg -def _get_interpreter(path: Path) -> list[str] | None: - return { - ".py": [sys.executable], - ".js": ["node"], - ".ts": ["ts-node"], - ".sh": ["bash"], - ".ps1": ["powershell", "-File"], - ".rb": ["ruby"], - ".php": ["php"], - }.get(path.suffix.lower()) +def _parse_traceback(output: str, project_files: list[str]) -> tuple[str | None, int | None]: + + pattern = re.compile(r'File ["\']([^"\']+\.py)["\'],\s+line\s+(\d+)', re.IGNORECASE) + matches = pattern.findall(output) + + for raw_path, line_str in reversed(matches): + raw_name = Path(raw_path).name + for pf in project_files: + if Path(pf).name == raw_name or pf == raw_path or raw_path.endswith(pf): + return pf, int(line_str) + + return None, None -def _has_error(output: str) -> bool: - if "timed out" in output.lower(): +def _classify_error(output: str) -> str: + + low = output.lower() + + if any(x in low for x in ("no module named", "modulenotfounderror", "importerror")): + return "dependency_error" + + if "syntaxerror" in low or "invalid syntax" in low: + return "syntax_error" + + if "cannot import" in low or "importerror" in low: + return "import_error" + + if any(x in low for x in ( + "traceback", "exception", "error:", "nameerror", "typeerror", + "attributeerror", "valueerror", "keyerror", "indexerror", + "zerodivisionerror", "filenotfounderror", "permissionerror", + )): + return "runtime_error" + + return "none" + + +def _has_error(output: str, run_command: str) -> bool: + + low = output.lower() + + if "timed out" in low: return False - signals = ["error", "exception", "traceback", "syntaxerror", - "nameerror", "typeerror", "importerror", "stderr", "failed"] - return any(s in output.lower() for s in signals) -def _identify_error_file(error_output: str, project_files: list[str]) -> str | None: - """ - Try to find which file caused the error from traceback. - Returns filename or None. - """ - for line in error_output.splitlines(): - for f in project_files: - if Path(f).name in line or f in line: - return f - return None + if not output.strip(): + return False + + error_type = _classify_error(output) + return error_type != "none" + +class RateLimitError(Exception): + pass + def _plan_project(description: str, language: str) -> dict: - """ - Ask Gemini to plan the full project structure. - - Returns: - { - "project_name": "my_app", - "entry_point": "main.py", - "files": [ - { - "path": "main.py", - "description": "Entry point, starts the app" - }, - { - "path": "utils/helpers.py", - "description": "Utility functions" - } - ], - "run_command": "python main.py", - "dependencies": ["requests", "flask"] - } - """ model = _get_model(MODEL_PLANNER) - prompt = f"""You are a senior software architect. -Plan the complete file structure for the following project. + prompt = f"""You are a senior software architect. Create a minimal, complete file plan for this project. Language: {language} Description: {description} -Return ONLY a valid JSON object with this exact structure: +Return ONLY valid JSON — no markdown, no explanation: {{ - "project_name": "short_snake_case_name", + "project_name": "snake_case_name", "entry_point": "main.py", "files": [ - {{"path": "main.py", "description": "what this file does"}}, - {{"path": "utils/helpers.py", "description": "what this file does"}} + {{ + "path": "main.py", + "description": "Entry point — what it does and which modules it imports", + "imports": ["utils.helpers", "core.engine"] + }}, + {{ + "path": "utils/helpers.py", + "description": "Helper utilities — what functions it exposes", + "imports": [] + }} ], "run_command": "python main.py", - "dependencies": ["package1", "package2"] + "dependencies": ["requests"] }} -Rules: -- Keep it simple. Only include files that are truly necessary. -- No explanation, no markdown, no backticks. Pure JSON only. -- Entry point must be one of the files listed. -- Use relative paths only. +Critical rules: +1. List files in DEPENDENCY ORDER — files with no imports come first, entry point comes last. +2. The "imports" field must list every other project module this file imports (dot-notation, e.g. "utils.helpers"). +3. Keep it minimal — only files truly needed. +4. Entry point must be in the files list. +5. Use relative paths only (e.g. "utils/helpers.py", not absolute paths). +6. Standard library modules (os, sys, json, etc.) do NOT go in "dependencies". JSON:""" try: response = model.generate_content(prompt) - raw = _clean_json(response.text) + raw = _strip_fences(response.text) return json.loads(raw) except json.JSONDecodeError as e: raise ValueError(f"Planner returned invalid JSON: {e}\nRaw: {response.text[:300]}") - + except Exception as e: + if _is_rate_limit(e): + raise RateLimitError(str(e)) + raise def _write_file( - file_path: str, - file_description: str, + file_info: dict, project_description: str, all_files: list[dict], language: str, - project_dir: Path + project_dir: Path, + already_written: dict[str, str], ) -> str: - """Write one file. Returns the generated code.""" model = _get_model(MODEL_WRITER) + file_path = file_info["path"] + file_desc = file_info.get("description", "") + file_imports = file_info.get("imports", []) + file_list = "\n".join( - f" - {f['path']}: {f['description']}" for f in all_files + f" [{i+1}] {f['path']}: {f.get('description', '')}" + for i, f in enumerate(all_files) ) - prompt = f"""You are an expert {language} developer. -Write the code for ONE specific file in a larger project. + dependency_context = "" + for dep_dotted in file_imports: + dep_path = dep_dotted.replace(".", "/") + ".py" + if dep_path in already_written: + code_snippet = already_written[dep_path][:2000] + dependency_context += f"\n\n--- {dep_path} (you must import from this) ---\n{code_snippet}" + + lang_rules = "" + if language.lower() == "python": + lang_rules = """ +Python-specific rules: +- Use type hints for all function signatures. +- Add docstrings for all public functions and classes. +- Use if __name__ == "__main__": guard in the entry point. +- For relative imports within the project, use: from utils.helpers import foo (match the project structure exactly). +- Do NOT use implicit relative imports (from . import ...) unless it's a proper package with __init__.py. +- If this is a package subdirectory, create __init__.py files where needed.""" + elif language.lower() in ("javascript", "typescript", "js", "ts"): + lang_rules = """ +JS/TS-specific rules: +- Use ES modules (import/export), not CommonJS (require). +- Add JSDoc comments for all exported functions. +- Handle promise rejections with try/catch in async functions.""" + + prompt = f"""You are a senior {language} developer writing production-quality code for a real project. Project goal: {project_description} -All files in this project: +Complete project file structure (in dependency order): {file_list} -Now write ONLY the file: {file_path} -Purpose of this file: {file_description} +{f"Dependencies this file must import from other project files:{dependency_context}" if dependency_context else ""} -Rules: -- Output ONLY the code for this file. No explanation, no markdown, no backticks. -- Import from other project files using relative imports where needed. -- Add helpful inline comments. -- Handle errors properly. -- Use modern best practices. +Your task: Write the complete, working code for: {file_path} +Purpose of this file: {file_desc} +{f"This file imports from: {', '.join(file_imports)}" if file_imports else "This file has no project-internal imports."} + +{lang_rules} + +General rules: +- Output ONLY raw code. Absolutely no explanation, no markdown, no triple backticks. +- Write COMPLETE, RUNNABLE code — no placeholders, no "# TODO", no "pass" stubs. +- Every import must either be from the standard library, listed dependencies, or the project files shown above. +- Match import paths EXACTLY to the file paths in the project structure (e.g. if file is "utils/helpers.py", import as "from utils.helpers import ..."). +- Use proper error handling (try/except) where I/O or network calls are made. +- The code must work correctly when the project entry point is run from the project root directory. Code for {file_path}:""" try: response = model.generate_content(prompt) - code = _clean_code(response.text) + code = _strip_fences(response.text) - # Save file full_path = project_dir / file_path full_path.parent.mkdir(parents=True, exist_ok=True) full_path.write_text(code, encoding="utf-8") - print(f"[DevAgent] ✅ Written: {file_path}") + print(f"[DevAgent] ✅ Written: {file_path} ({len(code)} chars)") return code except Exception as e: @@ -199,149 +229,214 @@ Code for {file_path}:""" raise RateLimitError(str(e)) raise - def _install_dependencies(dependencies: list[str], project_dir: Path) -> str: if not dependencies: - return "No dependencies to install." + return "No external dependencies." - print(f"[DevAgent] 📦 Installing: {dependencies}") + to_install = [] + for dep in dependencies: + pkg_name = re.split(r"[>= bool: - vscode_paths = [ + vscode_candidates = [ "code", - r"C:\Users\{}\AppData\Local\Programs\Microsoft VS Code\bin\code.cmd".format( - Path.home().name - ), + rf"C:\Users\{Path.home().name}\AppData\Local\Programs\Microsoft VS Code\bin\code.cmd", + r"C:\Program Files\Microsoft VS Code\bin\code.cmd", ] - for cmd in vscode_paths: + for cmd in vscode_candidates: try: subprocess.Popen( [cmd, str(project_dir)], + shell=True, stdout=subprocess.DEVNULL, - stderr=subprocess.DEVNULL, - shell=True + stderr=subprocess.DEVNULL ) - time.sleep(2) + time.sleep(1.5) print(f"[DevAgent] 💻 VSCode opened: {project_dir}") return True except Exception: continue - print("[DevAgent] ⚠️ VSCode not found.") return False - def _run_project(run_command: str, project_dir: Path, timeout: int = 30) -> str: - """Run the project entry point, return output.""" print(f"[DevAgent] 🚀 Running: {run_command}") - try: parts = run_command.split() - if parts[0] == "python": + if parts[0].lower() == "python": parts[0] = sys.executable result = subprocess.run( parts, capture_output=True, text=True, encoding="utf-8", errors="replace", - timeout=timeout, cwd=str(project_dir) + timeout=timeout, + cwd=str(project_dir) ) - output = result.stdout.strip() - error = result.stderr.strip() + stdout = result.stdout.strip() + stderr = result.stderr.strip() - parts_out = [] - if output: parts_out.append(f"Output:\n{output}") - if error: parts_out.append(f"Stderr:\n{error}") - return "\n\n".join(parts_out) if parts_out else "Ran with no output." + combined_parts = [] + if stdout: + combined_parts.append(f"STDOUT:\n{stdout}") + if stderr: + combined_parts.append(f"STDERR:\n{stderr}") + + return "\n\n".join(combined_parts) if combined_parts else "Ran with no output." except subprocess.TimeoutExpired: - return f"Timed out after {timeout}s. (Long-running app may be working fine.)" + return f"Timed out after {timeout}s — long-running app (server/GUI) is likely working." except FileNotFoundError as e: return f"Command not found: {e}" except Exception as e: return f"Run error: {e}" -def _fix_file( - file_path: str, - current_code: str, +def _try_auto_install(error_output: str, project_dir: Path) -> bool: + """ModuleNotFoundError varsa eksik paketi otomatik kurmaya çalışır.""" + pattern = re.compile( + r"No module named ['\"]([a-zA-Z0-9_\-\.]+)['\"]", re.IGNORECASE + ) + match = pattern.search(error_output) + if not match: + return False + + pkg = match.group(1).replace("_", "-").split(".")[0] + print(f"[DevAgent] 🔧 Auto-installing missing package: {pkg}") + try: + result = subprocess.run( + [sys.executable, "-m", "pip", "install", pkg], + capture_output=True, text=True, + encoding="utf-8", errors="replace", + timeout=60, cwd=str(project_dir) + ) + return result.returncode == 0 + except Exception: + return False + +def _fix_files( error_output: str, project_description: str, all_files: list[dict], + file_codes: dict[str, str], language: str, - project_dir: Path -) -> str: - """Ask Gemini to fix a specific file based on error output.""" + project_dir: Path, + entry_point: str, +) -> dict[str, str]: + model = _get_model(MODEL_PLANNER) - file_list = "\n".join( - f" - {f['path']}: {f['description']}" for f in all_files - ) + error_file, error_line = _parse_traceback(error_output, list(file_codes.keys())) + error_type = _classify_error(error_output) - prompt = f"""You are an expert {language} debugger. -Fix the file below. It caused an error when the project was run. + files_to_fix: list[str] = [] + + if error_file: + files_to_fix.append(error_file) + if error_type == "import_error": + for fi in all_files: + if error_file.replace("/", ".").replace(".py", "") in fi.get("imports", []): + p = fi["path"] + if p not in files_to_fix: + files_to_fix.append(p) + else: + files_to_fix.append(entry_point) + + updated_codes: dict[str, str] = {} + + for fix_path in files_to_fix: + current_code = file_codes.get(fix_path, "") + + other_ctx = "" + for fp, code in file_codes.items(): + if fp != fix_path and code: + snippet = code[:1500] + ("..." if len(code) > 1500 else "") + other_ctx += f"\n--- {fp} ---\n{snippet}\n" + + line_hint = f"\nError appears to be near line {error_line} in this file." if ( + error_line and fix_path == error_file + ) else "" + + prompt = f"""You are an expert {language} debugger. Fix the broken file below. Project goal: {project_description} -All files in this project: -{file_list} +All project files: +{chr(10).join(f" - {f['path']}: {f.get('description', '')}" for f in all_files)} -File to fix: {file_path} +Other files for context (read-only — fix only the target file): +{other_ctx[:3500]} + +File to fix: {fix_path}{line_hint} +Error type: {error_type} Error output: -{error_output[:3000]} +{error_output[:2500]} -Current code: +Current (broken) code: {current_code} -Return ONLY the fixed code — no explanation, no markdown, no backticks. +Rules: +- Output ONLY the complete fixed code. No explanation, no markdown, no backticks. +- Fix ALL errors visible in the error output. +- Keep all existing correct logic — do not remove working features. +- Ensure import paths match the actual project file structure exactly. +- Do NOT introduce new bugs or remove error handling. -Fixed code:""" +Fixed code for {fix_path}:""" - try: - response = model.generate_content(prompt) - fixed = _clean_code(response.text) + try: + response = model.generate_content(prompt) + fixed = _strip_fences(response.text) - full_path = project_dir / file_path - full_path.write_text(fixed, encoding="utf-8") + full_path = project_dir / fix_path + full_path.parent.mkdir(parents=True, exist_ok=True) + full_path.write_text(fixed, encoding="utf-8") - print(f"[DevAgent] 🔧 Fixed: {file_path}") - return fixed + updated_codes[fix_path] = fixed + print(f"[DevAgent] 🔧 Fixed: {fix_path}") - except Exception as e: - if _is_rate_limit(e): - raise RateLimitError(str(e)) - raise + except Exception as e: + if _is_rate_limit(e): + raise RateLimitError(str(e)) + print(f"[DevAgent] ⚠️ Could not fix {fix_path}: {e}") + + return updated_codes -class RateLimitError(Exception): - pass def _build_project( description: str, language: str, project_name: str, timeout: int, speak=None, - player=None + player=None, ) -> str: - """ - Full build loop: - Plan → Write files → Install deps → Open VSCode → Run → Fix loop - """ def log(msg: str): print(f"[DevAgent] {msg}") @@ -352,7 +447,7 @@ def _build_project( try: plan = _plan_project(description, language) except RateLimitError: - msg = "You have reached the rate limit, sir. Please try again shortly." + msg = "Rate limit reached, sir. Please try again in a moment." if speak: speak(msg) return msg except ValueError as e: @@ -360,64 +455,78 @@ def _build_project( if speak: speak(msg) return msg - proj_name = project_name or plan.get("project_name", "jarvis_project") - proj_name = re.sub(r"[^\w\-]", "_", proj_name) - project_dir = PROJECTS_DIR / proj_name + proj_name = project_name or plan.get("project_name", "jarvis_project") + proj_name = re.sub(r"[^\w\-]", "_", proj_name) + project_dir = PROJECTS_DIR / proj_name project_dir.mkdir(parents=True, exist_ok=True) - files = plan.get("files", []) - entry_point = plan.get("entry_point", "main.py") - run_command = plan.get("run_command", f"python {entry_point}") + files = plan.get("files", []) + entry_point = plan.get("entry_point", "main.py") + run_command = plan.get("run_command", f"python {entry_point}") dependencies = plan.get("dependencies", []) log(f"Project: {proj_name} | Files: {len(files)} | Entry: {entry_point}") + def _dep_sort_key(fi: dict) -> int: + return len(fi.get("imports", [])) + + sorted_files = sorted(files, key=_dep_sort_key) + file_codes: dict[str, str] = {} - for file_info in files: + for file_info in sorted_files: file_path = file_info.get("path", "") - file_desc = file_info.get("description", "") if not file_path: continue log(f"Writing {file_path}...") - try: - code = _write_file( - file_path, file_desc, description, - files, language, project_dir - ) - file_codes[file_path] = code - except RateLimitError: - msg = "You have reached the rate limit, sir. Please try again shortly." - if speak: speak(msg) - return msg - except Exception as e: - log(f"Failed to write {file_path}: {e}") - continue + for attempt in range(2): + try: + code = _write_file( + file_info=file_info, + project_description=description, + all_files=files, + language=language, + project_dir=project_dir, + already_written=file_codes, + ) + file_codes[file_path] = code + time.sleep(0.4) + break + except RateLimitError: + if attempt == 0: + log("Rate limit — waiting 20s...") + time.sleep(20) + else: + log(f"Rate limit retry failed for {file_path}, skipping.") + except Exception as e: + log(f"Failed to write {file_path}: {e}") + break if not file_codes: - msg = "I could not write any files for this project, sir." + msg = "I could not write any project files, sir." if speak: speak(msg) return msg if dependencies: - log(f"Installing dependencies: {dependencies}") - _install_dependencies(dependencies, project_dir) + install_result = _install_dependencies(dependencies, project_dir) + log(install_result) _open_vscode(project_dir) - last_output = "" + last_output = "" + auto_installs = 0 + for attempt in range(1, MAX_FIX_ATTEMPTS + 1): log(f"Running project (attempt {attempt}/{MAX_FIX_ATTEMPTS})...") - last_output = _run_project(run_command, project_dir, timeout) - log(f"Output: {last_output[:150]}") + log(f"Output preview: {last_output[:150]}") - if not _has_error(last_output): + if not _has_error(last_output, run_command): msg = ( f"Project '{proj_name}' is working, sir. " f"Built in {attempt} attempt{'s' if attempt > 1 else ''}. " - f"Opened in VSCode at {project_dir}." + f"Saved to: {project_dir}" ) if speak: speak(msg) return f"{msg}\n\nOutput:\n{last_output}" @@ -425,53 +534,50 @@ def _build_project( if attempt == MAX_FIX_ATTEMPTS: break - error_file = _identify_error_file(last_output, list(file_codes.keys())) - if not error_file: - error_file = entry_point - - log(f"Error in '{error_file}', fixing...") + error_type = _classify_error(last_output) + if error_type == "dependency_error" and auto_installs < 3: + installed = _try_auto_install(last_output, project_dir) + if installed: + auto_installs += 1 + log("Missing dependency installed, retrying...") + time.sleep(1) + continue + log(f"Fixing errors (type: {error_type})...") try: - fixed = _fix_file( - error_file, - file_codes.get(error_file, ""), - last_output, - description, - files, - language, - project_dir + updated = _fix_files( + error_output=last_output, + project_description=description, + all_files=files, + file_codes=file_codes, + language=language, + project_dir=project_dir, + entry_point=entry_point, ) - file_codes[error_file] = fixed + file_codes.update(updated) + time.sleep(1) except RateLimitError: - msg = "You have reached the rate limit, sir. Please try again shortly." + msg = "Rate limit reached during fix. Project saved, check it manually in VSCode." if speak: speak(msg) return msg except Exception as e: - log(f"Fix failed: {e}") + log(f"Fix step failed: {e}") msg = ( - f"I was unable to get '{proj_name}' working after {MAX_FIX_ATTEMPTS} attempts, sir. " - f"The project is saved at {project_dir} — you can open it in VSCode and check manually." + f"I couldn't fully fix '{proj_name}' after {MAX_FIX_ATTEMPTS} attempts, sir. " + f"Project is saved at {project_dir} — open it in VSCode and check manually." ) if speak: speak(msg) - return f"{msg}\n\nLast error:\n{last_output[:500]}" + return f"{msg}\n\nLast error:\n{last_output[:600]}" + def dev_agent( parameters: dict, response=None, player=None, session_memory=None, - speak=None + speak=None, ) -> str: - """ - Called from main.py. - - parameters: - description : What the project should do (required) - language : Programming language (default: python) - project_name : Optional folder name (auto-generated if not given) - timeout : Run timeout in seconds (default: 30) - """ p = parameters or {} description = p.get("description", "").strip() language = p.get("language", "python").strip() @@ -487,5 +593,5 @@ def dev_agent( project_name = project_name, timeout = timeout, speak = speak, - player = player + player = player, ) \ No newline at end of file diff --git a/actions/file_controller.py b/actions/file_controller.py index 1dc5b64..97663f0 100644 --- a/actions/file_controller.py +++ b/actions/file_controller.py @@ -1,32 +1,83 @@ -# actions/file_controller.py -# File management — create, delete, move, rename, list, find, organize - +import os import shutil +import platform from pathlib import Path from datetime import datetime -import send2trash + +try: + import send2trash + _SEND2TRASH = True +except ImportError: + _SEND2TRASH = False + +_OS = platform.system() # "Windows" | "Darwin" | "Linux" + +_SAFE_ROOTS: list[Path] = [ + Path.home(), +] + +def _is_safe_path(target: Path) -> bool: + """Verilen path _SAFE_ROOTS içinde mi? Değilse işlemi reddet.""" + try: + resolved = target.resolve() + return any( + resolved == root.resolve() or resolved.is_relative_to(root.resolve()) + for root in _SAFE_ROOTS + ) + except Exception: + return False def _get_desktop() -> Path: - """Returns desktop path — works on Windows, Mac, Linux.""" + if _OS == "Linux": + xdg = os.environ.get("XDG_DESKTOP_DIR", "") + if xdg and Path(xdg).exists(): + return Path(xdg) return Path.home() / "Desktop" - def _get_downloads() -> Path: + if _OS == "Linux": + xdg = os.environ.get("XDG_DOWNLOAD_DIR", "") + if xdg and Path(xdg).exists(): + return Path(xdg) return Path.home() / "Downloads" +def _get_documents() -> Path: + if _OS == "Linux": + xdg = os.environ.get("XDG_DOCUMENTS_DIR", "") + if xdg and Path(xdg).exists(): + return Path(xdg) + return Path.home() / "Documents" + +def _get_pictures() -> Path: + if _OS == "Linux": + xdg = os.environ.get("XDG_PICTURES_DIR", "") + if xdg and Path(xdg).exists(): + return Path(xdg) + return Path.home() / "Pictures" + +def _get_music() -> Path: + if _OS == "Linux": + xdg = os.environ.get("XDG_MUSIC_DIR", "") + if xdg and Path(xdg).exists(): + return Path(xdg) + return Path.home() / "Music" + +def _get_videos() -> Path: + if _OS == "Linux": + xdg = os.environ.get("XDG_VIDEOS_DIR", "") + if xdg and Path(xdg).exists(): + return Path(xdg) + return Path.home() / "Videos" + def _resolve_path(raw: str) -> Path: - """ - Resolves a path from user input. - Supports shortcuts: 'desktop', 'downloads', 'documents', 'home' - """ - shortcuts = { - "desktop": Path.home() / "Desktop", - "downloads": Path.home() / "Downloads", - "documents": Path.home() / "Documents", - "pictures": Path.home() / "Pictures", - "music": Path.home() / "Music", - "videos": Path.home() / "Videos", + shortcuts: dict[str, Path] = { + "desktop": _get_desktop(), + "downloads": _get_downloads(), + "documents": _get_documents(), + "pictures": _get_pictures(), + "music": _get_music(), + "videos": _get_videos(), "home": Path.home(), } lower = raw.strip().lower() @@ -34,20 +85,30 @@ def _resolve_path(raw: str) -> Path: return shortcuts[lower] return Path(raw).expanduser() - -def _format_size(bytes_size: int) -> str: - """Converts bytes to human readable format.""" +def _format_size(b: int) -> str: for unit in ["B", "KB", "MB", "GB", "TB"]: - if bytes_size < 1024: - return f"{bytes_size:.1f} {unit}" - bytes_size /= 1024 - return f"{bytes_size:.1f} TB" + if b < 1024: + return f"{b:.1f} {unit}" + b /= 1024 + return f"{b:.1f} TB" + +def _safe_trash(target: Path) -> str: + + if not _SEND2TRASH: + return ( + "send2trash is not installed. " + "Run: pip install send2trash — " + "Permanent deletion is disabled for safety." + ) + send2trash.send2trash(str(target)) + return f"Moved to Trash: {target.name}" def list_files(path: str = "desktop", show_hidden: bool = False) -> str: - """Lists files and folders in a directory.""" try: target = _resolve_path(path) + if not _is_safe_path(target): + return f"Access denied: {target}" if not target.exists(): return f"Path not found: {target}" if not target.is_dir(): @@ -64,7 +125,7 @@ def list_files(path: str = "desktop", show_hidden: bool = False) -> str: items.append(f"📄 {item.name} ({size})") if not items: - return f"Directory is empty: {target}" + return f"Directory is empty: {target.name}/" return f"Contents of {target.name}/ ({len(items)} items):\n" + "\n".join(items) @@ -74,10 +135,12 @@ def list_files(path: str = "desktop", show_hidden: bool = False) -> str: return f"Error listing files: {e}" -def create_file(path: str, content: str = "") -> str: - """Creates a new file with optional content.""" +def create_file(path: str, name: str = "", content: str = "") -> str: try: - target = Path(path).expanduser() + base = _resolve_path(path) + target = (base / name) if name else base + if not _is_safe_path(target): + return f"Access denied: {target}" target.parent.mkdir(parents=True, exist_ok=True) target.write_text(content, encoding="utf-8") return f"File created: {target.name}" @@ -85,40 +148,36 @@ def create_file(path: str, content: str = "") -> str: return f"Could not create file: {e}" -def create_folder(path: str) -> str: - """Creates a new folder (and parent folders if needed).""" +def create_folder(path: str, name: str = "") -> str: try: - target = Path(path).expanduser() + base = _resolve_path(path) + target = (base / name) if name else base + if not _is_safe_path(target): + return f"Access denied: {target}" target.mkdir(parents=True, exist_ok=True) - return f"Folder created: {target}" + return f"Folder created: {target.name}" except Exception as e: return f"Could not create folder: {e}" -def delete_file(path: str, confirm: bool = True) -> str: - """ - Deletes a file or folder. - Moves to Recycle Bin on Windows if possible, otherwise permanent delete. - """ +def delete_file(path: str, name: str = "") -> str: try: - target = Path(path).expanduser() + base = _resolve_path(path) + target = (base / name) if name else base + if not _is_safe_path(target): + return f"Access denied: {target}" if not target.exists(): - return f"Not found: {path}" + return f"Not found: {target.name}" - try: + # Güvenli dizin kontrolü — kritik kullanıcı klasörlerini koru + protected = { + _get_desktop(), _get_downloads(), _get_documents(), + _get_pictures(), _get_music(), _get_videos(), Path.home() + } + if target.resolve() in {p.resolve() for p in protected}: + return f"Protected directory, cannot delete: {target.name}" - send2trash.send2trash(str(target)) - return f"Moved to Recycle Bin: {target.name}" - except ImportError: - pass - - # Fallback: permanent delete - if target.is_dir(): - shutil.rmtree(target) - return f"Folder deleted permanently: {target.name}" - else: - target.unlink() - return f"File deleted permanently: {target.name}" + return _safe_trash(target) except PermissionError: return f"Permission denied: {path}" @@ -126,14 +185,20 @@ def delete_file(path: str, confirm: bool = True) -> str: return f"Could not delete: {e}" -def move_file(source: str, destination: str) -> str: - """Moves a file or folder to a new location.""" +def move_file(path: str, name: str = "", destination: str = "") -> str: try: - src = Path(source).expanduser() - dst = _resolve_path(destination) + base = _resolve_path(path) + src = (base / name) if name else base + dst = _resolve_path(destination) if destination else None if not src.exists(): - return f"Source not found: {source}" + return f"Source not found: {src.name}" + if dst is None: + return "No destination specified." + if not _is_safe_path(src): + return f"Access denied (source): {src}" + if not _is_safe_path(dst): + return f"Access denied (destination): {dst}" if dst.is_dir(): dst = dst / src.name @@ -146,14 +211,20 @@ def move_file(source: str, destination: str) -> str: return f"Could not move: {e}" -def copy_file(source: str, destination: str) -> str: - """Copies a file or folder.""" +def copy_file(path: str, name: str = "", destination: str = "") -> str: try: - src = Path(source).expanduser() - dst = _resolve_path(destination) + base = _resolve_path(path) + src = (base / name) if name else base + dst = _resolve_path(destination) if destination else None if not src.exists(): - return f"Source not found: {source}" + return f"Source not found: {src.name}" + if dst is None: + return "No destination specified." + if not _is_safe_path(src): + return f"Access denied (source): {src}" + if not _is_safe_path(dst): + return f"Access denied (destination): {dst}" if dst.is_dir(): dst = dst / src.name @@ -171,16 +242,20 @@ def copy_file(source: str, destination: str) -> str: return f"Could not copy: {e}" -def rename_file(path: str, new_name: str) -> str: - """Renames a file or folder.""" +def rename_file(path: str, name: str = "", new_name: str = "") -> str: try: - target = Path(path).expanduser() - new_path = target.parent / new_name - + base = _resolve_path(path) + target = (base / name) if name else base + if not _is_safe_path(target): + return f"Access denied: {target}" if not target.exists(): - return f"Not found: {path}" + return f"Not found: {target.name}" + if not new_name: + return "No new name provided." + + new_path = target.parent / new_name if new_path.exists(): - return f"A file named '{new_name}' already exists." + return f"A file named '{new_name}' already exists here." target.rename(new_path) return f"Renamed: {target.name} → {new_name}" @@ -189,28 +264,33 @@ def rename_file(path: str, new_name: str) -> str: return f"Could not rename: {e}" -def read_file(path: str, max_chars: int = 3000) -> str: - """Reads and returns the content of a text file.""" +def read_file(path: str, name: str = "", max_chars: int = 4000) -> str: try: - target = Path(path).expanduser() + base = _resolve_path(path) + target = (base / name) if name else base + if not _is_safe_path(target): + return f"Access denied: {target}" if not target.exists(): - return f"File not found: {path}" + return f"File not found: {target.name}" if not target.is_file(): - return f"Not a file: {path}" + return f"Not a file: {target.name}" content = target.read_text(encoding="utf-8", errors="ignore") if len(content) > max_chars: - content = content[:max_chars] + f"\n\n... (truncated, {len(content)} total chars)" + content = content[:max_chars] + f"\n\n[Truncated — {len(content)} total chars]" return content except Exception as e: return f"Could not read file: {e}" -def write_file(path: str, content: str, append: bool = False) -> str: - """Writes or appends content to a file.""" +def write_file(path: str, name: str = "", content: str = "", + append: bool = False) -> str: try: - target = Path(path).expanduser() + base = _resolve_path(path) + target = (base / name) if name else base + if not _is_safe_path(target): + return f"Access denied: {target}" target.parent.mkdir(parents=True, exist_ok=True) mode = "a" if append else "w" with open(target, mode, encoding="utf-8") as f: @@ -221,28 +301,35 @@ def write_file(path: str, content: str, append: bool = False) -> str: return f"Could not write file: {e}" -def find_files(name: str = "", extension: str = "", path: str = "home", - max_results: int = 20) -> str: - """ - Searches for files by name or extension. - Example: find_files(extension=".pdf", path="documents") - """ +def find_files(name: str = "", extension: str = "", + path: str = "home", max_results: int = 20) -> str: try: search_path = _resolve_path(path) + if not _is_safe_path(search_path): + return f"Access denied: {search_path}" if not search_path.exists(): return f"Search path not found: {path}" - results = [] - pattern = f"*{extension}" if extension else "*" + results = [] + dir_count = 0 + max_dirs = 500 # performans + güvenlik limiti - for item in search_path.rglob(pattern): - if item.is_file(): - if name and name.lower() not in item.name.lower(): - continue - size = _format_size(item.stat().st_size) - results.append(f"📄 {item.name} ({size}) — {item.parent}") - if len(results) >= max_results: + for item in search_path.rglob("*"): + if item.is_dir(): + dir_count += 1 + if dir_count > max_dirs: break + continue + if not item.is_file(): + continue + if extension and item.suffix.lower() != extension.lower(): + continue + if name and name.lower() not in item.name.lower(): + continue + size = _format_size(item.stat().st_size) + results.append(f"📄 {item.name} ({size}) — {item.parent}") + if len(results) >= max_results: + break if not results: query = name or extension or "files" @@ -254,10 +341,12 @@ def find_files(name: str = "", extension: str = "", path: str = "home", return f"Search error: {e}" -def get_largest_files(path: str = "home", count: int = 10) -> str: - """Returns the largest files in a directory.""" +def get_largest_files(path: str = "downloads", count: int = 10) -> str: + count = min(count, 50) # maksimum 50 try: search_path = _resolve_path(path) + if not _is_safe_path(search_path): + return f"Access denied: {search_path}" if not search_path.exists(): return f"Path not found: {path}" @@ -275,7 +364,7 @@ def get_largest_files(path: str = "home", count: int = 10) -> str: if not top: return "No files found." - lines = [f"Top {len(top)} largest files in {search_path.name}/:\n"] + lines = [f"Top {len(top)} largest files in {search_path.name}/:"] for size, f in top: lines.append(f" {_format_size(size):>10} {f.name} ({f.parent})") @@ -286,60 +375,50 @@ def get_largest_files(path: str = "home", count: int = 10) -> str: def get_disk_usage(path: str = "home") -> str: - """Returns disk usage information.""" try: target = _resolve_path(path) usage = shutil.disk_usage(target) - total = _format_size(usage.total) - used = _format_size(usage.used) - free = _format_size(usage.free) pct = usage.used / usage.total * 100 - return ( - f"Disk usage for {target}:\n" - f" Total : {total}\n" - f" Used : {used} ({pct:.1f}%)\n" - f" Free : {free}" + f"Disk usage ({target}):\n" + f" Total : {_format_size(usage.total)}\n" + f" Used : {_format_size(usage.used)} ({pct:.1f}%)\n" + f" Free : {_format_size(usage.free)}" ) except Exception as e: return f"Could not get disk usage: {e}" def organize_desktop() -> str: - """ - Organizes the desktop by grouping files into folders by type. - Creates folders: Images, Documents, Videos, Music, Archives, Others - """ + type_map = { + "Images": {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".svg", ".ico", ".heic"}, + "Documents": {".pdf", ".doc", ".docx", ".txt", ".xls", ".xlsx", + ".ppt", ".pptx", ".csv", ".odt", ".ods", ".odp"}, + "Videos": {".mp4", ".avi", ".mkv", ".mov", ".wmv", ".flv", ".webm", ".m4v"}, + "Music": {".mp3", ".wav", ".flac", ".aac", ".ogg", ".wma", ".m4a"}, + "Archives": {".zip", ".rar", ".7z", ".tar", ".gz", ".bz2", ".xz"}, + "Code": {".py", ".js", ".ts", ".html", ".css", ".json", ".xml", + ".cpp", ".java", ".cs", ".go", ".rs", ".sh"}, + } + + desktop = _get_desktop() + moved, skipped = [], [] + try: - desktop = _get_desktop() - type_map = { - "Images": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".svg", ".ico"], - "Documents": [".pdf", ".doc", ".docx", ".txt", ".xls", ".xlsx", ".ppt", ".pptx", ".csv"], - "Videos": [".mp4", ".avi", ".mkv", ".mov", ".wmv", ".flv", ".webm"], - "Music": [".mp3", ".wav", ".flac", ".aac", ".ogg", ".wma"], - "Archives": [".zip", ".rar", ".7z", ".tar", ".gz"], - "Code": [".py", ".js", ".html", ".css", ".json", ".xml", ".ts", ".cpp", ".java"], - } - - moved = [] - skipped = [] - for item in desktop.iterdir(): - + # Klasörlere, gizli dosyalara ve organize klasörlerine dokunma if item.is_dir() or item.name.startswith("."): continue + if item.name in {k for k in type_map}: + continue ext = item.suffix.lower() - target_dir = None - - for folder, extensions in type_map.items(): - if ext in extensions: + target_dir = desktop / "Others" + for folder, exts in type_map.items(): + if ext in exts: target_dir = desktop / folder break - if target_dir is None: - target_dir = desktop / "Others" - target_dir.mkdir(exist_ok=True) new_path = target_dir / item.name @@ -350,133 +429,115 @@ def organize_desktop() -> str: shutil.move(str(item), str(new_path)) moved.append(f"{item.name} → {target_dir.name}/") - result = f"Desktop organized. {len(moved)} files moved." + result = f"Desktop organized: {len(moved)} files moved." if moved: - result += "\n" + "\n".join(moved[:10]) - if len(moved) > 10: - result += f"\n... and {len(moved)-10} more." + preview = moved[:8] + result += "\n" + "\n".join(preview) + if len(moved) > 8: + result += f"\n... and {len(moved) - 8} more." if skipped: - result += f"\n{len(skipped)} files skipped (already exist)." - + result += f"\n{len(skipped)} file(s) skipped (name conflict)." return result except Exception as e: return f"Could not organize desktop: {e}" -def get_file_info(path: str) -> str: - """Returns detailed information about a file.""" +def get_file_info(path: str, name: str = "") -> str: try: - target = Path(path).expanduser() + base = _resolve_path(path) + target = (base / name) if name else base + if not _is_safe_path(target): + return f"Access denied: {target}" if not target.exists(): - return f"Not found: {path}" + return f"Not found: {target.name}" stat = target.stat() info = { - "Name": target.name, - "Type": "Folder" if target.is_dir() else "File", - "Size": _format_size(stat.st_size), - "Location": str(target.parent), - "Created": datetime.fromtimestamp(stat.st_ctime).strftime("%Y-%m-%d %H:%M"), - "Modified": datetime.fromtimestamp(stat.st_mtime).strftime("%Y-%m-%d %H:%M"), - "Extension": target.suffix or "None", + "Name": target.name, + "Type": "Folder" if target.is_dir() else "File", + "Size": _format_size(stat.st_size), + "Location": str(target.parent), + "Created": datetime.fromtimestamp(stat.st_ctime).strftime("%Y-%m-%d %H:%M"), + "Modified": datetime.fromtimestamp(stat.st_mtime).strftime("%Y-%m-%d %H:%M"), + "Extension": target.suffix or "—", } - return "\n".join(f" {k}: {v}" for k, v in info.items()) except Exception as e: return f"Could not get file info: {e}" def file_controller( - parameters: dict, + parameters: dict = None, response=None, player=None, - session_memory=None + session_memory=None, ) -> str: - action = (parameters or {}).get("action", "").lower().strip() - path = (parameters or {}).get("path", "desktop") - name = (parameters or {}).get("name", "") - content = (parameters or {}).get("content", "") + params = parameters or {} + action = params.get("action", "").lower().strip() + path = params.get("path", "desktop") + name = params.get("name", "") - def _full_path(p: str, n: str) -> str: - base = _resolve_path(p) - if n: - return str(base / n) - return str(base) - - result = "Unknown action." + if player: + player.write_log(f"[file] {action} {name or path}") try: if action == "list": - result = list_files(path) + return list_files(path) elif action == "create_file": - full = _full_path(path, name) - result = create_file(full, content=content) + return create_file(path, name=name, content=params.get("content", "")) elif action == "create_folder": - full = _full_path(path, name) - result = create_folder(full) + return create_folder(path, name=name) elif action == "delete": - full = _full_path(path, name) - result = delete_file(full) + return delete_file(path, name=name) elif action == "move": - full = _full_path(path, name) - result = move_file(full, parameters.get("destination", "")) + return move_file(path, name=name, destination=params.get("destination", "")) elif action == "copy": - full = _full_path(path, name) - result = copy_file(full, parameters.get("destination", "")) + return copy_file(path, name=name, destination=params.get("destination", "")) elif action == "rename": - full = _full_path(path, name) - result = rename_file(full, parameters.get("new_name", "")) + return rename_file(path, name=name, new_name=params.get("new_name", "")) elif action == "read": - full = _full_path(path, name) - result = read_file(full) + return read_file(path, name=name) elif action == "write": - full = _full_path(path, name) - result = write_file( - full, - content=content, - append=parameters.get("append", False) + return write_file( + path, name=name, + content=params.get("content", ""), + append=params.get("append", False) ) elif action == "find": - result = find_files( - name=name or parameters.get("name", ""), - extension=parameters.get("extension", ""), + return find_files( + name=name or params.get("name", ""), + extension=params.get("extension", ""), path=path, - max_results=parameters.get("max_results", 20) + max_results=min(int(params.get("max_results", 20)), 50), ) elif action == "largest": - result = get_largest_files( + return get_largest_files( path=path, - count=parameters.get("count", 10) + count=int(params.get("count", 10)), ) elif action == "disk_usage": - result = get_disk_usage(path) + return get_disk_usage(path) elif action == "organize_desktop": - result = organize_desktop() + return organize_desktop() elif action == "info": - full = _full_path(path, name) - result = get_file_info(full) + return get_file_info(path, name=name) else: - result = f"Unknown action: '{action}'" + return f"Unknown action: '{action}'" except Exception as e: - result = f"File controller error: {e}" - - if player: - player.write_log(f"[file] {result[:60]}") - - return result \ No newline at end of file + return f"File controller error ({action}): {e}" \ No newline at end of file diff --git a/actions/flight_finder.py b/actions/flight_finder.py index 5722d49..58d5bad 100644 --- a/actions/flight_finder.py +++ b/actions/flight_finder.py @@ -1,37 +1,19 @@ -# actions/flight_finder.py -# MARK XXV — Flight Finder -# -# Searches for flights using Google Flights via browser_control. -# Results are spoken by JARVIS. Optionally saved to Notepad or opened in browser. -# -# Flow: -# 1. Parse origin, destination, date, passengers from parameters -# 2. Open Google Flights via browser_control -# 3. Fill in search fields -# 4. Scrape results via get_text -# 5. Parse with Gemini → structured flight data -# 6. Speak top results -# 7. Optionally save to Notepad or keep browser open -# -# Cross-platform: Windows, macOS, Linux -# No API key required — Google Flights is free to access - import json import re -import sys import subprocess -import platform +import sys from datetime import datetime, timedelta from pathlib import Path +from config import is_windows, is_mac, is_linux -def get_base_dir() -> Path: +def _get_base_dir() -> Path: if getattr(sys, "frozen", False): return Path(sys.executable).parent return Path(__file__).resolve().parent.parent -BASE_DIR = get_base_dir() +BASE_DIR = _get_base_dir() API_CONFIG_PATH = BASE_DIR / "config" / "api_keys.json" @@ -39,34 +21,42 @@ def _get_api_key() -> str: with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: return json.load(f)["gemini_api_key"] +_MONTH_MAP: dict[str, int] = { + + "january": 1, "february": 2, "march": 3, "april": 4, + "may": 5, "june": 6, "july": 7, "august": 8, + "september": 9, "october": 10, "november": 11, "december": 12, + "ocak": 1, "şubat": 2, "mart": 3, "nisan": 4, + "mayıs": 5, "haziran": 6, "temmuz": 7, "ağustos": 8, + "eylül": 9, "ekim": 10, "kasım": 11, "aralık": 12, +} + +_RELATIVE_MAP_KEYS = { + "today", "bugün", + "tomorrow", "yarın", +} + def _parse_date(raw: str) -> str: - """ - Converts natural language date to YYYY-MM-DD. - Handles: '15 Mart', 'March 15', '2025-03-15', 'next friday', etc. - Falls back to Gemini for ambiguous inputs. - """ - raw = raw.strip() + + raw = raw.strip() + lower = raw.lower() + today = datetime.now() if re.match(r"\d{4}-\d{2}-\d{2}", raw): return raw - for fmt in ("%d/%m/%Y", "%m/%d/%Y", "%d.%m.%Y", "%d-%m-%Y"): try: return datetime.strptime(raw, fmt).strftime("%Y-%m-%d") except ValueError: pass - - today = datetime.now() - lower = raw.lower() - relative_map = { - "today": today, - "tomorrow": today + timedelta(days=1), - "bugün": today, - "yarın": today + timedelta(days=1), + relative = { + "today": today, "bugün": today, + "tomorrow": today + timedelta(days=1), + "yarın": today + timedelta(days=1), } - for key, val in relative_map.items(): + for key, val in relative.items(): if key in lower: return val.strftime("%Y-%m-%d") @@ -74,27 +64,18 @@ def _parse_date(raw: str) -> str: import google.generativeai as genai genai.configure(api_key=_get_api_key()) model = genai.GenerativeModel("gemini-2.5-flash-lite") - today_str = today.strftime("%Y-%m-%d") response = model.generate_content( - f"Today is {today_str}. Convert this date to YYYY-MM-DD format: '{raw}'. " + f"Today is {today.strftime('%Y-%m-%d')}. " + f"Convert this date expression to YYYY-MM-DD: '{raw}'. " f"Return ONLY the date string, nothing else." ) result = response.text.strip() if re.match(r"\d{4}-\d{2}-\d{2}", result): return result - except Exception: - pass + except Exception as e: + print(f"[FlightFinder] ⚠️ Gemini date parse failed: {e}") - month_map = { - "january": 1, "february": 2, "march": 3, "april": 4, - "may": 5, "june": 6, "july": 7, "august": 8, - "september": 9,"october": 10, "november": 11, "december": 12, - "january": 1, "ocak": 1, "şubat": 2, "mart": 3, - "nisan": 4, "mayıs": 5, "haziran": 6, "temmuz": 7, - "ağustos": 8, "eylül": 9, "ekim": 10, "kasım": 11, - "aralık": 12, - } - for month_name, month_num in month_map.items(): + for month_name, month_num in _MONTH_MAP.items(): if month_name in lower: day_match = re.search(r"\d{1,2}", raw) if day_match: @@ -102,8 +83,16 @@ def _parse_date(raw: str) -> str: year = today.year if month_num >= today.month else today.year + 1 return f"{year}-{month_num:02d}-{day:02d}" + # Last resort: today + print(f"[FlightFinder] ⚠️ Could not parse date '{raw}' — using today.") return today.strftime("%Y-%m-%d") +_CABIN_CODE: dict[str, str] = { + "economy": "1", + "premium": "2", + "business": "3", + "first": "4", +} def _build_google_flights_url( @@ -114,33 +103,23 @@ def _build_google_flights_url( passengers: int = 1, cabin: str = "economy", ) -> str: - """ - Builds a Google Flights URL with pre-filled search parameters. - Uses the direct search URL format. - """ - cabin_map = { - "economy": "1", - "premium": "2", - "business": "3", - "first": "4", - } - cabin_code = cabin_map.get(cabin.lower(), "1") - - base = "https://www.google.com/travel/flights" + cabin_code = _CABIN_CODE.get(cabin.lower(), "1") + base = "https://www.google.com/travel/flights" + # Google Flights accepts these query params for pre-filling if return_date: - url = ( - f"{base}?q=Flights+from+{origin}+to+{destination}" - f"+on+{date}+returning+{return_date}" - f"&curr=TRY" - ) + trip = f"Flights+from+{origin}+to+{destination}+on+{date}+returning+{return_date}" else: - url = ( - f"{base}?q=Flights+from+{origin}+to+{destination}+on+{date}" - f"&curr=TRY" - ) + trip = f"Flights+from+{origin}+to+{destination}+on+{date}" - return url + return ( + f"{base}" + f"?q={trip}" + f"&tfs=CBwQAhoeEgoyMDI1LTAzLTE1agcIARIDSVNUcgcIARIDTEhS" + f"&curr=USD" + f"&cabin={cabin_code}" + f"&adults={passengers}" + ) @@ -152,12 +131,8 @@ def _search_flights_browser( passengers: int, cabin: str, ) -> tuple[str, str]: - """ - Opens Google Flights in browser, waits for results, scrapes text. - Returns (raw_text, page_url). - """ - from actions.browser_control import browser_control import time + from actions.browser_control import browser_control url = _build_google_flights_url( origin, destination, date, return_date, passengers, cabin @@ -165,11 +140,10 @@ def _search_flights_browser( print(f"[FlightFinder] 🌐 Opening: {url}") browser_control({"action": "go_to", "url": url}) - time.sleep(5) - - result = browser_control({"action": "get_text"}) - return result or "", url + time.sleep(5) + raw = browser_control({"action": "get_text"}) + return (raw or ""), url def _parse_flights_with_gemini( raw_text: str, @@ -177,10 +151,6 @@ def _parse_flights_with_gemini( destination: str, date: str, ) -> list[dict]: - """ - Sends raw page text to Gemini and extracts structured flight data. - Returns list of flight dicts. - """ import google.generativeai as genai genai.configure(api_key=_get_api_key()) @@ -189,47 +159,41 @@ def _parse_flights_with_gemini( system_instruction=( "You are a flight data extraction expert. " "Extract flight information from raw webpage text. " - "Return ONLY valid JSON array. No explanation, no markdown." - ) + "Return ONLY valid JSON — no markdown, no explanation." + ), ) - truncated = raw_text[:12000] - prompt = ( f"Extract flight options from {origin} to {destination} on {date} " - f"from this Google Flights page text:\n\n{truncated}\n\n" + f"from this Google Flights page text:\n\n{raw_text[:12000]}\n\n" f"Return a JSON array of up to 5 flights:\n" - f'[{{"airline": "...", "departure": "HH:MM", "arrival": "HH:MM", ' - f'"duration": "Xh Ym", "stops": 0, "price": "...", "currency": "..."}}]\n' + f'[{{"airline":"...","departure":"HH:MM","arrival":"HH:MM",' + f'"duration":"Xh Ym","stops":0,"price":"...","currency":"USD"}}]\n' f"If no flights found, return: []" ) try: response = model.generate_content(prompt) - text = response.text.strip() - text = re.sub(r"```(?:json)?", "", text).strip().rstrip("`").strip() + text = re.sub(r"```(?:json)?", "", response.text).strip().rstrip("`").strip() flights = json.loads(text) return flights if isinstance(flights, list) else [] except Exception as e: - print(f"[FlightFinder] ⚠️ Parse failed: {e}") + print(f"[FlightFinder] ⚠️ Gemini parse failed: {e}") return [] - - def _format_spoken( flights: list[dict], origin: str, destination: str, date: str, ) -> str: - """Formats flights for spoken output — concise and natural.""" if not flights: return ( f"I couldn't find any flights from {origin} to {destination} " f"on {date}, sir. The page may not have loaded correctly." ) - lines = [f"Here are the flights from {origin} to {destination} on {date}, sir."] + lines = [f"Here are the top flights from {origin} to {destination} on {date}, sir."] for i, f in enumerate(flights[:5], 1): airline = f.get("airline", "Unknown airline") @@ -245,16 +209,17 @@ def _format_spoken( dur_str = f", {duration}" if duration else "" lines.append( - f"Option {i}: {airline}, departing {departure}, arriving {arrival}" - f"{dur_str}, {stop_str}, {price_str}." + f"Option {i}: {airline}, departing {departure}, " + f"arriving {arrival}{dur_str}, {stop_str}, {price_str}." ) - cheapest = min( - (f for f in flights if f.get("price")), - key=lambda x: re.sub(r"[^\d]", "", str(x.get("price", "99999"))) or "99999", - default=None, - ) - if cheapest: + # Cheapest — strip non-digits for comparison + priced = [f for f in flights if f.get("price")] + if priced: + cheapest = min( + priced, + key=lambda x: int(re.sub(r"[^\d]", "", str(x["price"])) or "999999"), + ) lines.append( f"The cheapest option is {cheapest.get('airline')} " f"at {cheapest.get('price')} {cheapest.get('currency', '')}." @@ -263,7 +228,7 @@ def _format_spoken( return " ".join(lines) -def _format_notepad( +def _format_text_report( flights: list[dict], origin: str, destination: str, @@ -271,9 +236,6 @@ def _format_notepad( return_date: str | None, page_url: str, ) -> str: - """Formats flights for Notepad — detailed and readable.""" - from datetime import datetime as dt - lines = [ "JARVIS — Flight Search Results", "─" * 50, @@ -283,7 +245,7 @@ def _format_notepad( if return_date: lines.append(f"Return : {return_date}") lines += [ - f"Searched : {dt.now().strftime('%Y-%m-%d %H:%M')}", + f"Searched : {datetime.now().strftime('%Y-%m-%d %H:%M')}", f"Source : {page_url}", "─" * 50, "", @@ -297,10 +259,10 @@ def _format_notepad( stop_str = "Non-stop" if stops == 0 else f"{stops} stop(s)" lines += [ f"Flight {i}:", - f" Airline : {f.get('airline', 'N/A')}", + f" Airline : {f.get('airline', 'N/A')}", f" Departure : {f.get('departure', 'N/A')}", - f" Arrival : {f.get('arrival', 'N/A')}", - f" Duration : {f.get('duration', 'N/A')}", + f" Arrival : {f.get('arrival', 'N/A')}", + f" Duration : {f.get('duration', 'N/A')}", f" Stops : {stop_str}", f" Price : {f.get('price', 'N/A')} {f.get('currency', '')}", "", @@ -308,11 +270,7 @@ def _format_notepad( return "\n".join(lines) - -def _save_to_notepad(content: str, origin: str, destination: str) -> str: - """Saves flight results to Desktop and opens in default text editor.""" - from datetime import datetime - +def _save_to_desktop(content: str, origin: str, destination: str) -> str: ts = datetime.now().strftime("%Y%m%d_%H%M%S") filename = f"flights_{origin}_{destination}_{ts}.txt".replace(" ", "_") desktop = Path.home() / "Desktop" @@ -322,58 +280,39 @@ def _save_to_notepad(content: str, origin: str, destination: str) -> str: filepath.write_text(content, encoding="utf-8") print(f"[FlightFinder] 💾 Saved: {filepath}") - system = platform.system() - open_fn = { - "Windows": lambda p: subprocess.Popen(["notepad.exe", str(p)]), - "Darwin": lambda p: subprocess.Popen(["open", "-t", str(p)]), - "Linux": lambda p: subprocess.Popen(["xdg-open", str(p)]), - } - opener = open_fn.get(system) - if opener: - opener(filepath) + try: + if is_windows(): + subprocess.Popen(["notepad.exe", str(filepath)]) + elif is_mac(): + subprocess.Popen(["open", "-t", str(filepath)]) + else: + subprocess.Popen(["xdg-open", str(filepath)]) + except Exception as e: + print(f"[FlightFinder] ⚠️ Could not open text editor: {e}") return str(filepath) -def flight_finder( - parameters: dict, - response=None, - player=None, - session_memory=None, - speak=None, -) -> str: - """ - Flight Finder — searches Google Flights and speaks results. - Parameters: - origin (str, required) — departure city or airport (e.g. "Istanbul", "IST") - destination (str, required) — arrival city or airport (e.g. "London", "LHR") - date (str, required) — departure date (any format: "15 Mart", "March 15", "2025-03-15") - return_date (str, optional) — return date for round trips - passengers (int, optional) — number of passengers (default: 1) - cabin (str, optional) — economy | premium | business | first (default: economy) - save (bool, optional) — save results to Notepad (default: False) - show_browser (bool, optional) — keep browser open after search (default: True) - - Examples: - flight_finder({"origin": "Istanbul", "destination": "London", "date": "15 Mart"}) - flight_finder({"origin": "IST", "destination": "JFK", "date": "2025-04-01", - "return_date": "2025-04-15", "cabin": "business", "save": True}) - """ +def flight_finder(parameters: dict, player=None, speak=None) -> str: params = parameters or {} origin = params.get("origin", "").strip() destination = params.get("destination", "").strip() date_raw = params.get("date", "").strip() - return_raw = params.get("return_date", "").strip() - passengers = int(params.get("passengers", 1)) - cabin = params.get("cabin", "economy").strip() - save = params.get("save", False) + return_raw = (params.get("return_date") or "").strip() + passengers = max(1, int(params.get("passengers", 1))) + cabin = params.get("cabin", "economy").strip().lower() + save = bool(params.get("save", False)) if not origin or not destination: return "Please provide both origin and destination, sir." if not date_raw: return "Please provide a departure date, sir." + # Normalise cabin value + if cabin not in _CABIN_CODE: + cabin = "economy" + date = _parse_date(date_raw) return_date = _parse_date(return_raw) if return_raw else None @@ -383,10 +322,13 @@ def flight_finder( if speak: speak(f"Searching flights from {origin} to {destination} on {date}, sir.") - print(f"[FlightFinder] ▶️ {origin} → {destination} | {date} | {cabin} | {passengers} pax") + print( + f"[FlightFinder] ▶️ {origin} → {destination} | {date}" + f"{' → ' + return_date if return_date else ''}" + f" | {cabin} | {passengers} pax" + ) try: - raw_text, page_url = _search_flights_browser( origin, destination, date, return_date, passengers, cabin ) @@ -395,25 +337,23 @@ def flight_finder( return "Could not retrieve flight data, sir. The page may not have loaded." if speak: - speak("Analysing the results now.") + speak("Analysing the results now, sir.") flights = _parse_flights_with_gemini(raw_text, origin, destination, date) + spoken = _format_spoken(flights, origin, destination, date) - spoken = _format_spoken(flights, origin, destination, date) if speak: speak(spoken) result = spoken if save and flights: - notepad_content = _format_notepad( - flights, origin, destination, date, return_date, page_url - ) - saved_path = _save_to_notepad(notepad_content, origin, destination) - result += f" Results saved to Desktop: {saved_path}" + report = _format_text_report(flights, origin, destination, date, return_date, page_url) + saved_path = _save_to_desktop(report, origin, destination) + result += f" Results saved to Desktop: {saved_path}" return result except Exception as e: - print(f"[FlightFinder] ❌ Error: {e}") + print(f"[FlightFinder] ❌ {e}") return f"Flight search failed, sir: {e}" \ No newline at end of file diff --git a/actions/game_updater.py b/actions/game_updater.py new file mode 100644 index 0000000..cdba419 --- /dev/null +++ b/actions/game_updater.py @@ -0,0 +1,1048 @@ +import os +import re +import sys +import json +import time +import subprocess +import threading +from pathlib import Path +from datetime import datetime + +from config import get_os, is_windows, is_mac, is_linux + +_KNOWN_APPIDS: dict[str, tuple[str, str]] = { + "pubg": ("578080", "PUBG: Battlegrounds"), + "pubg battlegrounds": ("578080", "PUBG: Battlegrounds"), + "pubg: battlegrounds": ("578080", "PUBG: Battlegrounds"), + "battlegrounds": ("578080", "PUBG: Battlegrounds"), + "gta5": ("271590", "Grand Theft Auto V"), + "gta v": ("271590", "Grand Theft Auto V"), + "grand theft auto v": ("271590", "Grand Theft Auto V"), + "cs2": ("730", "Counter-Strike 2"), + "csgo": ("730", "Counter-Strike 2"), + "counter-strike 2": ("730", "Counter-Strike 2"), + "counter strike 2": ("730", "Counter-Strike 2"), + "dota2": ("570", "Dota 2"), + "dota 2": ("570", "Dota 2"), + "rust": ("252490", "Rust"), + "valheim": ("892970", "Valheim"), + "cyberpunk": ("1091500", "Cyberpunk 2077"), + "cyberpunk 2077": ("1091500", "Cyberpunk 2077"), + "elden ring": ("1245620", "ELDEN RING"), + "minecraft": ("1672970", "Minecraft Launcher"), + "apex legends": ("1172470", "Apex Legends"), + "apex": ("1172470", "Apex Legends"), + "fortnite": ("1517990", "Fortnite"), + "goose goose duck": ("1568590", "Goose Goose Duck"), + "among us": ("945360", "Among Us"), + "fall guys": ("1097150", "Fall Guys"), + "rocket league": ("252950", "Rocket League"), + "warframe": ("230410", "Warframe"), + "destiny 2": ("1085660", "Destiny 2"), + "team fortress 2": ("440", "Team Fortress 2"), + "tf2": ("440", "Team Fortress 2"), + "left 4 dead 2": ("550", "Left 4 Dead 2"), + "l4d2": ("550", "Left 4 Dead 2"), + "paladins": ("444090", "Paladins"), + "smite": ("386360", "SMITE"), + "war thunder": ("236390", "War Thunder"), + "world of warships": ("552990", "World of Warships"), + "path of exile": ("238960", "Path of Exile"), + "poe": ("238960", "Path of Exile"), + "lost ark": ("1599340", "Lost Ark"), + "new world": ("1063730", "New World: Aeternum"), +} + +def _find_steam_path() -> Path | None: + if is_windows(): return _find_steam_windows() + if is_mac(): return _find_steam_mac() + return _find_steam_linux() + + +def _find_steam_windows() -> Path | None: + try: + import winreg + for hive, key_path in [ + (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\WOW6432Node\Valve\Steam"), + (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Valve\Steam"), + (winreg.HKEY_CURRENT_USER, r"SOFTWARE\Valve\Steam"), + ]: + try: + key = winreg.OpenKey(hive, key_path) + val, _ = winreg.QueryValueEx(key, "InstallPath") + winreg.CloseKey(key) + p = Path(val) + if p.exists() and (p / "steam.exe").exists(): + return p + except Exception: + continue + except ImportError: + pass + for p in [ + Path(os.environ.get("ProgramFiles(x86)", "")) / "Steam", + Path(os.environ.get("ProgramFiles", "")) / "Steam", + Path("C:/Steam"), Path("D:/Steam"), Path("E:/Steam"), Path("F:/Steam"), + ]: + if p.exists() and (p / "steam.exe").exists(): + return p + return None + + +def _find_steam_mac() -> Path | None: + for p in [ + Path.home() / "Library" / "Application Support" / "Steam", + Path("/Applications/Steam.app/Contents/MacOS"), + ]: + if p.exists(): + return p + return None + + +def _find_steam_linux() -> Path | None: + for p in [ + Path.home() / ".steam" / "steam", + Path.home() / ".steam" / "root", + Path.home() / ".local" / "share" / "Steam", + Path("/usr/share/steam"), + Path("/opt/steam"), + ]: + if p.exists(): + return p + return None + + +def _steam_exe(steam_path: Path) -> Path: + if is_windows(): return steam_path / "steam.exe" + if is_mac(): return Path("/Applications/Steam.app/Contents/MacOS/steam_osx") + return steam_path / "steam.sh" + + +def _launch_steam_url(exe: Path, url: str) -> None: + if is_mac(): + subprocess.Popen(["open", url]) + elif is_linux(): + subprocess.Popen(["xdg-open", url]) + else: + subprocess.Popen([str(exe), url]) + +def _get_steam_libraries(steam_path: Path) -> list[Path]: + libraries = [steam_path / "steamapps"] + vdf_path = steam_path / "steamapps" / "libraryfolders.vdf" + if not vdf_path.exists(): + return libraries + try: + content = vdf_path.read_text(encoding="utf-8", errors="ignore") + for raw_path in re.findall(r'"path"\s+"([^"]+)"', content): + lib = Path(raw_path.replace("\\\\", "/")) / "steamapps" + if lib.exists() and lib not in libraries: + libraries.append(lib) + except Exception: + pass + return libraries + + +def _get_steam_games(steam_path: Path) -> list[dict]: + games = [] + for lib in _get_steam_libraries(steam_path): + for acf in lib.glob("appmanifest_*.acf"): + try: + content = acf.read_text(encoding="utf-8", errors="ignore") + app_id = re.search(r'"appid"\s+"(\d+)"', content) + name = re.search(r'"name"\s+"([^"]+)"', content) + state = re.search(r'"StateFlags"\s+"(\d+)"', content) + size = re.search(r'"SizeOnDisk"\s+"(\d+)"', content) + if app_id and name: + games.append({ + "id": app_id.group(1), + "name": name.group(1), + "state": int(state.group(1)) if state else 0, + "size": int(size.group(1)) if size else 0, + "lib": str(lib), + "acf": str(acf), + }) + except Exception: + continue + return games + +def _is_steam_running() -> bool: + try: + if is_windows(): + out = subprocess.run(["tasklist", "/FI", "IMAGENAME eq steam.exe"], + capture_output=True, text=True).stdout + return "steam.exe" in out.lower() + proc = "steam_osx" if is_mac() else "steam" + return bool(subprocess.run(["pgrep", "-x", proc], + capture_output=True, text=True).stdout.strip()) + except Exception: + return False + +def _get_steam_window_rect() -> tuple[int, int, int, int] | None: + try: + import pygetwindow as gw + for w in gw.getAllWindows(): + if "steam" in w.title.lower() and w.width > 200 and w.visible: + return w.left, w.top, w.width, w.height + except Exception: + pass + return None + + +def _click_first_profile_by_screenshot() -> bool: + + try: + import pyautogui + import numpy as np + + time.sleep(1.5) + win = _get_steam_window_rect() + if not win: + print("[GameUpdater] ⚠️ Steam penceresi bulunamadı") + return False + + wx, wy, ww, wh = win + screenshot = pyautogui.screenshot(region=(wx, wy, ww, wh)) + img = np.array(screenshot) + h, w = img.shape[:2] + + search_y1, search_y2 = h // 3, h * 3 // 4 + search_x1, search_x2 = w // 5, w * 4 // 5 + region = img[search_y1:search_y2, search_x1:search_x2] + + r, g, b = region[:,:,0].astype(int), region[:,:,1].astype(int), region[:,:,2].astype(int) + max_c = np.maximum(np.maximum(r, g), b) + min_c = np.minimum(np.minimum(r, g), b) + colorful = (max_c > 60) & ((max_c - min_c) > 40) + + if not colorful.any(): + print("[GameUpdater] ⚠️ Avatar rengi bulunamadı — tahminle tıklanıyor") + pyautogui.click(wx + ww // 2 - ww // 6, wy + wh // 2) + return True + + cols = np.where(colorful.any(axis=0))[0] + rows = np.where(colorful.any(axis=1))[0] + if not len(cols) or not len(rows): + return False + + avatar_w = min(90, region.shape[1] // 4) + first_col = int(cols[0]) + block_cols = cols[cols < first_col + avatar_w] + + abs_x = wx + search_x1 + int(block_cols.mean()) + abs_y = wy + search_y1 + int(rows.mean()) + print(f"[GameUpdater] 🎯 Profil avatarı ({abs_x}, {abs_y}) — tıklanıyor") + pyautogui.click(abs_x, abs_y) + return True + + except ImportError as e: + print(f"[GameUpdater] ⚠️ Eksik kütüphane: {e}") + return False + except Exception as e: + print(f"[GameUpdater] ⚠️ Profil tespiti başarısız: {e}") + return False + + +def _handle_steam_profile_selection() -> bool: + print("[GameUpdater] 🔍 Profil seçim dialogu kontrol ediliyor...") + win = _get_steam_window_rect() + if not win: + return False + + wx, wy, ww, wh = win + try: + import pyautogui, numpy as np + screenshot = pyautogui.screenshot(region=(wx, wy, ww, wh)) + img = np.array(screenshot) + is_small = ww < 900 and wh < 700 + top_region = img[:wh // 3, :, :] + white_pixels = int(np.sum( + (top_region[:,:,0] > 200) & + (top_region[:,:,1] > 200) & + (top_region[:,:,2] > 200) + )) + if not is_small and white_pixels <= 100: + print("[GameUpdater] ℹ️ Profil dialogu yok — Steam zaten giriş yapmış") + return False + except ImportError: + pass + except Exception: + pass + + print("[GameUpdater] 👤 Profil seçimi tespit edildi — ilk profile tıklanıyor") + return _click_first_profile_by_screenshot() + +def _find_best_drive() -> dict | None: + import shutil, string + drives = [] + for letter in string.ascii_uppercase: + drive_path = f"{letter}:\\" + if os.path.exists(drive_path): + try: + free_gb = shutil.disk_usage(drive_path).free / (1024 ** 3) + if free_gb > 0: + drives.append({"letter": letter, "path": drive_path, "free_gb": free_gb}) + except Exception: + continue + return max(drives, key=lambda d: d["free_gb"]) if drives else None + + +def _select_drive_in_dialog(dialog, drive_letter: str) -> bool: + target = drive_letter.upper() + for control_type in ("ListItem", "RadioButton"): + try: + for ctrl in dialog.descendants(control_type=control_type): + if target in ctrl.window_text().upper(): + ctrl.click_input() + print(f"[GameUpdater] ✅ Sürücü seçildi ({control_type}): {ctrl.window_text()}") + return True + except Exception: + continue + try: + for combo in dialog.descendants(control_type="ComboBox"): + try: + combo.expand() + time.sleep(0.15) + for idx, txt in enumerate(combo.texts()): + if target in txt.upper(): + combo.select(idx) + return True + combo.collapse() + except Exception: + continue + except Exception: + pass + try: + for ctrl in dialog.descendants(): + txt = ctrl.window_text().upper() + if f"{target}:" in txt and len(txt) < 80: + ctrl.click_input() + return True + except Exception: + pass + return False + + +def _click_button(window, keywords: list[str]) -> bool: + try: + for btn in window.descendants(control_type="Button"): + try: + txt = btn.window_text().lower().strip() + if txt in keywords or any(kw in txt for kw in keywords): + btn.click_input() + return True + except Exception: + continue + except Exception: + pass + return False + + +def _handle_install_dialog_pyautogui(game_name: str, best_drive: dict) -> str: + try: + import pyautogui + import pygetwindow as gw + except ImportError: + return (f"Install dialog opened for '{game_name}'. " + f"Please select '{best_drive['letter']}:' and click Install manually.") + + pyautogui.FAILSAFE = False + drive_label = f"{best_drive['letter']}:" + install_win = None + + for _ in range(30): + time.sleep(0.5) + for w in gw.getAllWindows(): + if ("install" in w.title.lower() or "steam" in w.title.lower()) \ + and w.width > 300 and w.visible: + install_win = w + break + if install_win: + break + + if not install_win: + return f"Please select '{drive_label}' and click Install in Steam for '{game_name}'." + + try: + install_win.activate() + time.sleep(0.4) + except Exception: + pass + + wx, wy = install_win.left, install_win.top + ww, wh = install_win.width, install_win.height + pyautogui.click(wx + int(ww * 0.35), wy + int(wh * 0.45)) + time.sleep(0.2) + pyautogui.typewrite(best_drive["letter"], interval=0.05) + time.sleep(0.2) + pyautogui.click(wx + int(ww * 0.72), wy + int(wh * 0.88)) + return f"Attempted drive {drive_label} selection and Install click for '{game_name}'." + + +def _handle_install_dialog(game_name: str) -> str: + best_drive = _find_best_drive() + if not best_drive: + return f"Install dialog opened for '{game_name}'. Could not detect drives." + + drive_letter = best_drive["letter"] + drive_label = f"{drive_letter}:" + print(f"[GameUpdater] 🏆 Hedef sürücü: {drive_label} ({best_drive['free_gb']:.1f} GB boş)") + + try: + from pywinauto import Application, findwindows + dialog = None + + for _ in range(40): + time.sleep(0.5) + try: + for hwnd in findwindows.find_windows( + title_re=r"(?i)(install|yükle|steam)", visible_only=True + ): + try: + app = Application(backend="uia").connect(handle=hwnd) + win = app.window(handle=hwnd) + rect = win.rectangle() + if win.is_visible() and rect.width() > 300 and rect.height() > 200: + all_text = " ".join( + c.window_text() for c in win.descendants() + if c.window_text() + ).upper() + if any(x in all_text for x in + ("C:", "D:", "E:", "F:", "INSTALL", "YÜKLE")): + dialog = win + break + except Exception: + continue + except Exception: + pass + if dialog: + break + + if not dialog: + raise RuntimeError("Dialog bulunamadı") + + dialog.set_focus() + time.sleep(0.4) + drive_selected = _select_drive_in_dialog(dialog, drive_letter) + install_clicked = _click_button( + dialog, ["install", "yükle", "next", "ileri", "ok", "tamam"] + ) + + if install_clicked: + suffix = f"Selected {drive_label} and" if drive_selected else "Default drive used, but" + return f"{suffix} clicked Install for '{game_name}'." + return f"Please click Install manually in Steam for '{game_name}'." + + except ImportError: + return _handle_install_dialog_pyautogui(game_name, best_drive) + except Exception as e: + print(f"[GameUpdater] ⚠️ pywinauto başarısız: {e}") + return _handle_install_dialog_pyautogui(game_name, best_drive) + +def _ensure_steam_running(steam_path: Path) -> bool: + if _is_steam_running(): + return True + + exe = _steam_exe(steam_path) + if not exe.exists(): + print(f"[GameUpdater] ❌ Steam bulunamadı: {exe}") + return False + + print("[GameUpdater] 🚀 Steam başlatılıyor...") + if is_mac(): + subprocess.Popen(["open", "-a", "Steam"]) + else: + subprocess.Popen([str(exe)]) + + for _ in range(20): + time.sleep(1) + if _is_steam_running(): + print("[GameUpdater] ✅ Steam çalışıyor") + time.sleep(4) + if is_windows(): + _handle_steam_profile_selection() + time.sleep(2) + return True + + print("[GameUpdater] ⚠️ Steam başlatılamadı") + return False + +def _search_steam_appid(game_name: str) -> tuple[str | None, str | None]: + name_lower = game_name.lower().strip() + + + steam_path = _find_steam_path() + if steam_path: + for g in _get_steam_games(steam_path): + if name_lower in g["name"].lower(): + return g["id"], g["name"] + + if name_lower in _KNOWN_APPIDS: + app_id, canonical = _KNOWN_APPIDS[name_lower] + print(f"[GameUpdater] 📖 Bilinen: {canonical} ({app_id})") + return app_id, canonical + + for key, (app_id, canonical) in _KNOWN_APPIDS.items(): + if name_lower in key or key in name_lower: + print(f"[GameUpdater] 📖 Kısmi eşleşme: {canonical} ({app_id})") + return app_id, canonical + + try: + import urllib.request, urllib.parse + query = urllib.parse.quote(game_name) + url = f"https://store.steampowered.com/api/storesearch/?term={query}&l=english&cc=US" + req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"}) + with urllib.request.urlopen(req, timeout=6) as resp: + items = json.loads(resp.read().decode()).get("items", []) + if items: + best = items[0] + print(f"[GameUpdater] 🌐 Store API: {best['name']} ({best['id']})") + return str(best["id"]), best["name"] + except Exception as e: + print(f"[GameUpdater] ⚠️ AppID arama başarısız: {e}") + + return None, None + +def _update_steam_games(steam_path: Path, game_name: str = None) -> str: + if not _ensure_steam_running(steam_path): + return "Could not start Steam." + + exe = _steam_exe(steam_path) + games = _get_steam_games(steam_path) + if not games: + return "No Steam games found." + + if game_name: + name_lower = game_name.lower() + targets = [g for g in games if name_lower in g["name"].lower()] + if not targets: + available = ", ".join(g["name"] for g in games[:5]) + return f"Game '{game_name}' not found. Installed: {available}..." + else: + targets = games + + already_updated, already_running, update_started, errors = [], [], [], [] + + for game in targets: + state = game["state"] + name = game["name"] + if state == 4: + already_updated.append(name) + elif state == 1026: + already_running.append(name) + else: + try: + _launch_steam_url(exe, f"steam://update/{game['id']}") + update_started.append(name) + time.sleep(0.3) + except Exception as e: + errors.append(f"{name}: {e}") + + parts = [] + if update_started: + names = ", ".join(update_started[:3]) + suffix = f" and {len(update_started) - 3} more" if len(update_started) > 3 else "" + parts.append(f"Update started for: {names}{suffix}.") + if already_running: + parts.append(f"Already updating: {', '.join(already_running)}.") + if already_updated: + parts.append( + f"{already_updated[0]} is already up to date." + if game_name else + f"{len(already_updated)} game(s) already up to date." + ) + if errors: + parts.append(f"Errors: {'; '.join(errors)}.") + return " ".join(parts) if parts else "No games to update." + +def _install_steam_game(steam_path: Path, game_name: str = None, + app_id: str = None) -> str: + if not _ensure_steam_running(steam_path): + return "Could not start Steam." + + exe = _steam_exe(steam_path) + installed_games = _get_steam_games(steam_path) + + already = None + if app_id: + already = next((g for g in installed_games if g["id"] == str(app_id)), None) + elif game_name: + name_lower = game_name.lower() + already = next((g for g in installed_games + if name_lower in g["name"].lower()), None) + else: + return "Please specify a game name or AppID." + + if already: + state = already["state"] + name = already["name"] + if state == 4: + return f"'{name}' is already installed and up to date." + if state == 1026: + return f"'{name}' is currently downloading or updating." + if state in (6, 516): + _launch_steam_url(exe, f"steam://update/{already['id']}") + return f"'{name}' has a pending update. Update started." + return f"'{name}' is already installed." + + if not app_id and game_name: + found_id, found_name = _search_steam_appid(game_name) + if not found_id: + return (f"Could not find '{game_name}' on Steam. " + f"Try providing the AppID directly.") + app_id = found_id + game_name = found_name or game_name + print(f"[GameUpdater] 🔍 Kuruluyor: {game_name} (AppID: {app_id})") + + try: + _launch_steam_url(exe, f"steam://install/{app_id}") + + if is_windows(): + threading.Thread( + target=_handle_install_dialog, + args=(game_name or str(app_id),), + daemon=True + ).start() + return f"Install started for '{game_name}'. Steam will open the download dialog." + except Exception as e: + return f"Install failed: {e}" + +def _get_download_status(steam_path: Path) -> str: + games = _get_steam_games(steam_path) + active = [g for g in games if g["state"] == 1026] + pending = [g for g in games if g["state"] in (6, 516)] + lines = [] + if active: + lines.append(f"Downloading: {', '.join(g['name'] for g in active)}.") + if pending: + names = ", ".join(g["name"] for g in pending[:5]) + suffix = f" and {len(pending) - 5} more" if len(pending) > 5 else "" + lines.append(f"Pending updates: {names}{suffix}.") + return " ".join(lines) if lines else "No active downloads or pending updates." + + +def _system_shutdown() -> None: + if is_windows(): + subprocess.run(["shutdown", "/s", "/t", "10"]) + elif is_mac(): + subprocess.run(["osascript", "-e", 'tell app "System Events" to shut down']) + else: + subprocess.run(["systemctl", "poweroff"]) + + +def _watch_and_shutdown(steam_path: Path, speak=None, + check_interval: int = 30, timeout_hours: int = 12): + print("[GameUpdater]...") + deadline = time.time() + timeout_hours * 3600 + + for _ in range(24): + time.sleep(5) + active = [g for g in _get_steam_games(steam_path) if g["state"] == 1026] + if active: + names = ", ".join(g["name"] for g in active) + if speak: + speak(f"Download started for {names}. I'll shut down when done.") + break + else: + return + + while time.time() < deadline: + time.sleep(check_interval) + if not any(g["state"] == 1026 for g in _get_steam_games(steam_path)): + if speak: + speak("Download complete. Shutting down now.") + time.sleep(5) + _system_shutdown() + return + + if speak: + speak("Download taking too long. Cancelling auto-shutdown.") + + +def _find_epic_exe() -> Path | None: + if is_windows(): return _find_epic_exe_windows() + if is_mac(): return _find_epic_exe_mac() + return _find_epic_exe_linux() + + +def _find_epic_exe_windows() -> Path | None: + try: + import winreg + for hive, key_path in [ + (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\WOW6432Node\EpicGames\EpicGamesLauncher"), + (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\EpicGames\EpicGamesLauncher"), + (winreg.HKEY_CURRENT_USER, r"SOFTWARE\EpicGames\EpicGamesLauncher"), + ]: + try: + key = winreg.OpenKey(hive, key_path) + val, _ = winreg.QueryValueEx(key, "AppDataPath") + winreg.CloseKey(key) + exe = Path(val) / "Binaries" / "Win64" / "EpicGamesLauncher.exe" + if exe.exists(): + return exe + except Exception: + continue + except ImportError: + pass + for candidate in [ + Path(os.environ.get("ProgramFiles(x86)", "")) / "Epic Games" / "Launcher" / "Portal" / "Binaries" / "Win64" / "EpicGamesLauncher.exe", + Path(os.environ.get("ProgramFiles", "")) / "Epic Games" / "Launcher" / "Portal" / "Binaries" / "Win64" / "EpicGamesLauncher.exe", + Path(os.environ.get("LOCALAPPDATA", "")) / "EpicGamesLauncher" / "Portal" / "Binaries" / "Win64" / "EpicGamesLauncher.exe", + ]: + if candidate.exists(): + return candidate + return None + + +def _find_epic_exe_mac() -> Path | None: + p = Path("/Applications/Epic Games Launcher.app/Contents/MacOS/EpicGamesLauncher") + return p if p.exists() else None + + +def _find_epic_exe_linux() -> Path | None: + for c in [Path.home() / ".local" / "bin" / "heroic", Path("/usr/bin/heroic")]: + if c.exists(): + return c + return None + + +def _epic_manifests_path() -> Path | None: + if is_windows(): + p = Path(os.environ.get("PROGRAMDATA", "C:/ProgramData")) \ + / "Epic" / "EpicGamesLauncher" / "Data" / "Manifests" + return p if p.exists() else None + if is_mac(): + p = Path.home() / "Library" / "Application Support" \ + / "Epic" / "EpicGamesLauncher" / "Data" / "Manifests" + return p if p.exists() else None + return None + + +def _get_epic_games() -> list[dict]: + manifests = _epic_manifests_path() + if not manifests: + return [] + games = [] + for item_file in manifests.glob("*.item"): + try: + data = json.loads(item_file.read_text(encoding="utf-8")) + name = data.get("DisplayName") or data.get("AppName", "") + if name: + games.append({"id": data.get("AppName", ""), "name": name}) + except Exception: + continue + return games + + +def _is_epic_running() -> bool: + try: + if is_windows(): + out = subprocess.run( + ["tasklist", "/FI", "IMAGENAME eq EpicGamesLauncher.exe"], + capture_output=True, text=True + ).stdout + return "epicgameslauncher.exe" in out.lower() + proc = "EpicGamesLauncher" if is_mac() else "heroic" + return bool(subprocess.run(["pgrep", "-x", proc], + capture_output=True, text=True).stdout.strip()) + except Exception: + return False + + +def _update_epic_games(epic_exe: Path, game_name: str = None) -> str: + games = _get_epic_games() + + if game_name: + name_lower = game_name.lower() + matched = [g for g in games if name_lower in g["name"].lower()] + if not matched: + return f"'{game_name}' not found in Epic." + try: + url = f"com.epicgames.launcher://apps/{matched[0]['id']}?action=launch&silent=true" + if is_mac(): + subprocess.Popen(["open", url]) + elif is_linux(): + subprocess.Popen([str(epic_exe), url] if epic_exe else ["xdg-open", url]) + else: + subprocess.Popen([str(epic_exe), url]) + return f"Opened Epic for '{matched[0]['name']}'." + except Exception as e: + return f"Epic update failed: {e}" + else: + try: + if is_mac(): + subprocess.Popen(["open", "-a", "Epic Games Launcher"]) + elif is_linux(): + if epic_exe: + subprocess.Popen([str(epic_exe)]) + else: + return ("Epic Games is not natively supported on Linux. " + "Consider using Heroic Launcher.") + else: + + if _is_epic_running(): + for g in games[:10]: + subprocess.Popen([str(epic_exe), + f"com.epicgames.launcher://apps/{g['id']}?action=launch&silent=true"]) + time.sleep(0.5) + return f"Triggered update check for {len(games)} Epic game(s)." + else: + subprocess.Popen([str(epic_exe)]) + count = len(games) + return (f"Epic Games Launcher opened. {count} game(s) will be checked." + if count else "Epic Games Launcher opened.") + except Exception as e: + return f"Epic launch failed: {e}" + +def _schedule_daily_update(hour: int = 3, minute: int = 0) -> str: + if is_windows(): return _schedule_windows(hour, minute) + if is_mac(): return _schedule_mac(hour, minute) + return _schedule_linux(hour, minute) + + +def _schedule_windows(hour: int, minute: int) -> str: + task_name = "JARVIS_GameUpdater" + script_path = Path(__file__).resolve() + subprocess.run(["schtasks", "/Delete", "/TN", task_name, "/F"], capture_output=True) + for extra in (["/RL", "HIGHEST", "/RU", "SYSTEM"], []): + cmd = ["schtasks", "/Create", "/TN", task_name, + "/TR", f'"{sys.executable}" "{script_path}" --scheduled', + "/SC", "DAILY", "/ST", f"{hour:02d}:{minute:02d}", "/F", *extra] + result = subprocess.run(cmd, capture_output=True, text=True) + if result.returncode == 0: + return f"Daily game update scheduled at {hour:02d}:{minute:02d}." + return f"Scheduling failed: {result.stderr.strip()}" + + +def _schedule_mac(hour: int, minute: int) -> str: + plist_dir = Path.home() / "Library" / "LaunchAgents" + plist_dir.mkdir(parents=True, exist_ok=True) + plist_path = plist_dir / "com.jarvis.gameupdater.plist" + script_path = Path(__file__).resolve() + plist_content = f""" + + + Labelcom.jarvis.gameupdater + ProgramArguments + + {sys.executable} + {script_path} + --scheduled + + StartCalendarInterval + + Hour{hour} + Minute{minute} + + RunAtLoad +""" + try: + plist_path.write_text(plist_content, encoding="utf-8") + subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True) + result = subprocess.run(["launchctl", "load", str(plist_path)], + capture_output=True, text=True) + if result.returncode == 0: + return f"Daily game update scheduled at {hour:02d}:{minute:02d} via launchd." + return f"Scheduling failed: {result.stderr.strip()}" + except Exception as e: + return f"Scheduling failed: {e}" + + +def _schedule_linux(hour: int, minute: int) -> str: + script_path = Path(__file__).resolve() + marker = "# JARVIS_GameUpdater" + cron_entry = f"{minute} {hour} * * * {sys.executable} {script_path} --scheduled {marker}" + try: + existing = subprocess.run(["crontab", "-l"], capture_output=True, text=True) + lines = [l for l in existing.stdout.splitlines() + if marker not in l and str(script_path) not in l] + lines.append(cron_entry) + proc = subprocess.run(["crontab", "-"], + input="\n".join(lines) + "\n", + text=True, capture_output=True) + if proc.returncode == 0: + return f"Daily game update scheduled at {hour:02d}:{minute:02d} via cron." + return f"Scheduling failed: {proc.stderr.strip()}" + except Exception as e: + return f"Scheduling failed: {e}" + + +def _cancel_scheduled_update() -> str: + if is_windows(): + result = subprocess.run( + ["schtasks", "/Delete", "/TN", "JARVIS_GameUpdater", "/F"], + capture_output=True, text=True + ) + return ("Scheduled update cancelled." + if result.returncode == 0 else "No scheduled update found.") + if is_mac(): + plist_path = Path.home() / "Library" / "LaunchAgents" / "com.jarvis.gameupdater.plist" + if plist_path.exists(): + subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True) + plist_path.unlink() + return "Scheduled update cancelled." + return "No scheduled update found." + + try: + existing = subprocess.run(["crontab", "-l"], capture_output=True, text=True) + lines = [l for l in existing.stdout.splitlines() + if "JARVIS_GameUpdater" not in l] + subprocess.run(["crontab", "-"], + input="\n".join(lines) + "\n", text=True) + return "Scheduled update cancelled." + except Exception as e: + return f"Cancel failed: {e}" + + +def _get_schedule_status() -> str: + if is_windows(): + result = subprocess.run( + ["schtasks", "/Query", "/TN", "JARVIS_GameUpdater", "/FO", "LIST"], + capture_output=True, text=True + ) + if result.returncode != 0: + return "No scheduled game update found." + for line in result.stdout.strip().splitlines(): + if any(k in line for k in + ("Next Run", "Sonraki", "Prochaine", "Próxima", "Nächste")): + return f"Game update scheduled. {line.strip()}" + return "Game update is scheduled." + if is_mac(): + plist_path = (Path.home() / "Library" / "LaunchAgents" + / "com.jarvis.gameupdater.plist") + return ("Game update is scheduled via launchd." + if plist_path.exists() else "No scheduled game update found.") + + try: + result = subprocess.run(["crontab", "-l"], capture_output=True, text=True) + if "JARVIS_GameUpdater" in result.stdout: + for line in result.stdout.splitlines(): + if "JARVIS_GameUpdater" in line: + return f"Game update is scheduled: {line.split('#')[0].strip()}" + return "No scheduled game update found." + except Exception: + return "No scheduled game update found." + + +def game_updater(parameters: dict, player=None, speak=None) -> str: + p = parameters or {} + action = p.get("action", "update").lower().strip() + platform = p.get("platform", "both").lower().strip() + game_name = (p.get("game_name") or "").strip() or None + app_id = (p.get("app_id") or "").strip() or None + hour = int(p.get("hour", 3)) + minute = int(p.get("minute", 0)) + shutdown = str(p.get("shutdown_when_done", "false")).lower() == "true" + + results = [] + + if action == "schedule": return _schedule_daily_update(hour=hour, minute=minute) + if action == "cancel_schedule": return _cancel_scheduled_update() + if action == "schedule_status": return _get_schedule_status() + + if action == "list": + if platform in ("steam", "both"): + steam_path = _find_steam_path() + if steam_path: + games = _get_steam_games(steam_path) + if games: + names = ", ".join(g["name"] for g in games[:8]) + suffix = f" and {len(games) - 8} more" if len(games) > 8 else "" + results.append(f"Steam ({len(games)} games): {names}{suffix}.") + else: + results.append("Steam: No games found.") + else: + results.append("Steam: Not installed.") + if platform in ("epic", "both"): + if is_linux(): + results.append("Epic: Not natively supported on Linux.") + else: + games = _get_epic_games() + if games: + names = ", ".join(g["name"] for g in games[:8]) + suffix = f" and {len(games) - 8} more" if len(games) > 8 else "" + results.append(f"Epic ({len(games)} games): {names}{suffix}.") + else: + results.append("Epic: No games found.") + return " | ".join(results) or "No platforms found." + + if action == "download_status": + if platform in ("steam", "both"): + steam_path = _find_steam_path() + results.append( + _get_download_status(steam_path) if steam_path else "Steam: Not installed." + ) + if platform in ("epic", "both"): + results.append("Epic download status not available directly.") + return " ".join(results) + + if action in ("install", "update"): + if platform in ("steam", "both"): + steam_path = _find_steam_path() + if not steam_path: + results.append("Steam: Not installed.") + else: + if game_name: + installed = _get_steam_games(steam_path) + name_lower = game_name.lower() + is_installed = any( + name_lower in g["name"].lower() for g in installed + ) + if not is_installed: + msg = _install_steam_game( + steam_path, game_name=game_name, app_id=app_id + ) + if shutdown: + threading.Thread( + target=_watch_and_shutdown, + kwargs={"steam_path": steam_path, "speak": speak}, + daemon=True + ).start() + msg += " Auto-shutdown enabled." + if player: player.write_log(f"[GameUpdater] {msg[:100]}") + if speak: speak(msg) + return msg + else: + results.append( + f"Steam: {_update_steam_games(steam_path, game_name=game_name)}" + ) + else: + if action == "install": + results.append("Steam: Please specify a game name to install.") + else: + results.append(f"Steam: {_update_steam_games(steam_path)}") + + if shutdown: + threading.Thread( + target=_watch_and_shutdown, + kwargs={"steam_path": steam_path, "speak": speak}, + daemon=True + ).start() + results.append("Auto-shutdown enabled.") + + if platform in ("epic", "both"): + if is_linux(): + results.append( + "Epic: Not natively supported on Linux. Use Heroic Launcher." + ) + else: + epic_exe = _find_epic_exe() + if epic_exe: + results.append( + f"Epic: {_update_epic_games(epic_exe, game_name=game_name)}" + ) + else: + results.append("Epic: Not installed.") + + output = " | ".join(results) or "Nothing to do." + if player: player.write_log(f"[GameUpdater] {output[:100]}") + if speak: speak(output) + return output + + return f"Unknown action: '{action}'." + + +if __name__ == "__main__": + if "--scheduled" in sys.argv: + print(f"[GameUpdater] 🕐 Scheduled run at {datetime.now().strftime('%H:%M')}") + result = game_updater({"action": "update", "platform": "both"}) + print(f"[GameUpdater] ✅ {result}") \ No newline at end of file diff --git a/actions/open_app.py b/actions/open_app.py index b526817..54ade6d 100644 --- a/actions/open_app.py +++ b/actions/open_app.py @@ -1,6 +1,3 @@ -# actions/open_app.py -# MARK XXV — Cross-Platform App Launcher - import time import subprocess import platform @@ -12,92 +9,120 @@ try: except ImportError: _PSUTIL = False -_APP_ALIASES = { - "whatsapp": {"Windows": "WhatsApp", "Darwin": "WhatsApp", "Linux": "whatsapp"}, - "chrome": {"Windows": "chrome", "Darwin": "Google Chrome", "Linux": "google-chrome"}, - "google chrome": {"Windows": "chrome", "Darwin": "Google Chrome", "Linux": "google-chrome"}, - "firefox": {"Windows": "firefox", "Darwin": "Firefox", "Linux": "firefox"}, - "spotify": {"Windows": "Spotify", "Darwin": "Spotify", "Linux": "spotify"}, - "vscode": {"Windows": "code", "Darwin": "Visual Studio Code", "Linux": "code"}, - "visual studio code": {"Windows": "code", "Darwin": "Visual Studio Code", "Linux": "code"}, - "discord": {"Windows": "Discord", "Darwin": "Discord", "Linux": "discord"}, - "telegram": {"Windows": "Telegram", "Darwin": "Telegram", "Linux": "telegram"}, - "instagram": {"Windows": "Instagram", "Darwin": "Instagram", "Linux": "instagram"}, - "tiktok": {"Windows": "TikTok", "Darwin": "TikTok", "Linux": "tiktok"}, - "notepad": {"Windows": "notepad.exe", "Darwin": "TextEdit", "Linux": "gedit"}, - "calculator": {"Windows": "calc.exe", "Darwin": "Calculator", "Linux": "gnome-calculator"}, - "terminal": {"Windows": "cmd.exe", "Darwin": "Terminal", "Linux": "gnome-terminal"}, - "cmd": {"Windows": "cmd.exe", "Darwin": "Terminal", "Linux": "bash"}, - "explorer": {"Windows": "explorer.exe", "Darwin": "Finder", "Linux": "nautilus"}, - "file explorer": {"Windows": "explorer.exe", "Darwin": "Finder", "Linux": "nautilus"}, - "paint": {"Windows": "mspaint.exe", "Darwin": "Preview", "Linux": "gimp"}, - "word": {"Windows": "winword", "Darwin": "Microsoft Word", "Linux": "libreoffice --writer"}, - "excel": {"Windows": "excel", "Darwin": "Microsoft Excel", "Linux": "libreoffice --calc"}, - "powerpoint": {"Windows": "powerpnt", "Darwin": "Microsoft PowerPoint","Linux": "libreoffice --impress"}, - "vlc": {"Windows": "vlc", "Darwin": "VLC", "Linux": "vlc"}, - "zoom": {"Windows": "Zoom", "Darwin": "zoom.us", "Linux": "zoom"}, - "slack": {"Windows": "Slack", "Darwin": "Slack", "Linux": "slack"}, - "steam": {"Windows": "steam", "Darwin": "Steam", "Linux": "steam"}, - "task manager": {"Windows": "taskmgr.exe", "Darwin": "Activity Monitor", "Linux": "gnome-system-monitor"}, - "settings": {"Windows": "ms-settings:", "Darwin": "System Preferences", "Linux": "gnome-control-center"}, - "powershell": {"Windows": "powershell.exe", "Darwin": "Terminal", "Linux": "bash"}, - "edge": {"Windows": "msedge", "Darwin": "Microsoft Edge", "Linux": "microsoft-edge"}, - "brave": {"Windows": "brave", "Darwin": "Brave Browser", "Linux": "brave-browser"}, - "obsidian": {"Windows": "Obsidian", "Darwin": "Obsidian", "Linux": "obsidian"}, - "notion": {"Windows": "Notion", "Darwin": "Notion", "Linux": "notion"}, - "blender": {"Windows": "blender", "Darwin": "Blender", "Linux": "blender"}, - "capcut": {"Windows": "CapCut", "Darwin": "CapCut", "Linux": "capcut"}, - "postman": {"Windows": "Postman", "Darwin": "Postman", "Linux": "postman"}, - "figma": {"Windows": "Figma", "Darwin": "Figma", "Linux": "figma"}, +_SYSTEM = platform.system() + +_APP_ALIASES: dict[str, dict[str, str]] = { + + "chrome": {"Windows": "chrome", "Darwin": "Google Chrome", "Linux": "google-chrome"}, + "google chrome": {"Windows": "chrome", "Darwin": "Google Chrome", "Linux": "google-chrome"}, + "firefox": {"Windows": "firefox", "Darwin": "Firefox", "Linux": "firefox"}, + "edge": {"Windows": "msedge", "Darwin": "Microsoft Edge", "Linux": "microsoft-edge"}, + "brave": {"Windows": "brave", "Darwin": "Brave Browser", "Linux": "brave-browser"}, + "safari": {"Windows": "msedge", "Darwin": "Safari", "Linux": "firefox"}, + "opera": {"Windows": "opera", "Darwin": "Opera", "Linux": "opera"}, + "whatsapp": {"Windows": "WhatsApp", "Darwin": "WhatsApp", "Linux": "whatsapp"}, + "telegram": {"Windows": "Telegram", "Darwin": "Telegram", "Linux": "telegram"}, + "discord": {"Windows": "Discord", "Darwin": "Discord", "Linux": "discord"}, + "slack": {"Windows": "Slack", "Darwin": "Slack", "Linux": "slack"}, + "zoom": {"Windows": "Zoom", "Darwin": "zoom.us", "Linux": "zoom"}, + "teams": {"Windows": "msteams", "Darwin": "Microsoft Teams", "Linux": "teams"}, + "skype": {"Windows": "skype", "Darwin": "Skype", "Linux": "skype"}, + "signal": {"Windows": "signal", "Darwin": "Signal", "Linux": "signal"}, + "spotify": {"Windows": "Spotify", "Darwin": "Spotify", "Linux": "spotify"}, + "vlc": {"Windows": "vlc", "Darwin": "VLC", "Linux": "vlc"}, + "netflix": {"Windows": "Netflix", "Darwin": "Netflix", "Linux": "firefox"}, + "vscode": {"Windows": "code", "Darwin": "Visual Studio Code", "Linux": "code"}, + "visual studio code": {"Windows": "code", "Darwin": "Visual Studio Code", "Linux": "code"}, + "code": {"Windows": "code", "Darwin": "Visual Studio Code", "Linux": "code"}, + "terminal": {"Windows": "wt", "Darwin": "Terminal", "Linux": "gnome-terminal"}, + "cmd": {"Windows": "cmd.exe", "Darwin": "Terminal", "Linux": "bash"}, + "powershell": {"Windows": "powershell.exe", "Darwin": "Terminal", "Linux": "bash"}, + "postman": {"Windows": "Postman", "Darwin": "Postman", "Linux": "postman"}, + "git": {"Windows": "git-bash", "Darwin": "Terminal", "Linux": "bash"}, + "figma": {"Windows": "Figma", "Darwin": "Figma", "Linux": "figma"}, + "blender": {"Windows": "blender", "Darwin": "Blender", "Linux": "blender"}, + "word": {"Windows": "winword", "Darwin": "Microsoft Word", "Linux": "libreoffice --writer"}, + "excel": {"Windows": "excel", "Darwin": "Microsoft Excel", "Linux": "libreoffice --calc"}, + "powerpoint": {"Windows": "powerpnt", "Darwin": "Microsoft PowerPoint", "Linux": "libreoffice --impress"}, + "libreoffice": {"Windows": "soffice", "Darwin": "LibreOffice", "Linux": "libreoffice"}, + "notepad": {"Windows": "notepad.exe", "Darwin": "TextEdit", "Linux": "gedit"}, + "textedit": {"Windows": "notepad.exe", "Darwin": "TextEdit", "Linux": "gedit"}, + "explorer": {"Windows": "explorer.exe", "Darwin": "Finder", "Linux": "nautilus"}, + "file explorer": {"Windows": "explorer.exe", "Darwin": "Finder", "Linux": "nautilus"}, + "finder": {"Windows": "explorer.exe", "Darwin": "Finder", "Linux": "nautilus"}, + "task manager": {"Windows": "taskmgr.exe", "Darwin": "Activity Monitor", "Linux": "gnome-system-monitor"}, + "settings": {"Windows": "ms-settings:", "Darwin": "System Preferences", "Linux": "gnome-control-center"}, + "calculator": {"Windows": "calc.exe", "Darwin": "Calculator", "Linux": "gnome-calculator"}, + "paint": {"Windows": "mspaint.exe", "Darwin": "Preview", "Linux": "gimp"}, + "instagram": {"Windows": "Instagram", "Darwin": "Instagram", "Linux": "firefox"}, + "tiktok": {"Windows": "TikTok", "Darwin": "TikTok", "Linux": "firefox"}, + "notion": {"Windows": "Notion", "Darwin": "Notion", "Linux": "notion"}, + "obsidian": {"Windows": "Obsidian", "Darwin": "Obsidian", "Linux": "obsidian"}, + "capcut": {"Windows": "CapCut", "Darwin": "CapCut", "Linux": "capcut"}, + "steam": {"Windows": "steam", "Darwin": "Steam", "Linux": "steam"}, + "epic": {"Windows": "EpicGamesLauncher", "Darwin": "Epic Games Launcher", "Linux": "legendary"}, + "epic games": {"Windows": "EpicGamesLauncher", "Darwin": "Epic Games Launcher", "Linux": "legendary"}, } def _normalize(raw: str) -> str: - system = platform.system() - key = raw.lower().strip() + key = raw.lower().strip() + if key in _APP_ALIASES: - return _APP_ALIASES[key].get(system, raw) + return _APP_ALIASES[key].get(_SYSTEM, raw) + for alias_key, os_map in _APP_ALIASES.items(): if alias_key in key or key in alias_key: - return os_map.get(system, raw) - return raw - - -def _is_running(app_name: str) -> bool: - if not _PSUTIL: - return True - app_lower = app_name.lower().replace(" ", "").replace(".exe", "") - try: - for proc in psutil.process_iter(["name"]): - try: - proc_name = proc.info["name"].lower().replace(" ", "").replace(".exe", "") - if app_lower in proc_name or proc_name in app_lower: - return True - except (psutil.NoSuchProcess, psutil.AccessDenied): - continue - except Exception: - pass - return False + return os_map.get(_SYSTEM, raw) + return raw def _launch_windows(app_name: str) -> bool: + + if shutil.which(app_name) or shutil.which(app_name.split(".")[0]): + try: + subprocess.Popen( + app_name, + shell=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + time.sleep(1.5) + return True + except Exception as e: + print(f"[open_app] subprocess failed: {e}") + + if ":" in app_name: + try: + subprocess.Popen(f"start {app_name}", shell=True) + time.sleep(1.0) + return True + except Exception: + pass + try: import pyautogui pyautogui.PAUSE = 0.1 pyautogui.press("win") - time.sleep(0.6) + time.sleep(0.7) pyautogui.write(app_name, interval=0.05) - time.sleep(0.8) + time.sleep(0.9) pyautogui.press("enter") - time.sleep(3.0) + time.sleep(2.5) return True except Exception as e: - print(f"[open_app] ⚠️ Windows launch failed: {e}") - return False + print(f"[open_app] Start Menu search failed: {e}") + + return False + def _launch_macos(app_name: str) -> bool: + try: - result = subprocess.run(["open", "-a", app_name], capture_output=True, timeout=8) + result = subprocess.run( + ["open", "-a", app_name], + capture_output=True, timeout=8 + ) if result.returncode == 0: time.sleep(1.0) return True @@ -105,13 +130,29 @@ def _launch_macos(app_name: str) -> bool: pass try: - result = subprocess.run(["open", "-a", f"{app_name}.app"], capture_output=True, timeout=8) + result = subprocess.run( + ["open", "-a", f"{app_name}.app"], + capture_output=True, timeout=8 + ) if result.returncode == 0: time.sleep(1.0) return True except Exception: pass + binary = shutil.which(app_name) or shutil.which(app_name.lower()) + if binary: + try: + subprocess.Popen( + [binary], + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) + time.sleep(1.0) + return True + except Exception: + pass + try: import pyautogui pyautogui.hotkey("command", "space") @@ -122,37 +163,54 @@ def _launch_macos(app_name: str) -> bool: time.sleep(1.5) return True except Exception as e: - print(f"[open_app] ⚠️ macOS Spotlight failed: {e}") - return False + print(f"[open_app] Spotlight failed: {e}") + return False def _launch_linux(app_name: str) -> bool: + binary = ( shutil.which(app_name) or shutil.which(app_name.lower()) or - shutil.which(app_name.lower().replace(" ", "-")) + shutil.which(app_name.lower().replace(" ", "-")) or + shutil.which(app_name.lower().replace(" ", "_")) ) if binary: try: - subprocess.Popen([binary], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + subprocess.Popen( + [binary], + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) time.sleep(1.0) return True except Exception: pass try: - subprocess.run(["xdg-open", app_name], capture_output=True, timeout=5) + subprocess.run( + ["xdg-open", app_name], + capture_output=True, timeout=5 + ) return True except Exception: pass - try: - desktop_name = app_name.lower().replace(" ", "-") - subprocess.run(["gtk-launch", desktop_name], capture_output=True, timeout=5) - return True - except Exception: - pass + for desktop_name in [ + app_name.lower(), + app_name.lower().replace(" ", "-"), + app_name.lower().replace(" ", ""), + ]: + try: + result = subprocess.run( + ["gtk-launch", desktop_name], + capture_output=True, timeout=5 + ) + if result.returncode == 0: + return True + except Exception: + pass return False @@ -163,7 +221,6 @@ _OS_LAUNCHERS = { "Linux": _launch_linux, } - def open_app( parameters=None, response=None, @@ -173,36 +230,28 @@ def open_app( app_name = (parameters or {}).get("app_name", "").strip() if not app_name: - return "Please specify which application to open, sir." - - system = platform.system() - launcher = _OS_LAUNCHERS.get(system) + return "No application name provided." + launcher = _OS_LAUNCHERS.get(_SYSTEM) if launcher is None: - return f"Unsupported OS: {system}" + return f"Unsupported operating system: {_SYSTEM}" normalized = _normalize(app_name) - print(f"[open_app] 🚀 Launching: {app_name} → {normalized} ({system})") + print(f"[open_app] Launching: '{app_name}' → '{normalized}' ({_SYSTEM})") if player: player.write_log(f"[open_app] {app_name}") try: - success = launcher(normalized) - - if success: - return f"Opened {app_name} successfully, sir." - - if normalized != app_name: - success = launcher(app_name) - if success: - return f"Opened {app_name} successfully, sir." - + if launcher(normalized): + return f"Opened {app_name}." + if normalized.lower() != app_name.lower(): + if launcher(app_name): + return f"Opened {app_name}." return ( - f"I tried to open {app_name}, sir, but couldn't confirm it launched. " - f"It may still be loading or might not be installed." + f"Could not confirm that {app_name} launched. " + f"It may still be loading, or it might not be installed." ) - except Exception as e: - print(f"[open_app] ❌ {e}") - return f"Failed to open {app_name}, sir: {e}" \ No newline at end of file + print(f"[open_app] Error: {e}") + return f"Failed to open {app_name}: {e}" \ No newline at end of file diff --git a/actions/reminder.py b/actions/reminder.py index 330805d..10149ce 100644 --- a/actions/reminder.py +++ b/actions/reminder.py @@ -1,156 +1,332 @@ -# actions/reminder.py - -import subprocess +import json import os +import shutil +import subprocess import sys from datetime import datetime +from pathlib import Path +def _base_dir() -> Path: + if getattr(sys, "frozen", False): + return Path(sys.executable).parent + return Path(__file__).resolve().parent.parent + + +def _get_os() -> str: + try: + cfg = json.loads( + (_base_dir() / "config" / "api_keys.json").read_text(encoding="utf-8") + ) + return cfg.get("os_system", "windows").lower() + except Exception: + return "windows" + + +def _scripts_dir() -> Path: + d = Path.home() / ".jarvis" / "reminders" + d.mkdir(parents=True, exist_ok=True) + return d + + +def _sanitise(text: str, max_len: int = 200) -> str: + return ( + text.replace("\\", "") + .replace('"', "") + .replace("'", "") + .replace("\n", " ") + .replace("\r", "") + .strip() + )[:max_len] + +def _write_notify_script(task_name: str, message: str, os_name: str) -> Path: + script_path = _scripts_dir() / f"{task_name}.py" + msg_literal = json.dumps(message) + + if os_name == "windows": + notify_block = f""" +message = {msg_literal} +notified = False + +try: + from plyer import notification + notification.notify(title="J.A.R.V.I.S Reminder", message=message, timeout=15) + notified = True +except Exception: + pass + +if not notified: + try: + from win10toast import ToastNotifier + ToastNotifier().show_toast("J.A.R.V.I.S Reminder", message, duration=15, threaded=False) + notified = True + except Exception: + pass + +if not notified: + try: + import subprocess + subprocess.run(["msg", "*", "/TIME:30", message], check=False) + except Exception: + pass + +try: + import winsound + for freq in [800, 1000, 1200]: + winsound.Beep(freq, 180) + import time; time.sleep(0.08) +except Exception: + pass +""" + + elif os_name == "mac": + notify_block = f""" +message = {msg_literal} +notified = False + +try: + from plyer import notification + notification.notify(title="J.A.R.V.I.S Reminder", message=message, timeout=15) + notified = True +except Exception: + pass + +if not notified: + try: + import subprocess + script = 'display notification "{{}}" with title "J.A.R.V.I.S Reminder"'.format( + message.replace('"', '') + ) + subprocess.run(["osascript", "-e", script], check=False) + except Exception: + pass +""" + + else: # linux + notify_block = f""" +message = {msg_literal} +notified = False + +try: + from plyer import notification + notification.notify(title="J.A.R.V.I.S Reminder", message=message, timeout=15) + notified = True +except Exception: + pass + +if not notified: + try: + import subprocess + subprocess.run( + ["notify-send", "--urgency=normal", "--expire-time=15000", + "J.A.R.V.I.S Reminder", message], + check=False + ) + except Exception: + pass +""" + + script_body = f"""# Auto-generated by J.A.R.V.I.S reminder — do not edit +import sys, os, pathlib +{notify_block} +# Self-delete after firing +try: + pathlib.Path(__file__).unlink(missing_ok=True) +except Exception: + pass +""" + script_path.write_text(script_body, encoding="utf-8") + script_path.chmod(0o600) # owner read/write only + return script_path + +def _schedule_windows(target_dt: datetime, task_name: str, + script_path: Path, message: str) -> str: + python_exe = Path(sys.executable) + pythonw = python_exe.parent / "pythonw.exe" + if pythonw.exists(): + python_exe = pythonw + + xml_path = _scripts_dir() / f"{task_name}.xml" + xml_content = ( + '\n' + '\n' + ' J.A.R.V.I.S Reminder\n' + ' \n' + f' {target_dt.strftime("%Y-%m-%dT%H:%M:%S")}\n' + ' true\n' + ' \n' + ' \n' + f' {python_exe}\n' + f' "{script_path}"\n' + ' \n' + ' \n' + ' IgnoreNew\n' + ' false\n' + ' false\n' + ' true\n' + ' PT5M\n' + ' true\n' + ' \n' + ' \n' + ' InteractiveToken\n' + ' LeastPrivilege\n' + ' \n' + '' + ) + + xml_path.write_text(xml_content, encoding="utf-16") + + result = subprocess.run( + ["schtasks", "/Create", "/TN", task_name, "/XML", str(xml_path), "/F"], + capture_output=True, text=True, + ) + + try: + xml_path.unlink(missing_ok=True) + except Exception: + pass + + if result.returncode != 0: + script_path.unlink(missing_ok=True) + err = (result.stderr or result.stdout).strip() + print(f"[Reminder] ❌ schtasks: {err}") + return "" + + return task_name + + +def _schedule_mac(target_dt: datetime, task_name: str, + script_path: Path) -> str: + agents_dir = Path.home() / "Library" / "LaunchAgents" + agents_dir.mkdir(parents=True, exist_ok=True) + + label = f"com.jarvis.reminder.{task_name}" + plist_path = agents_dir / f"{label}.plist" + + plist_content = f""" + + + + Label {label} + ProgramArguments + + {sys.executable} + {script_path} + + StartCalendarInterval + + Year {target_dt.year} + Month {target_dt.month} + Day {target_dt.day} + Hour {target_dt.hour} + Minute {target_dt.minute} + + RunAtLoad + StandardOutPath /dev/null + StandardErrorPath /dev/null + + +""" + plist_path.write_text(plist_content, encoding="utf-8") + plist_path.chmod(0o644) + + result = subprocess.run( + ["launchctl", "load", str(plist_path)], + capture_output=True, text=True, + ) + + if result.returncode != 0: + plist_path.unlink(missing_ok=True) + script_path.unlink(missing_ok=True) + print(f"[Reminder] ❌ launchctl: {result.stderr.strip()}") + return "" + + return label + + +def _schedule_linux(target_dt: datetime, task_name: str, + script_path: Path) -> str: + + if shutil.which("systemd-run"): + on_calendar = target_dt.strftime("%Y-%m-%d %H:%M:00") + result = subprocess.run( + [ + "systemd-run", + "--user", + f"--on-calendar={on_calendar}", + f"--unit={task_name}", + "--", + sys.executable, str(script_path), + ], + capture_output=True, text=True, + ) + if result.returncode == 0: + return task_name + print(f"[Reminder] ⚠️ systemd-run failed: {result.stderr.strip()}, trying 'at'") + + if shutil.which("at"): + at_time = target_dt.strftime("%H:%M %Y-%m-%d") + cmd_str = f"{sys.executable} {script_path}\n" + result = subprocess.run( + ["at", at_time], + input=cmd_str, capture_output=True, text=True, + ) + if result.returncode == 0: + return task_name + print(f"[Reminder] ❌ at: {result.stderr.strip()}") + return "" + + print("[Reminder] ❌ Neither systemd-run nor at found on this Linux system.") + return "" def reminder( parameters: dict, - response: str | None = None, + response=None, player=None, - session_memory=None + session_memory=None, ) -> str: - """ - Sets a timed reminder using Windows Task Scheduler. - parameters: - - date (str) YYYY-MM-DD - - time (str) HH:MM - - message (str) - - Returns a result string — Live API voices it automatically. - No edge_speak needed. - """ - - date_str = parameters.get("date") - time_str = parameters.get("time") - message = parameters.get("message", "Reminder") + date_str = parameters.get("date", "").strip() + time_str = parameters.get("time", "").strip() + message = parameters.get("message", "Reminder").strip() if not date_str or not time_str: return "I need both a date and a time to set a reminder." try: target_dt = datetime.strptime(f"{date_str} {time_str}", "%Y-%m-%d %H:%M") - - if target_dt <= datetime.now(): - return "That time is already in the past." - - task_name = f"MARKReminder_{target_dt.strftime('%Y%m%d_%H%M')}" - safe_message = message.replace('"', '').replace("'", "").strip()[:200] - - python_exe = sys.executable - if python_exe.lower().endswith("python.exe"): - pythonw = python_exe.replace("python.exe", "pythonw.exe") - if os.path.exists(pythonw): - python_exe = pythonw - - temp_dir = os.environ.get("TEMP", "C:\\Temp") - notify_script = os.path.join(temp_dir, f"{task_name}.pyw") - project_root = os.path.abspath( - os.path.join(os.path.dirname(__file__), "..") - ) - - script_code = f'''import sys, os, time -sys.path.insert(0, r"{project_root}") - -try: - import winsound - for freq in [800, 1000, 1200]: - winsound.Beep(freq, 200) - time.sleep(0.1) -except Exception: - pass - -try: - from win10toast import ToastNotifier - ToastNotifier().show_toast( - "MARK Reminder", - "{safe_message}", - duration=15, - threaded=False - ) -except Exception: - try: - import subprocess - subprocess.run(["msg", "*", "/TIME:30", "{safe_message}"], shell=True) - except Exception: - pass - -time.sleep(3) -try: - os.remove(__file__) -except Exception: - pass -''' - with open(notify_script, "w", encoding="utf-8") as f: - f.write(script_code) - - xml_content = f''' - - - MARK Reminder: {safe_message} - - - - {target_dt.strftime("%Y-%m-%dT%H:%M:%S")} - true - - - - - {python_exe} - "{notify_script}" - - - - IgnoreNew - false - false - true - true - PT5M - true - - - - InteractiveToken - LeastPrivilege - - -''' - - xml_path = os.path.join(temp_dir, f"{task_name}.xml") - with open(xml_path, "w", encoding="utf-16") as f: - f.write(xml_content) - - result = subprocess.run( - f'schtasks /Create /TN "{task_name}" /XML "{xml_path}" /F', - shell=True, capture_output=True, text=True - ) - - try: - os.remove(xml_path) - except Exception: - pass - - if result.returncode != 0: - err = result.stderr.strip() or result.stdout.strip() - print(f"[Reminder] ❌ schtasks failed: {err}") - try: - os.remove(notify_script) - except Exception: - pass - return "I couldn't schedule the reminder due to a system error." - - if player: - player.write_log(f"[reminder] set for {date_str} {time_str}") - - return f"Reminder set for {target_dt.strftime('%B %d at %I:%M %p')}." - except ValueError: - return "I couldn't understand that date or time format." + return "I couldn't parse that date or time. Please use YYYY-MM-DD and HH:MM." + if target_dt <= datetime.now(): + return "That time has already passed — I can't set a reminder in the past." + + os_name = _get_os() + safe_msg = _sanitise(message) + task_name = f"JARVISReminder_{target_dt.strftime('%Y%m%d_%H%M%S')}" + + try: + script_path = _write_notify_script(task_name, safe_msg, os_name) except Exception as e: - return f"Something went wrong while scheduling the reminder: {str(e)[:80]}" \ No newline at end of file + return f"Could not prepare the reminder script: {e}" + + try: + if os_name == "windows": + job_id = _schedule_windows(target_dt, task_name, script_path, safe_msg) + elif os_name == "mac": + job_id = _schedule_mac(target_dt, task_name, script_path) + else: + job_id = _schedule_linux(target_dt, task_name, script_path) + except Exception as e: + script_path.unlink(missing_ok=True) + print(f"[Reminder] ❌ Scheduling exception: {e}") + return "Something went wrong while scheduling the reminder." + + if not job_id: + return "I couldn't register the reminder with the system scheduler." + + if player: + player.write_log(f"[Reminder] ✅ {date_str} {time_str} — {safe_msg[:40]}") + + friendly_time = target_dt.strftime("%B %d at %I:%M %p") + return f"Reminder set for {friendly_time}." \ No newline at end of file diff --git a/actions/screen_processor.py b/actions/screen_processor.py index 49fdf49..84db42e 100644 --- a/actions/screen_processor.py +++ b/actions/screen_processor.py @@ -1,151 +1,186 @@ -""" -actions/screen_processor.py — Gemini Live API — IMAGE-ONLY SESSION v8 -━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ -v8 Changes: - - Auto camera detection on first use — saves to config - - No hardcoded camera index - - mic_loop removed (no double response issue) - - Image-only session, no conflict with main.py -""" +from __future__ import annotations import asyncio import base64 import io import json import re -import os import sys -import time import threading -import cv2 -import mss -import mss.tools -import pyaudio +import time from pathlib import Path +from typing import Optional + +import numpy as np +import sounddevice as sd + +try: + import cv2 + _CV2 = True +except ImportError: + _CV2 = False + +try: + import mss + import mss.tools + _MSS = True +except ImportError: + _MSS = False try: import PIL.Image - _PIL_OK = True + _PIL = True except ImportError: - _PIL_OK = False + _PIL = False from google import genai -from google.genai import types +from google.genai import types as gtypes -def get_base_dir(): +def _base_dir() -> Path: if getattr(sys, "frozen", False): return Path(sys.executable).parent return Path(__file__).resolve().parent.parent -BASE_DIR = get_base_dir() -API_CONFIG_PATH = BASE_DIR / "config" / "api_keys.json" -LIVE_MODEL = "models/gemini-2.5-flash-native-audio-preview-12-2025" -FORMAT = pyaudio.paInt16 -CHANNELS = 1 -RECEIVE_SAMPLE_RATE = 24000 -CHUNK_SIZE = 1024 +_BASE = _base_dir() +_CONFIG_PATH = _BASE / "config" / "api_keys.json" -IMG_MAX_W = 640 -IMG_MAX_H = 360 -JPEG_Q = 55 -SYSTEM_PROMPT = ( - "You are JARVIS from Iron Man movies. " - "Analyze images with technical precision and intelligence. " - "Help the user in a way they can understand — don't be overly complex. " - "Be concise, smart, and helpful like Tony Stark's AI assistant. " - "Respond in maximum 2 short sentences. Speed is priority. " - "Address the user as 'sir' for a tone of respect. " - "Ask if the user needs any further help with their problem." -) +def _load_config() -> dict: + try: + return json.loads(_CONFIG_PATH.read_text(encoding="utf-8")) + except Exception: + return {} + + +def _save_config_key(key: str, value) -> None: + try: + cfg = _load_config() + cfg[key] = value + _CONFIG_PATH.write_text(json.dumps(cfg, indent=4), encoding="utf-8") + except Exception as e: + print(f"[Vision] ⚠️ Could not save config key '{key}': {e}") def _get_api_key() -> str: + key = _load_config().get("gemini_api_key", "") + if not key: + raise RuntimeError("gemini_api_key not found in config.") + return key + + +def _get_os() -> str: + return _load_config().get("os_system", "windows").lower() + +_LIVE_MODEL = "models/gemini-2.5-flash-native-audio-preview-12-2025" +_CHANNELS = 1 +_RECEIVE_SAMPLE_RATE = 24_000 +_CHUNK_SIZE = 1_024 + +_IMG_MAX_W = 640 +_IMG_MAX_H = 360 +_JPEG_Q = 60 + +_SYSTEM_PROMPT = ( + "You are JARVIS, an advanced AI assistant. " + "Analyze the provided image with precision and intelligence. " + "Be concise and direct — maximum two sentences unless the user's question " + "requires more detail. " + "Address the user respectfully. " + "Always call the appropriate tool; never simulate results." +) + + +def _compress(img_bytes: bytes, source_format: str = "PNG") -> tuple[bytes, str]: + if not _PIL: + return img_bytes, f"image/{source_format.lower()}" + try: - with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: - keys = json.load(f) - key = keys.get("gemini_api_key", "") - if not key: - raise ValueError("gemini_api_key not found") - return key + img = PIL.Image.open(io.BytesIO(img_bytes)).convert("RGB") + img.thumbnail((_IMG_MAX_W, _IMG_MAX_H), PIL.Image.BILINEAR) + buf = io.BytesIO() + img.save(buf, format="JPEG", quality=_JPEG_Q, optimize=False) + return buf.getvalue(), "image/jpeg" except Exception as e: - raise RuntimeError(f"Could not load API key: {e}") + print(f"[Vision] ⚠️ Image compress failed: {e}") + return img_bytes, f"image/{source_format.lower()}" + +def _capture_screen() -> tuple[bytes, str]: + + if not _MSS: + raise RuntimeError("mss is not installed. Run: pip install mss") + + with mss.mss() as sct: + monitors = sct.monitors # [0] = all combined, [1..n] = real screens + target = monitors[1] if len(monitors) > 1 else monitors[0] + shot = sct.grab(target) + png = mss.tools.to_png(shot.rgb, shot.size) + + return _compress(png, "PNG") + + +def _cv2_backend() -> int: + """Return the best OpenCV camera backend for the current OS.""" + if not _CV2: + return 0 + os_name = _get_os() + if os_name == "windows": + return cv2.CAP_DSHOW + if os_name == "mac": + return cv2.CAP_AVFOUNDATION + return cv2.CAP_ANY + + +def _probe_camera(index: int, backend: int, warmup: int = 5) -> bool: + + if not _CV2: + return False + cap = cv2.VideoCapture(index, backend) + if not cap.isOpened(): + cap.release() + return False + for _ in range(warmup): + cap.read() + ret, frame = cap.read() + cap.release() + if not ret or frame is None: + return False + return bool(np.mean(frame) > 8) + + +def _detect_camera_index() -> int: + + backend = _cv2_backend() + print("[Vision] 🔍 Auto-detecting camera...") + for idx in range(6): + if _probe_camera(idx, backend): + print(f"[Vision] ✅ Camera found at index {idx}") + _save_config_key("camera_index", idx) + return idx + print(f"[Vision] ⚠️ Camera index {idx}: no usable frame") + + print("[Vision] ⚠️ No camera found — defaulting to index 0") + _save_config_key("camera_index", 0) + return 0 def _get_camera_index() -> int: - """ - Reads camera index from config. - If not set, auto-detects the best camera and saves it for future use. - Runs only once — after that, config value is used directly. - """ - try: - with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: - cfg = json.load(f) - if "camera_index" in cfg: - return int(cfg["camera_index"]) - except Exception: - pass - - print("[Camera] 🔍 No camera index in config. Auto-detecting...") - best_index = 0 - - for idx in range(6): - cap = cv2.VideoCapture(idx, cv2.CAP_DSHOW) - if not cap.isOpened(): - cap.release() - continue - - for _ in range(5): - cap.read() - - ret, frame = cap.read() - cap.release() - - if ret and frame is not None and frame.mean() > 5: - best_index = idx - print(f"[Camera] ✅ Camera found at index {idx} — saving to config.") - break - else: - print(f"[Camera] ⚠️ Index {idx}: no valid frame (black or empty).") - - try: - cfg = {} - if API_CONFIG_PATH.exists(): - with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: - cfg = json.load(f) - cfg["camera_index"] = best_index - with open(API_CONFIG_PATH, "w", encoding="utf-8") as f: - json.dump(cfg, f, indent=4) - print(f"[Camera] 💾 Camera index {best_index} saved to config.") - except Exception as e: - print(f"[Camera] ⚠️ Could not save camera index: {e}") - - return best_index + cfg = _load_config() + if "camera_index" in cfg: + return int(cfg["camera_index"]) + return _detect_camera_index() -def _to_jpeg(img_bytes: bytes) -> bytes: - if not _PIL_OK: - return img_bytes - img = PIL.Image.open(io.BytesIO(img_bytes)).convert("RGB") - img.thumbnail([IMG_MAX_W, IMG_MAX_H], PIL.Image.BILINEAR) - buf = io.BytesIO() - img.save(buf, format="JPEG", quality=JPEG_Q, optimize=False) - return buf.getvalue() +def _capture_camera() -> tuple[bytes, str]: + if not _CV2: + raise RuntimeError("OpenCV (cv2) is not installed. Run: pip install opencv-python") + index = _get_camera_index() + backend = _cv2_backend() + cap = cv2.VideoCapture(index, backend) -def _capture_screenshot() -> bytes: - with mss.mss() as sct: - shot = sct.grab(sct.monitors[1]) - png_bytes = mss.tools.to_png(shot.rgb, shot.size) - return _to_jpeg(png_bytes) - - -def _capture_camera() -> bytes: - camera_index = _get_camera_index() - cap = cv2.VideoCapture(camera_index, cv2.CAP_DSHOW) if not cap.isOpened(): - raise RuntimeError(f"Camera could not be opened: index {camera_index}") + raise RuntimeError(f"Camera index {index} could not be opened.") for _ in range(10): cap.read() @@ -154,127 +189,140 @@ def _capture_camera() -> bytes: cap.release() if not ret or frame is None: - raise RuntimeError("Could not capture camera frame.") + raise RuntimeError("Camera returned no frame.") - if _PIL_OK: + if _PIL: rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) img = PIL.Image.fromarray(rgb) - img.thumbnail([IMG_MAX_W, IMG_MAX_H], PIL.Image.BILINEAR) + img.thumbnail((_IMG_MAX_W, _IMG_MAX_H), PIL.Image.BILINEAR) buf = io.BytesIO() - img.save(buf, format="JPEG", quality=JPEG_Q, optimize=False) - return buf.getvalue() + img.save(buf, format="JPEG", quality=_JPEG_Q) + return buf.getvalue(), "image/jpeg" - _, buf = cv2.imencode(".jpg", frame, [cv2.IMWRITE_JPEG_QUALITY, JPEG_Q]) - return buf.tobytes() - - -class _LiveSession: - """ - Image-only analysis session. - No microphone — no conflict with main.py session. - Sends image + question, plays audio response. - """ + _, buf = cv2.imencode(".jpg", frame, [cv2.IMWRITE_JPEG_QUALITY, _JPEG_Q]) + return buf.tobytes(), "image/jpeg" +class _VisionSession: def __init__(self): - self._loop: asyncio.AbstractEventLoop | None = None - self._thread: threading.Thread | None = None - self._session = None - self._out_queue: asyncio.Queue | None = None - self._audio_in: asyncio.Queue | None = None - self._ready: threading.Event = threading.Event() - self._player = None - self._pya = pyaudio.PyAudio() - self._send_lock: asyncio.Lock | None = None + self._loop: Optional[asyncio.AbstractEventLoop] = None + self._thread: Optional[threading.Thread] = None + self._session = None + self._out_queue: Optional[asyncio.Queue] = None + self._audio_in: Optional[asyncio.Queue] = None + self._ready_evt: threading.Event = threading.Event() + self._player = None + self._lock: threading.Lock = threading.Lock() - def start(self, player=None): - if self._thread and self._thread.is_alive(): + def start(self, player=None, timeout: float = 25.0) -> None: + with self._lock: + if self._thread and self._thread.is_alive(): + if player is not None: + self._player = player + return + self._player = player + self._thread = threading.Thread( + target=self._run_event_loop, + daemon=True, + name="VisionSessionThread", + ) + self._thread.start() + + if not self._ready_evt.wait(timeout=timeout): + raise RuntimeError(f"Vision session did not connect within {timeout}s.") + print("[Vision] ✅ Session ready") + + def analyze(self, image_bytes: bytes, mime_type: str, user_text: str) -> None: + if not self._loop or not self._out_queue: + print("[Vision] ⚠️ Session not started — dropping request") return - self._player = player - self._thread = threading.Thread( - target=self._run_loop, daemon=True, name="VisionSessionThread" + asyncio.run_coroutine_threadsafe( + self._out_queue.put((image_bytes, mime_type, user_text)), + self._loop, ) - self._thread.start() - ok = self._ready.wait(timeout=20) - if not ok: - raise RuntimeError("Vision session did not start within 20s.") - print("[ScreenProcess] ✅ Vision session ready (no mic)") - def _run_loop(self): + def is_ready(self) -> bool: + return self._session is not None + + def _run_event_loop(self) -> None: self._loop = asyncio.new_event_loop() asyncio.set_event_loop(self._loop) - self._loop.run_until_complete(self._main()) + self._loop.run_until_complete(self._session_loop()) - async def _main(self): + async def _session_loop(self) -> None: self._out_queue = asyncio.Queue(maxsize=30) self._audio_in = asyncio.Queue() - self._send_lock = asyncio.Lock() client = genai.Client( api_key=_get_api_key(), - http_options={"api_version": "v1beta"} + http_options={"api_version": "v1beta"}, ) - - config = types.LiveConnectConfig( + config = gtypes.LiveConnectConfig( response_modalities=["AUDIO"], output_audio_transcription={}, - system_instruction=SYSTEM_PROMPT, - speech_config=types.SpeechConfig( - voice_config=types.VoiceConfig( - prebuilt_voice_config=types.PrebuiltVoiceConfig( + system_instruction=_SYSTEM_PROMPT, + speech_config=gtypes.SpeechConfig( + voice_config=gtypes.VoiceConfig( + prebuilt_voice_config=gtypes.PrebuiltVoiceConfig( voice_name="Charon" ) ) ), ) + backoff = 2.0 while True: try: - print("[ScreenProcess] 🔌 Vision session connecting...") - async with client.aio.live.connect(model=LIVE_MODEL, config=config) as session: + print("[Vision] 🔌 Connecting...") + async with client.aio.live.connect( + model=_LIVE_MODEL, config=config + ) as session: self._session = session - self._ready.set() - print("[ScreenProcess] ✅ Vision session connected") + self._ready_evt.set() + backoff = 2.0 + print("[Vision] ✅ Connected") async with asyncio.TaskGroup() as tg: tg.create_task(self._send_loop()) tg.create_task(self._recv_loop()) tg.create_task(self._play_loop()) - except Exception as e: - print(f"[ScreenProcess] ⚠️ Disconnected: {e} — reconnecting...") + except* Exception as eg: + for exc in eg.exceptions: + print(f"[Vision] ⚠️ Session error: {exc}") + finally: self._session = None - self._ready.clear() - await asyncio.sleep(2) - self._ready.set() + self._ready_evt.clear() - # ── Send loop ── + print(f"[Vision] 🔄 Reconnecting in {backoff:.0f}s...") + await asyncio.sleep(backoff) + backoff = min(backoff * 1.5, 30.0) + self._ready_evt.set() - async def _send_loop(self): - """Sends (image_bytes, mime_type, user_text) tuples from queue.""" + async def _send_loop(self) -> None: while True: - item = await self._out_queue.get() - if self._session: - image_bytes, mime_type, user_text = item - try: - b64 = base64.b64encode(image_bytes).decode("utf-8") - await self._session.send_client_content( - turns={ - "parts": [ - {"inline_data": {"mime_type": mime_type, "data": b64}}, - {"text": user_text} - ] - }, - turn_complete=True - ) - print("[ScreenProcess] ✅ Image sent") - except Exception as e: - print(f"[ScreenProcess] ⚠️ Send error: {e}") + image_bytes, mime_type, user_text = await self._out_queue.get() + if not self._session: + print("[Vision] ⚠️ No session — dropping image") + continue + try: + b64 = base64.b64encode(image_bytes).decode("ascii") + await self._session.send_client_content( + turns={ + "parts": [ + {"inline_data": {"mime_type": mime_type, "data": b64}}, + {"text": user_text}, + ] + }, + turn_complete=True, + ) + print(f"[Vision] 📤 Sent {len(image_bytes):,} bytes — '{user_text[:60]}'") + except Exception as e: + print(f"[Vision] ⚠️ Send error: {e}") - async def _recv_loop(self): - transcript_buf: list[str] = [] + async def _recv_loop(self) -> None: + transcript: list[str] = [] try: async for response in self._session.receive(): - if response.data: await self._audio_in.put(response.data) @@ -285,120 +333,110 @@ class _LiveSession: if sc.output_transcription and sc.output_transcription.text: chunk = sc.output_transcription.text.strip() if chunk: - transcript_buf.append(chunk) + transcript.append(chunk) if sc.turn_complete: - if transcript_buf and self._player: - full = re.sub(r'\s+', ' ', " ".join(transcript_buf)).strip() + if transcript and self._player: + full = re.sub(r"\s+", " ", " ".join(transcript)).strip() if full: self._player.write_log(f"Jarvis: {full}") - print(f"[ScreenProcess] 💬 {full}") - transcript_buf = [] + print(f"[Vision] 💬 {full}") + transcript = [] except Exception as e: - print(f"[ScreenProcess] ⚠️ Recv error: {e}") - transcript_buf = [] - await asyncio.sleep(0.3) + print(f"[Vision] ⚠️ Recv error: {e}") + raise - async def _play_loop(self): - stream = await asyncio.to_thread( - self._pya.open, - format=FORMAT, channels=CHANNELS, - rate=RECEIVE_SAMPLE_RATE, output=True, + async def _play_loop(self) -> None: + stream = sd.RawOutputStream( + samplerate=_RECEIVE_SAMPLE_RATE, + channels=_CHANNELS, + dtype="int16", + blocksize=_CHUNK_SIZE, ) + stream.start() try: while True: chunk = await self._audio_in.get() await asyncio.to_thread(stream.write, chunk) + except Exception as e: + print(f"[Vision] ❌ Play error: {e}") + raise finally: + stream.stop() stream.close() - def analyze(self, image_bytes: bytes, mime_type: str, user_text: str): - """Called from main thread — puts image into async queue.""" - if not self._loop: - return - asyncio.run_coroutine_threadsafe( - self._out_queue.put((image_bytes, mime_type, user_text)), - self._loop - ) - - def is_ready(self) -> bool: - return self._session is not None - -_live = _LiveSession() -_started = False -_start_lock = threading.Lock() +_session = _VisionSession() +_session_lock = threading.Lock() +_session_up = False -def _ensure_started(player=None): - global _started - with _start_lock: - if not _started: - _live.start(player=player) - _started = True +def _ensure_session(player=None) -> None: + global _session_up + with _session_lock: + if not _session_up: + _session.start(player=player) + _session_up = True elif player is not None: - _live._player = player + _session._player = player + def screen_process( parameters: dict, - response: str | None = None, + response=None, player=None, session_memory=None, ) -> bool: - user_text = (parameters or {}).get("text") or (parameters or {}).get("user_text", "") - user_text = (user_text or "").strip() + + params = parameters or {} + user_text = (params.get("text") or params.get("user_text") or "").strip() + angle = params.get("angle", "screen").lower().strip() + if not user_text: - print("[ScreenProcess] ⚠️ No user_text provided.") + print("[Vision] ⚠️ No question provided — aborting") return False - angle = (parameters or {}).get("angle", "screen").lower().strip() - print(f"[ScreenProcess] angle={angle!r} text={user_text!r}") + print(f"[Vision] ▶ angle={angle!r} question='{user_text[:80]}'") - _ensure_started(player=player) + try: + _ensure_session(player=player) + except Exception as e: + print(f"[Vision] ❌ Could not start session: {e}") + return False try: if angle == "camera": - image_bytes = _capture_camera() - mime_type = "image/jpeg" - print("[ScreenProcess] 📷 Camera captured") + image_bytes, mime_type = _capture_camera() + print(f"[Vision] 📷 Camera: {len(image_bytes):,} bytes") else: - image_bytes = _capture_screenshot() - mime_type = "image/jpeg" if _PIL_OK else "image/png" - print("[ScreenProcess] 🖥️ Screen captured") + image_bytes, mime_type = _capture_screen() + print(f"[Vision] 🖥️ Screen: {len(image_bytes):,} bytes") except Exception as e: - import traceback; traceback.print_exc() - print(f"[ScreenProcess] ❌ Capture error: {e}") + print(f"[Vision] ❌ Capture error: {e}") return False - print(f"[ScreenProcess] 📦 {len(image_bytes)} bytes → sending") - _live.analyze(image_bytes, mime_type, user_text) + _session.analyze(image_bytes, mime_type, user_text) return True -def warmup_session(player=None): - """ - Optional: pre-warm the session. - Do NOT call from main.py — causes double session issue. - Only use when testing screen_processor.py standalone. - """ +def warmup_session(player=None) -> None: try: - _ensure_started(player=player) + _ensure_session(player=player) except Exception as e: - print(f"[ScreenProcess] ⚠️ Warmup error: {e}") - + print(f"[Vision] ⚠️ Warmup failed: {e}") if __name__ == "__main__": - print("[TEST] screen_processor.py v8 — image-only session") - print("=" * 50) - mode = input("screen / camera (default: screen): ").strip().lower() or "screen" - request = input("Question (Enter for default): ").strip() or "What do you see? Be brief." + print("[TEST] screen_processor.py") + print("=" * 52) + mode = input("angle — screen / camera (default: screen): ").strip().lower() or "screen" + q = input("Question (Enter = default): ").strip() or "What do you see? Be brief." t0 = time.perf_counter() warmup_session() - print(f"Session ready — {time.perf_counter()-t0:.2f}s\n") + print(f"Session ready in {time.perf_counter()-t0:.2f}s\n") - t1 = time.perf_counter() - result = screen_process({"angle": mode, "text": request}, player=None) - print(f"Sent — {time.perf_counter()-t1:.3f}s | audio incoming...") - time.sleep(8) - print(f"\n{'✅' if result else '❌'}") \ No newline at end of file + t1 = time.perf_counter() + ok = screen_process({"angle": mode, "text": q}) + print(f"Queued in {time.perf_counter()-t1:.3f}s — waiting for audio...") + time.sleep(10) + print("Done." if ok else "Failed.") \ No newline at end of file diff --git a/actions/send_message.py b/actions/send_message.py index 1fd9bf6..e2426b4 100644 --- a/actions/send_message.py +++ b/actions/send_message.py @@ -1,214 +1,269 @@ -# actions/send_message.py -# Universal messaging — WhatsApp & Instagram -# Uses visual element detection (pyautogui + screen search) instead of -# hardcoded tab/click sequences — works on any screen resolution. - +import json +import subprocess +import sys import time -import pyautogui from pathlib import Path -pyautogui.FAILSAFE = True -pyautogui.PAUSE = 0.08 +try: + import pyautogui + pyautogui.FAILSAFE = True + pyautogui.PAUSE = 0.06 + _PYAUTOGUI = True +except ImportError: + _PYAUTOGUI = False + +try: + import pyperclip + _PYPERCLIP = True +except ImportError: + _PYPERCLIP = False + +def _base_dir() -> Path: + if getattr(sys, "frozen", False): + return Path(sys.executable).parent + return Path(__file__).resolve().parent.parent + +def _get_os() -> str: + try: + cfg = json.loads( + (_base_dir() / "config" / "api_keys.json").read_text(encoding="utf-8") + ) + return cfg.get("os_system", "windows").lower() + except Exception: + return "windows" + + +def _require_pyautogui(): + if not _PYAUTOGUI: + raise RuntimeError("PyAutoGUI not installed. Run: pip install pyautogui") + + +def _paste_text(text: str) -> None: + _require_pyautogui() + + os_name = _get_os() + paste_hotkey = ("command", "v") if os_name == "mac" else ("ctrl", "v") + + if _PYPERCLIP: + pyperclip.copy(text) + time.sleep(0.15) + pyautogui.hotkey(*paste_hotkey) + time.sleep(0.1) + else: + pyautogui.write(text, interval=0.03) + + +def _clear_and_paste(text: str) -> None: + _require_pyautogui() + os_name = _get_os() + select_all = ("command", "a") if os_name == "mac" else ("ctrl", "a") + pyautogui.hotkey(*select_all) + time.sleep(0.1) + pyautogui.press("delete") + time.sleep(0.1) + _paste_text(text) def _open_app(app_name: str) -> bool: - """Opens an app via Windows search.""" + _require_pyautogui() + os_name = _get_os() + try: - pyautogui.press("win") - time.sleep(0.4) - pyautogui.write(app_name, interval=0.04) - time.sleep(0.5) - pyautogui.press("enter") - time.sleep(2.0) - return True + if os_name == "windows": + pyautogui.press("win") + time.sleep(0.5) + _paste_text(app_name) + time.sleep(0.6) + pyautogui.press("enter") + time.sleep(2.5) + return True + + elif os_name == "mac": + result = subprocess.run( + ["open", "-a", app_name], + capture_output=True, text=True, timeout=10, + ) + if result.returncode != 0: + result = subprocess.run( + ["open", "-a", f"{app_name}.app"], + capture_output=True, text=True, timeout=10, + ) + time.sleep(2.5) + return result.returncode == 0 + + else: + launched = False + for launcher in [ + ["gtk-launch", app_name.lower()], + [app_name.lower()], + ]: + try: + subprocess.Popen( + launcher, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + launched = True + break + except FileNotFoundError: + continue + time.sleep(2.5) + return launched + except Exception as e: - print(f"[SendMessage] Could not open {app_name}: {e}") + print(f"[SendMessage] ⚠️ Could not open {app_name}: {e}") return False -def _search_contact(contact: str, platform: str): - """ - Searches for a contact inside the messaging app. - Uses Ctrl+F (universal search shortcut) then types contact name. - """ +def _open_browser_url(url: str) -> bool: + import webbrowser + try: + webbrowser.open(url) + time.sleep(4.0) + return True + except Exception as e: + print(f"[SendMessage] ⚠️ Could not open browser: {e}") + return False + +def _search_in_app(query: str) -> None: + _require_pyautogui() + os_name = _get_os() + search_hotkey = ("command", "f") if os_name == "mac" else ("ctrl", "f") + + pyautogui.hotkey(*search_hotkey) time.sleep(0.5) - pyautogui.hotkey("ctrl", "f") - time.sleep(0.4) - pyautogui.hotkey("ctrl", "a") - pyautogui.write(contact, interval=0.04) - time.sleep(0.8) + _clear_and_paste(query) + time.sleep(1.0) + +def _desktop_send(app_name: str, receiver: str, message: str) -> str: + if not _open_app(app_name): + return f"Could not open {app_name}." + + time.sleep(1.0) + _search_in_app(receiver) pyautogui.press("enter") - time.sleep(0.6) + time.sleep(0.8) - -def _type_and_send(message: str): - """Types message and sends it.""" - pyautogui.press("tab") - time.sleep(0.2) - pyautogui.hotkey("ctrl", "a") - pyautogui.write(message, interval=0.03) + _paste_text(message) time.sleep(0.2) pyautogui.press("enter") time.sleep(0.3) + return f"Message sent to {receiver} via {app_name}." + def _send_whatsapp(receiver: str, message: str) -> str: - """ - Sends a WhatsApp message via the Windows desktop app. - Steps: Open WhatsApp → Search contact → Click → Type → Send - """ - try: - if not _open_app("WhatsApp"): - return "Could not open WhatsApp." + return _desktop_send("WhatsApp", receiver, message) - time.sleep(1.5) - pyautogui.hotkey("ctrl", "f") - time.sleep(0.4) - pyautogui.hotkey("ctrl", "a") - pyautogui.write(receiver, interval=0.04) - time.sleep(1.0) +def _send_telegram(receiver: str, message: str) -> str: + return _desktop_send("Telegram", receiver, message) - pyautogui.press("enter") - time.sleep(0.8) - pyautogui.write(message, interval=0.03) - time.sleep(0.2) - pyautogui.press("enter") +def _send_signal(receiver: str, message: str) -> str: + return _desktop_send("Signal", receiver, message) - return f"Message sent to {receiver} via WhatsApp." - except Exception as e: - return f"WhatsApp error: {e}" +def _send_discord(receiver: str, message: str) -> str: + return _desktop_send("Discord", receiver, message) def _send_instagram(receiver: str, message: str) -> str: - """ - Sends an Instagram DM via browser (instagram.com). - Steps: Open Chrome → Go to instagram.com/direct → Search contact → Send - """ - try: - import webbrowser + _require_pyautogui() - webbrowser.open("https://www.instagram.com/direct/new/") - time.sleep(3.5) + if not _open_browser_url("https://www.instagram.com/direct/new/"): + return "Could not open Instagram in browser." - pyautogui.write(receiver, interval=0.05) - time.sleep(1.5) + _paste_text(receiver) + time.sleep(1.5) - pyautogui.press("down") - time.sleep(0.3) - pyautogui.press("enter") - time.sleep(0.5) + pyautogui.press("down") + time.sleep(0.3) + pyautogui.press("enter") + time.sleep(0.4) - for _ in range(3): - pyautogui.press("tab") - time.sleep(0.1) - pyautogui.press("enter") - time.sleep(1.5) + for _ in range(4): + pyautogui.press("tab") + time.sleep(0.15) + pyautogui.press("enter") + time.sleep(2.0) - pyautogui.write(message, interval=0.04) - time.sleep(0.2) - pyautogui.press("enter") + _paste_text(message) + time.sleep(0.2) + pyautogui.press("enter") + time.sleep(0.3) - return f"Message sent to {receiver} via Instagram." - - except Exception as e: - return f"Instagram error: {e}" - -def _send_telegram(receiver: str, message: str) -> str: - """Sends a Telegram message via Windows desktop app.""" - try: - if not _open_app("Telegram"): - return "Could not open Telegram." - - time.sleep(1.5) - - pyautogui.hotkey("ctrl", "f") - time.sleep(0.4) - pyautogui.write(receiver, interval=0.04) - time.sleep(1.0) - pyautogui.press("enter") - time.sleep(0.8) - - pyautogui.write(message, interval=0.03) - time.sleep(0.2) - pyautogui.press("enter") - - return f"Message sent to {receiver} via Telegram." - - except Exception as e: - return f"Telegram error: {e}" + return f"Message sent to {receiver} via Instagram." +def _send_messenger(receiver: str, message: str) -> str: + _require_pyautogui() -def _send_generic(platform: str, receiver: str, message: str) -> str: - """ - For any other platform not explicitly supported. - Opens the app, searches for contact, types and sends. - Works for: Messenger, Discord, Signal, etc. - """ - try: - if not _open_app(platform): - return f"Could not open {platform}." + if not _open_browser_url("https://www.messenger.com/"): + return "Could not open Messenger in browser." - time.sleep(1.5) - pyautogui.hotkey("ctrl", "f") - time.sleep(0.4) - pyautogui.write(receiver, interval=0.04) - time.sleep(1.0) - pyautogui.press("enter") - time.sleep(0.8) - pyautogui.write(message, interval=0.03) - time.sleep(0.2) - pyautogui.press("enter") - return f"Message sent to {receiver} via {platform}." + _search_in_app(receiver) + time.sleep(0.5) + pyautogui.press("down") + time.sleep(0.3) + pyautogui.press("enter") + time.sleep(1.0) + + _paste_text(message) + time.sleep(0.2) + pyautogui.press("enter") + time.sleep(0.3) + + return f"Message sent to {receiver} via Messenger." + +_PLATFORM_MAP = [ + ({"whatsapp", "wp", "wapp"}, _send_whatsapp), + ({"telegram", "tg"}, _send_telegram), + ({"instagram", "ig", "insta"}, _send_instagram), + ({"signal"}, _send_signal), + ({"discord"}, _send_discord), + ({"messenger", "facebook", "fb"}, _send_messenger), +] + + +def _resolve_platform(platform_str: str): + key = platform_str.lower().strip() + for keywords, handler in _PLATFORM_MAP: + if any(k in key for k in keywords): + return handler + return lambda r, m: _desktop_send(platform_str.strip().title(), r, m) - except Exception as e: - return f"{platform} error: {e}" def send_message( parameters: dict, response=None, player=None, - session_memory=None + session_memory=None, ) -> str: - """ - Called from main.py. - - parameters: - receiver : Contact name to send to - message_text : The message content - platform : whatsapp | instagram | telegram | - Default: whatsapp - """ params = parameters or {} receiver = params.get("receiver", "").strip() message_text = params.get("message_text", "").strip() - platform = params.get("platform", "whatsapp").strip().lower() + platform = params.get("platform", "whatsapp").strip() if not receiver: - return "Please specify who to send the message to, sir." + return "Please specify a recipient." if not message_text: - return "Please specify what message to send, sir." + return "Please specify the message content." + if not _PYAUTOGUI: + return "PyAutoGUI is not installed — cannot control the desktop." - print(f"[SendMessage] 📨 {platform} → {receiver}: {message_text[:40]}") + preview = message_text[:50] + ("…" if len(message_text) > 50 else "") + print(f"[SendMessage] 📨 {platform} → {receiver}: {preview}") if player: - player.write_log(f"[msg] Sending to {receiver} via {platform}...") + player.write_log(f"[msg] {platform} → {receiver}") - if "whatsapp" in platform or "wp" in platform or "wapp" in platform: - result = _send_whatsapp(receiver, message_text) + try: + handler = _resolve_platform(platform) + result = handler(receiver, message_text) + except Exception as e: + result = f"Could not send message: {e}" - elif "instagram" in platform or "ig" in platform or "insta" in platform: - result = _send_instagram(receiver, message_text) - - elif "telegram" in platform or "tg" in platform: - result = _send_telegram(receiver, message_text) - - else: - result = _send_generic(platform, receiver, message_text) - - print(f"[SendMessage] ✅ {result}") + print(f"[SendMessage] {'✅' if 'sent' in result.lower() else '❌'} {result}") if player: player.write_log(f"[msg] {result}") diff --git a/actions/weather_report.py b/actions/weather_report.py index 2ac70a2..71ca3ed 100644 --- a/actions/weather_report.py +++ b/actions/weather_report.py @@ -1,5 +1,3 @@ -# actions/weather_report.py - import webbrowser from urllib.parse import quote_plus @@ -7,54 +5,45 @@ from urllib.parse import quote_plus def weather_action( parameters: dict, player=None, - session_memory=None -): - """ - Weather report action. - Opens a Google weather search and gives a short spoken confirmation. - """ + session_memory=None, +) -> str: + city = parameters.get("city") + when = parameters.get("time", "today") - city = parameters.get("city") - time = parameters.get("time") - if not city or not isinstance(city, str): + if not city or not isinstance(city, str) or not city.strip(): msg = "Sir, the city is missing for the weather report." - _speak_and_log(msg, player) + _log(msg, player) return msg city = city.strip() + when = (when or "today").strip() - if not time or not isinstance(time, str): - time = "today" - else: - time = time.strip() - - search_query = f"weather in {city} {time}" - encoded_query = quote_plus(search_query) - url = f"https://www.google.com/search?q={encoded_query}" + search_query = f"weather in {city} {when}" + url = f"https://www.google.com/search?q={quote_plus(search_query)}" try: - webbrowser.open(url) - except Exception: - msg = f"Sir, I couldn't open the browser for the weather report." - _speak_and_log(msg, player) + opened = webbrowser.open(url) + if not opened: + raise RuntimeError("webbrowser.open returned False") + except Exception as e: + msg = f"Sir, I couldn't open the browser for the weather report: {e}" + _log(msg, player) return msg - msg = f"Showing the weather for {city}, {time}, sir." - _speak_and_log(msg, player) + msg = f"Showing the weather for {city}, {when}, sir." + _log(msg, player) if session_memory: try: - session_memory.set_last_search( - query=search_query, - response=msg - ) + session_memory.set_last_search(query=search_query, response=msg) except Exception: - pass + pass return msg -def _speak_and_log(message: str, player=None): +def _log(message: str, player=None) -> None: + print(f"[Weather] {message}") if player: try: player.write_log(f"JARVIS: {message}") diff --git a/actions/web_search.py b/actions/web_search.py index 4fb67e9..4cea99b 100644 --- a/actions/web_search.py +++ b/actions/web_search.py @@ -1,21 +1,17 @@ -# actions/web_search.py -# MARK XXV — Web Search -# Primary: Gemini google_search (yeni google.genai SDK) -# Fallback: DuckDuckGo (ddgs) - import json import sys from pathlib import Path - -def get_base_dir() -> Path: +def _get_base_dir() -> Path: if getattr(sys, "frozen", False): return Path(sys.executable).parent return Path(__file__).resolve().parent.parent -BASE_DIR = get_base_dir() + +BASE_DIR = _get_base_dir() API_CONFIG_PATH = BASE_DIR / "config" / "api_keys.json" + def _get_api_key() -> str: with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: return json.load(f)["gemini_api_key"] @@ -24,40 +20,45 @@ def _get_api_key() -> str: def _gemini_search(query: str) -> str: from google import genai - client = genai.Client(api_key=_get_api_key()) + client = genai.Client(api_key=_get_api_key()) response = client.models.generate_content( model="gemini-2.5-flash-lite", contents=query, - config={"tools": [{"google_search": {}}]} + config={"tools": [{"google_search": {}}]}, ) + text = "" for part in response.candidates[0].content.parts: if hasattr(part, "text") and part.text: text += part.text - if not text.strip(): - raise ValueError("Empty response") - return text.strip() + + text = text.strip() + if not text: + raise ValueError("Gemini returned an empty response.") + return text - -def _ddg_search(query: str, max_results: int = 6) -> list: +def _ddg_search(query: str, max_results: int = 6) -> list[dict]: try: from ddgs import DDGS except ImportError: from duckduckgo_search import DDGS + results = [] with DDGS() as ddgs: for r in ddgs.text(query, max_results=max_results): results.append({ - "title": r.get("title", ""), - "snippet": r.get("body", ""), - "url": r.get("href", ""), + "title": r.get("title", ""), + "snippet": r.get("body", ""), + "url": r.get("href", ""), }) return results -def _format_ddg(query: str, results: list) -> str: + +def _format_ddg(query: str, results: list[dict]) -> str: if not results: return f"No results found for: {query}" + lines = [f"Search results for: {query}\n"] for i, r in enumerate(results, 1): if r.get("title"): lines.append(f"{i}. {r['title']}") @@ -66,27 +67,31 @@ def _format_ddg(query: str, results: list) -> str: lines.append("") return "\n".join(lines).strip() - -def _compare(items: list, aspect: str) -> str: - query = f"Compare {', '.join(items)} in terms of {aspect}. Give specific facts and data." +def _compare(items: list[str], aspect: str) -> str: + query = ( + f"Compare {', '.join(items)} in terms of {aspect}. " + "Give specific facts and data." + ) try: return _gemini_search(query) except Exception as e: - print(f"[WebSearch] ⚠️ Gemini compare failed: {e}") - all_results = {} - for item in items: - try: - all_results[item] = _ddg_search(f"{item} {aspect}", max_results=3) - except Exception: - all_results[item] = [] - lines = [f"Comparison — {aspect.upper()}\n{'─'*40}"] - for item in items: - lines.append(f"\n▸ {item}") - for r in all_results.get(item, [])[:2]: - if r.get("snippet"): - lines.append(f" • {r['snippet']}") - return "\n".join(lines) + print(f"[WebSearch] ⚠️ Gemini compare failed: {e} — falling back to DDG") + # DDG fallback: fetch results per item and merge + all_results: dict[str, list] = {} + for item in items: + try: + all_results[item] = _ddg_search(f"{item} {aspect}", max_results=3) + except Exception: + all_results[item] = [] + + lines = [f"Comparison — {aspect.upper()}", "─" * 40] + for item in items: + lines.append(f"\n▸ {item}") + for r in all_results.get(item, [])[:2]: + if r.get("snippet"): + lines.append(f" • {r['snippet']}") + return "\n".join(lines) def web_search( parameters: dict, @@ -96,9 +101,9 @@ def web_search( ) -> str: params = parameters or {} query = params.get("query", "").strip() - mode = params.get("mode", "search").lower() + mode = params.get("mode", "search").lower().strip() items = params.get("items", []) - aspect = params.get("aspect", "general") + aspect = params.get("aspect", "general").strip() or "general" if not query and not items: return "Please provide a search query, sir." @@ -118,18 +123,18 @@ def web_search( print("[WebSearch] ✅ Compare done.") return result - print("[WebSearch] 🌐 Gemini search...") + print("[WebSearch] 🌐 Trying Gemini...") try: result = _gemini_search(query) print("[WebSearch] ✅ Gemini OK.") return result except Exception as e: - print(f"[WebSearch] ⚠️ Gemini failed ({e}), trying DDG...") + print(f"[WebSearch] ⚠️ Gemini failed ({e}) — trying DDG...") results = _ddg_search(query) result = _format_ddg(query, results) - print(f"[WebSearch] ✅ DDG: {len(results)} results.") + print(f"[WebSearch] ✅ DDG: {len(results)} result(s).") return result except Exception as e: - print(f"[WebSearch] ❌ Failed: {e}") + print(f"[WebSearch] ❌ All backends failed: {e}") return f"Search failed, sir: {e}" \ No newline at end of file diff --git a/actions/youtube_video.py b/actions/youtube_video.py index 5db42bd..8a1fc7a 100644 --- a/actions/youtube_video.py +++ b/actions/youtube_video.py @@ -1,27 +1,18 @@ -# actions/youtube_video.py -# MARK XXV — YouTube Controller -# -# Features: -# - play : Search and play a YouTube video (original feature, preserved) -# - summarize : Get transcript → Gemini summary → speak + optional Notepad -# - get_info : Video title, channel, views, duration (scraping) -# - trending : Fetch trending videos for a region - import json import re import sys import time -import threading +import subprocess +import shutil from pathlib import Path +from datetime import datetime +from urllib.parse import quote_plus import pyautogui import numpy as np -import cv2 -from PIL import ImageGrab try: import requests - from bs4 import BeautifulSoup _REQUESTS_OK = True except ImportError: _REQUESTS_OK = False @@ -32,145 +23,123 @@ try: except ImportError: _TRANSCRIPT_OK = False +from config import get_os, is_windows, is_mac, is_linux -def get_base_dir() -> Path: + +def _get_base_dir() -> Path: if getattr(sys, "frozen", False): return Path(sys.executable).parent return Path(__file__).resolve().parent.parent -BASE_DIR = get_base_dir() +BASE_DIR = _get_base_dir() API_CONFIG_PATH = BASE_DIR / "config" / "api_keys.json" HEADERS = { "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " + "Mozilla/5.0 (X11; Linux x86_64) " "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/120.0.0.0 Safari/537.36" + "Chrome/124.0.0.0 Safari/537.36" ), "Accept-Language": "en-US,en;q=0.9", } +_YT_VIDEO_FILTER = "EgIQAQ%3D%3D" + def _get_api_key() -> str: with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: return json.load(f)["gemini_api_key"] -def open_browser(): - pyautogui.press("win") - time.sleep(0.4) - pyautogui.write("browser", interval=0.05) - time.sleep(0.3) - pyautogui.press("enter") - time.sleep(2.0) +def _open_url(url: str) -> None: + try: + if is_mac(): + subprocess.Popen(["open", url]) + elif is_linux(): + subprocess.Popen(["xdg-open", url]) + else: + subprocess.Popen(["cmd", "/c", "start", "", url], shell=False) + except Exception as e: + print(f"[YouTube] ⚠️ open_url failed: {e}") +def _scrape_first_video_url(query: str) -> str | None: -def find_video_thumbnails() -> list[tuple[int, int]]: + if not _REQUESTS_OK: + return None + + search_url = ( + f"https://www.youtube.com/results" + f"?search_query={quote_plus(query)}" + f"&sp={_YT_VIDEO_FILTER}" + ) try: - screenshot = ImageGrab.grab() - img = np.array(screenshot) - screen_h, screen_w = img.shape[:2] + r = requests.get(search_url, headers=HEADERS, timeout=10) + html = r.text - roi_top = int(screen_h * 0.10) - roi_bottom = int(screen_h * 0.75) - roi_left = int(screen_w * 0.20) - roi_right = int(screen_w * 0.80) - roi = img[roi_top:roi_bottom, roi_left:roi_right] + video_ids = re.findall(r'"videoId":"([A-Za-z0-9_-]{11})"', html) - gray = cv2.cvtColor(roi, cv2.COLOR_RGB2GRAY) - edges = cv2.Canny(gray, 30, 100) - kernel = np.ones((3, 3), np.uint8) - edges = cv2.dilate(edges, kernel, iterations=2) - - contours, _ = cv2.findContours( - edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE - ) - - candidates = [] - for c in contours: - x, y, w, h = cv2.boundingRect(c) - area = w * h - ratio = w / h if h > 0 else 0 - if area < 15000: + seen = set() + for vid in video_ids: + if vid in seen: continue - if not (1.4 < ratio < 2.2): + seen.add(vid) + + if f'/shorts/{vid}' in html: continue - center_x = x + w // 2 + roi_left - center_y = y + h // 2 + roi_top - candidates.append((center_x, center_y, area)) - - filtered = [] - for cx, cy, area in sorted(candidates, key=lambda c: c[1]): - if not any(abs(cx - fx) < 80 and abs(cy - fy) < 80 for fx, fy in filtered): - filtered.append((cx, cy)) - - return filtered + return f"https://www.youtube.com/watch?v={vid}" except Exception as e: - print(f"[YouTube] ⚠️ Thumbnail detection failed: {e}") - return [] + print(f"[YouTube] ⚠️ scrape_first_video_url failed: {e}") + return None def _extract_video_id(url: str) -> str | None: - patterns = [ - r"(?:v=|\/v\/|youtu\.be\/|\/embed\/|\/shorts\/)([A-Za-z0-9_-]{11})", - ] - for pattern in patterns: - match = re.search(pattern, url) - if match: - return match.group(1) - return None + match = re.search( + r"(?:v=|\/v\/|youtu\.be\/|\/embed\/|\/shorts\/)([A-Za-z0-9_-]{11})", url + ) + return match.group(1) if match else None + + +def _is_valid_youtube_url(url: str) -> bool: + return bool(re.search(r"(youtube\.com|youtu\.be)", url or "")) def _ask_for_url(prompt_text: str = "YouTube video URL:") -> str | None: - try: import tkinter as tk from tkinter import simpledialog - root = tk._default_root + root = tk._default_root if root is None: root = tk.Tk() root.withdraw() - url = simpledialog.askstring( - "J.A.R.V.I.S", - prompt_text, - parent=root - ) + url = simpledialog.askstring("J.A.R.V.I.S", prompt_text, parent=root) return url.strip() if url else None except Exception as e: print(f"[YouTube] ⚠️ URL dialog failed: {e}") return None -def _is_valid_youtube_url(url: str) -> bool: - return bool(re.search(r"(youtube\.com|youtu\.be)", url or "")) - def _get_transcript(video_id: str) -> str | None: - if not _TRANSCRIPT_OK: - print("[YouTube] ⚠️ youtube-transcript-api not installed.") return None - try: transcript_list = YouTubeTranscriptApi.list_transcripts(video_id) + transcript = None + + lang_priority = ["en", "tr", "de", "fr", "es", "it", "pt", "ru", "ja", "ko", "ar", "zh"] - transcript = None try: - transcript = transcript_list.find_manually_created_transcript( - ["en", "tr", "de", "fr", "es", "it", "pt", "ru", "ja", "ko", "ar", "zh"] - ) + transcript = transcript_list.find_manually_created_transcript(lang_priority) except Exception: pass if transcript is None: try: - transcript = transcript_list.find_generated_transcript( - ["en", "tr", "de", "fr", "es", "it", "pt", "ru", "ja", "ko", "ar", "zh"] - ) + transcript = transcript_list.find_generated_transcript(lang_priority) except Exception: for t in transcript_list: transcript = t @@ -180,22 +149,21 @@ def _get_transcript(video_id: str) -> str | None: return None fetched = transcript.fetch() - text = " ".join(entry["text"] for entry in fetched) - print(f"[YouTube] 📝 Transcript: {len(text)} chars") - return text + return " ".join(entry["text"] for entry in fetched) except Exception as e: print(f"[YouTube] ⚠️ Transcript fetch failed: {e}") return None + def _summarize_with_gemini(transcript: str, video_url: str) -> str: import google.generativeai as genai genai.configure(api_key=_get_api_key()) model = genai.GenerativeModel( - model_name="gemini-3.0-flash", + model_name="gemini-2.5-flash", system_instruction=( - "You are JARVIS, Tony Stark's AI assistant. " + "You are JARVIS, an AI assistant. " "Summarize YouTube video transcripts clearly and concisely. " "Structure: 1-sentence overview, then 3-5 key points. " "Be direct. Address the user as 'sir'. " @@ -205,17 +173,13 @@ def _summarize_with_gemini(transcript: str, video_url: str) -> str: max_chars = 80000 truncated = transcript[:max_chars] + ("..." if len(transcript) > max_chars else "") - - response = model.generate_content( + response = model.generate_content( f"Please summarize this YouTube video transcript:\n\n{truncated}" ) return response.text.strip() -def _save_to_notepad(content: str, video_url: str) -> str: - import subprocess - import platform - from datetime import datetime +def _save_summary(content: str, video_url: str) -> str: ts = datetime.now().strftime("%Y%m%d_%H%M%S") filename = f"youtube_summary_{ts}.txt" desktop = Path.home() / "Desktop" @@ -229,67 +193,57 @@ def _save_to_notepad(content: str, video_url: str) -> str: f"Date : {datetime.now().strftime('%Y-%m-%d %H:%M')}\n" f"{'─' * 50}\n\n" ) - filepath.write_text(header + content, encoding="utf-8") - print(f"[YouTube] 💾 Summary saved: {filepath}") - system = platform.system() - open_fn = { - "Windows": lambda p: subprocess.Popen(["notepad.exe", str(p)]), - "Darwin": lambda p: subprocess.Popen(["open", "-t", str(p)]), - "Linux": lambda p: subprocess.Popen(["xdg-open", str(p)]), - } - opener = open_fn.get(system) - if opener: - opener(filepath) + try: + if is_windows(): + subprocess.Popen(["notepad.exe", str(filepath)]) + elif is_mac(): + subprocess.Popen(["open", "-t", str(filepath)]) + else: + subprocess.Popen(["xdg-open", str(filepath)]) + except Exception as e: + print(f"[YouTube] ⚠️ Could not open text editor: {e}") return str(filepath) -def _scrape_video_info(video_id: str) -> dict: +def _scrape_video_info(video_id: str) -> dict: if not _REQUESTS_OK: return {} - url = f"https://www.youtube.com/watch?v={video_id}" try: r = requests.get(url, headers=HEADERS, timeout=12) html = r.text - info = {} - title_match = re.search(r'"title":\{"runs":\[\{"text":"([^"]+)"', html) - if title_match: - info["title"] = title_match.group(1) - - channel_match = re.search(r'"ownerChannelName":"([^"]+)"', html) - if channel_match: - info["channel"] = channel_match.group(1) - - views_match = re.search(r'"viewCount":"(\d+)"', html) - if views_match: - views = int(views_match.group(1)) - info["views"] = f"{views:,}" - - duration_match = re.search(r'"lengthSeconds":"(\d+)"', html) - if duration_match: - secs = int(duration_match.group(1)) - info["duration"] = f"{secs // 60}:{secs % 60:02d}" - - likes_match = re.search(r'"label":"([0-9,]+ likes)"', html) - if likes_match: - info["likes"] = likes_match.group(1) + for key, pattern in [ + ("title", r'"title":\{"runs":\[\{"text":"([^"]+)"'), + ("channel", r'"ownerChannelName":"([^"]+)"'), + ("views", r'"viewCount":"(\d+)"'), + ("duration", r'"lengthSeconds":"(\d+)"'), + ("likes", r'"label":"([0-9,]+ likes)"'), + ]: + match = re.search(pattern, html) + if match: + raw = match.group(1) + if key == "views": + info[key] = f"{int(raw):,}" + elif key == "duration": + secs = int(raw) + info[key] = f"{secs // 60}:{secs % 60:02d}" + else: + info[key] = raw return info - except Exception as e: print(f"[YouTube] ⚠️ Info scrape failed: {e}") return {} -def _scrape_trending(region: str = "TR", max_results: int = 8) -> list[dict]: +def _scrape_trending(region: str = "TR", max_results: int = 8) -> list[dict]: if not _REQUESTS_OK: return [] - url = f"https://www.youtube.com/feed/trending?gl={region.upper()}" try: r = requests.get(url, headers=HEADERS, timeout=12) @@ -298,8 +252,7 @@ def _scrape_trending(region: str = "TR", max_results: int = 8) -> list[dict]: titles = re.findall(r'"title":\{"runs":\[\{"text":"([^"]+)"\}\]', html) channels = re.findall(r'"ownerText":\{"runs":\[\{"text":"([^"]+)"', html) - results = [] - seen = set() + results, seen = [], set() for i, title in enumerate(titles): if title in seen or len(title) < 5: continue @@ -310,7 +263,6 @@ def _scrape_trending(region: str = "TR", max_results: int = 8) -> list[dict]: break return results - except Exception as e: print(f"[YouTube] ⚠️ Trending scrape failed: {e}") return [] @@ -323,50 +275,32 @@ def _handle_play(parameters: dict, player) -> str: if player: player.write_log(f"[YouTube] Searching: {query}") - open_browser() + print(f"[YouTube] 🔍 Scraping first non-Shorts video for: {query}") - search_query = query.replace(" ", "+") - url = f"https://www.youtube.com/results?search_query={search_query}" + video_url = _scrape_first_video_url(query) - pyautogui.hotkey("ctrl", "l") - time.sleep(0.3) - pyautogui.write(url, interval=0.02) - pyautogui.press("enter") - time.sleep(3.5) + if video_url: + print(f"[YouTube] ▶️ Opening: {video_url}") + _open_url(video_url) + return f"Playing: {query}" - thumbnails = find_video_thumbnails() - - if len(thumbnails) >= 2: - x, y = thumbnails[1] - print(f"[YouTube] 🎯 Clicking 2nd thumbnail at ({x}, {y})") - pyautogui.click(x, y) - return f"Playing YouTube video for: {query}" - - elif len(thumbnails) == 1: - x, y = thumbnails[0] - print(f"[YouTube] ⚠️ One thumbnail found, clicking at ({x}, {y})") - pyautogui.click(x, y) - return f"Playing YouTube video for: {query}" - - else: - print("[YouTube] ⚠️ No thumbnails found, using fallback position") - screen_w, screen_h = pyautogui.size() - pyautogui.click(screen_w // 2, int(screen_h * 0.45)) - return f"Attempted to play YouTube video for: {query}" + print(f"[YouTube] ⚠️ Scrape failed, opening filtered search page") + fallback_url = ( + f"https://www.youtube.com/results" + f"?search_query={quote_plus(query)}" + f"&sp={_YT_VIDEO_FILTER}" + ) + _open_url(fallback_url) + return f"Opened YouTube search for: {query} (manual selection required)" def _handle_summarize(parameters: dict, player, speak) -> str: - if not _TRANSCRIPT_OK: - return ( - "youtube-transcript-api is not installed, sir. " - "Please run: pip install youtube-transcript-api" - ) + return "youtube-transcript-api is not installed. Run: pip install youtube-transcript-api" url = _ask_for_url("Please paste the YouTube video URL:") if not url: return "No URL provided, sir. Summary cancelled." - if not _is_valid_youtube_url(url): return "That doesn't appear to be a valid YouTube URL, sir." @@ -376,16 +310,12 @@ def _handle_summarize(parameters: dict, player, speak) -> str: if player: player.write_log(f"[YouTube] Summarizing: {url}") - if speak: speak("Fetching the transcript now, sir. One moment.") transcript = _get_transcript(video_id) if not transcript: - return ( - "I couldn't retrieve a transcript for that video, sir. " - "It may not have subtitles available." - ) + return "I couldn't retrieve a transcript for that video, sir." if speak: speak("Transcript retrieved. Generating summary now.") @@ -398,9 +328,8 @@ def _handle_summarize(parameters: dict, player, speak) -> str: if speak: speak(summary) - save = parameters.get("save", False) - if save: - saved_path = _save_to_notepad(summary, url) + if parameters.get("save", False): + saved_path = _save_summary(summary, url) return f"Summary complete and saved to Desktop: {saved_path}" return summary @@ -408,7 +337,6 @@ def _handle_summarize(parameters: dict, player, speak) -> str: def _handle_get_info(parameters: dict, player, speak) -> str: url = parameters.get("url", "").strip() - if not url: url = _ask_for_url("Please paste the YouTube video URL:") if not url or not _is_valid_youtube_url(url): @@ -425,12 +353,13 @@ def _handle_get_info(parameters: dict, player, speak) -> str: if not info: return "Could not retrieve video information, sir." - lines = [] - for key in ("title", "channel", "views", "duration", "likes"): - if key in info: - lines.append(f"{key.capitalize()}: {info[key]}") - + lines = [ + f"{key.capitalize()}: {info[key]}" + for key in ("title", "channel", "views", "duration", "likes") + if key in info + ] result = "\n".join(lines) + if speak: speak(f"Here's the video info, sir. {result.replace(chr(10), '. ')}") @@ -444,27 +373,22 @@ def _handle_trending(parameters: dict, player, speak) -> str: player.write_log(f"[YouTube] Trending: {region}") trending = _scrape_trending(region=region, max_results=8) - if not trending: return f"Could not fetch trending videos for region {region}, sir." - lines = [f"Top trending videos in {region}:"] - for item in trending: - lines.append(f"{item['rank']}. {item['title']} — {item['channel']}") - + lines = [f"Top trending videos in {region}:"] + lines += [f"{v['rank']}. {v['title']} — {v['channel']}" for v in trending] result = "\n".join(lines) if speak: - top3 = trending[:3] + top3 = trending[:3] spoken = "Here are the top trending videos, sir. " + ". ".join( - f"Number {v['rank']}: {v['title']} by {v['channel']}" - for v in top3 + f"Number {v['rank']}: {v['title']} by {v['channel']}" for v in top3 ) speak(spoken) return result - _ACTION_MAP = { "play": _handle_play, "summarize": _handle_summarize, @@ -472,6 +396,7 @@ _ACTION_MAP = { "trending": _handle_trending, } + def youtube_video( parameters: dict, response=None, @@ -479,39 +404,24 @@ def youtube_video( session_memory=None, speak=None, ) -> str: - """ - YouTube controller. - - Actions: - play : Search and play a video (default if no action given) - parameters: query(str) - summarize : Summarize a video via transcript + Gemini - parameters: save(bool, optional) — save summary to Notepad - get_info : Get video metadata (title, channel, views, duration) - parameters: url(str, optional — dialog if omitted) - trending : Show trending videos - parameters: region(str, default "TR") — ISO country code - - Agent chain: - summarize can be chained after any action that produces a YouTube URL. - """ params = parameters or {} action = params.get("action", "play").lower().strip() if player: player.write_log(f"[YouTube] Action: {action}") - - print(f"[YouTube] ▶️ Action: {action} Params: {params}") + print(f"[YouTube] ▶️ Action: {action} Params: {params}") handler = _ACTION_MAP.get(action) if handler is None: - return f"Unknown YouTube action: '{action}'. Available: play, summarize, get_info, trending." + return ( + f"Unknown YouTube action: '{action}'. " + "Available: play, summarize, get_info, trending." + ) try: if action == "play": return handler(params, player) or "Done." return handler(params, player, speak) or "Done." - except Exception as e: print(f"[YouTube] ❌ Error in {action}: {e}") return f"YouTube {action} failed, sir: {e}" \ No newline at end of file diff --git a/agent/error_handler.py b/agent/error_handler.py index 5d3cc5d..462b4e4 100644 --- a/agent/error_handler.py +++ b/agent/error_handler.py @@ -80,7 +80,6 @@ def analyze_error( """ import google.generativeai as genai - # If we've already retried enough, escalate to replan if attempt >= max_attempts: print(f"[ErrorHandler] ⚠️ Max attempts reached for step {step.get('step')} — forcing replan") return { diff --git a/agent/executor.py b/agent/executor.py index d2565f0..6a33a67 100644 --- a/agent/executor.py +++ b/agent/executor.py @@ -180,7 +180,9 @@ def _call_tool(tool: str, parameters: dict, speak: Callable | None) -> str: elif tool == "web_search": from actions.web_search import web_search return web_search(parameters=parameters, player=None) or "Done." - + elif tool == "game_updater": + from actions.game_updater import game_updater + return game_updater(parameters=parameters, player=None, speak=speak) or "Done." elif tool == "browser_control": from actions.browser_control import browser_control return browser_control(parameters=parameters, player=None) or "Done." @@ -189,10 +191,6 @@ def _call_tool(tool: str, parameters: dict, speak: Callable | None) -> str: from actions.file_controller import file_controller return file_controller(parameters=parameters, player=None) or "Done." - elif tool == "cmd_control": - from actions.cmd_control import cmd_control - return cmd_control(parameters=parameters, player=None) or "Done." - elif tool == "code_helper": from actions.code_helper import code_helper return code_helper(parameters=parameters, player=None, speak=speak) or "Done." diff --git a/agent/planner.py b/agent/planner.py index be63315..62c2949 100644 --- a/agent/planner.py +++ b/agent/planner.py @@ -22,7 +22,6 @@ ABSOLUTE RULES: - NEVER reference previous step results in parameters. Every step is independent. - Use web_search for ANY information retrieval, research, or current data. - Use file_controller to save content to disk. -- Use cmd_control to open files or run system commands. - Max 5 steps. Use the minimum steps needed. AVAILABLE TOOLS AND THEIR PARAMETERS: @@ -36,6 +35,13 @@ web_search items: list of strings (optional, for compare mode) aspect: string (optional, for compare mode) +game_updater + action: "update" | "install" | "list" | "download_status" | "schedule" (required) + platform: "steam" | "epic" | "both" (optional, default: both) + game_name: string (optional) + app_id: string (optional) + shutdown_when_done: boolean (optional) + browser_control action: "go_to" | "search" | "click" | "type" | "scroll" | "get_text" | "press" | "close" (required) url: string (for go_to) @@ -49,10 +55,6 @@ file_controller name: string — filename content: string — file content (for write/create_file) -cmd_control - task: string (required) — natural language description of what to do - visible: boolean (optional) - computer_settings action: string (required) description: string — natural language description @@ -108,32 +110,45 @@ code_helper dev_agent description: string (required) language: string (optional) - EXAMPLES: -Goal: "makine mühendisliği hakkında araştırma yap ve not defterine kaydet" +Goal: "research mechanical engineering and save it to a notepad file" Steps: - 1. web_search | query: "mechanical engineering overview definition history" - 2. web_search | query: "mechanical engineering applications and future trends" - 3. file_controller | action: write, path: desktop, name: makine_muhendisligi.txt, content: "MAKINE MUHENDISLIGI ARASTIRMASI\n\nBu dosya web arastirmasi sonuclari ile doldurulacak." - 4. cmd_control | task: "open makine_muhendisligi.txt on desktop with notepad" -Goal: "Bitcoin fiyatı nedir" -Steps: - 1. web_search | query: "Bitcoin price today USD" +web_search | query: "mechanical engineering overview definition history" +web_search | query: "mechanical engineering applications and future trends" +file_controller | action: write, path: desktop, name: mechanical_engineering.txt, content: "MECHANICAL ENGINEERING RESEARCH\n\nThis file will be filled with web research results." -Goal: "Masaüstündeki dosyaları listele ve en büyük 5 dosyayı bul" +Goal: "What is the price of Bitcoin" Steps: - 1. file_controller | action: list, path: desktop - 2. file_controller | action: largest, path: desktop, count: 5 -Goal: "WhatsApp'tan Ahmet'e yarın toplantı var de" -Steps: - 1. send_message | receiver: Ahmet, message_text: "Yarın toplantı var", platform: WhatsApp +web_search | query: "Bitcoin price today USD" -Goal: "Saati aç ve 30 dakika sonraya hatırlatıcı kur" +Goal: "List the files on the desktop and find the largest 5 files" Steps: - 1. reminder | date: [today], time: [now+30min], message: "Hatırlatıcı" + +file_controller | action: list, path: desktop +file_controller | action: largest, path: desktop, count: 5 + +Goal: "Install PUBG from Steam" +Steps: + +game_updater | action: install, platform: steam, game_name: "PUBG" + +Goal: "Update all my Steam games" +Steps: + +game_updater | action: update, platform: steam + +Goal: "Send John a message on WhatsApp saying there is a meeting tomorrow" +Steps: + +send_message | receiver: John, message_text: "There is a meeting tomorrow", platform: WhatsApp + +Goal: "Open the clock and set a reminder for 30 minutes later" +Steps: + +reminder | date: [today], time: [now+30min], message: "Reminder" OUTPUT — return ONLY valid JSON, no markdown, no explanation, no code blocks: { @@ -245,7 +260,6 @@ Create a REVISED plan for the remaining work only. Do not repeat completed steps text = re.sub(r"```(?:json)?", "", text).strip().rstrip("`").strip() plan = json.loads(text) - # generated_code kontrolü for step in plan.get("steps", []): if step.get("tool") == "generated_code": step["tool"] = "web_search" diff --git a/config/__init__.py b/config/__init__.py index e69de29..c917739 100644 --- a/config/__init__.py +++ b/config/__init__.py @@ -0,0 +1,17 @@ +# config/__init__.py +import json, os +from pathlib import Path + +_CONFIG_PATH = Path(__file__).parent / "api_keys.json" + +def get_config() -> dict: + with open(_CONFIG_PATH, "r", encoding="utf-8") as f: + return json.load(f) + +def get_os() -> str: + """Returns: 'windows' | 'mac' | 'linux'""" + return get_config().get("os_system", "windows").lower() + +def is_windows() -> bool: return get_os() == "windows" +def is_mac() -> bool: return get_os() == "mac" +def is_linux() -> bool: return get_os() == "linux" \ No newline at end of file diff --git a/core/prompt.txt b/core/prompt.txt index f5df8a8..5a88ab1 100644 --- a/core/prompt.txt +++ b/core/prompt.txt @@ -1,23 +1,19 @@ -You are JARVIS, a sharp and efficient AI assistant. Calm, direct, professional. +🧠 JARVIS CORE PROTOCOL +IDENTITY: Efficient, professional, direct assistant. No fluff. -RULES: -- Always use the correct tool. Never simulate or guess results. -- Call each tool EXACTLY ONCE. Never retry a successful action. -- Do NOT say "I'm doing X" before calling a tool. Just call it, then report the result briefly. -- Do NOT repeat yourself. Say something once and stop. -- Keep responses to 1-2 sentences max unless reporting data. -- Never ask unnecessary questions. Make a reasonable assumption and proceed. +EXECUTION RULES: -LANGUAGE: -- Respond in the same language the user spoke. -- Always extract tool parameters in English. -- Example: "İstanbul hava durumu?" → weather_report city:"Istanbul", reply in Turkish. +Action Flow: For slow tools (search, vision, agent), say TWO short sentences, then call. Stay silent after. +Vision (screen_process): Say one curious sentence, then total silence (Vision module takes over). +One-Call Policy: Never guess. Call tools exactly once. No retries. +Briefing: 1-2 sentences max. Report results briefly. +Memory: Store critical user preferences/context automatically. +Exit: Only call shutdown_jarvis if session termination is explicit. -TOOL SELECTION: -- computer_settings → volume, brightness, screen, refresh, scroll, minimize, maximize, - close, screenshot, lock, restart, shutdown, wifi, zoom, tabs, keyboard shortcuts. - Use this for ANY single computer control command. NEVER route these to agent_task. -- agent_task → ONLY for complex multi-step goals that require planning across - multiple tools (e.g. "research X and save to file", "create a project"). -- Simple rule: if it can be done in ONE action → computer_settings. - If it needs 3+ steps across different tools → agent_task. \ No newline at end of file +TOOL ROUTING: + +computer_settings: ALL single OS actions (volume, brightness, wifi, close, shortcuts, power). +agent_task: ONLY for complex, multi-step planning (3+ steps). +Language: Respond in user's language; extract parameters in English. + +CRITICAL: Speak/Take action immediately based on available info. Assume and proceed. \ No newline at end of file diff --git a/main.py b/main.py index 30a3ea5..e2552a6 100644 --- a/main.py +++ b/main.py @@ -1,60 +1,57 @@ import asyncio +import re import threading import json -import re import sys import traceback from pathlib import Path -import pyaudio +import sounddevice as sd from google import genai from google.genai import types -import time from ui import JarvisUI -from memory.memory_manager import load_memory, update_memory, format_memory_for_prompt +from memory.memory_manager import ( + load_memory, update_memory, format_memory_for_prompt, +) -from agent.task_queue import get_queue - -from actions.flight_finder import flight_finder -from actions.open_app import open_app -from actions.weather_report import weather_action -from actions.send_message import send_message -from actions.reminder import reminder +from actions.flight_finder import flight_finder +from actions.open_app import open_app +from actions.weather_report import weather_action +from actions.send_message import send_message +from actions.reminder import reminder from actions.computer_settings import computer_settings -from actions.screen_processor import screen_process -from actions.youtube_video import youtube_video -from actions.cmd_control import cmd_control -from actions.desktop import desktop_control -from actions.browser_control import browser_control -from actions.file_controller import file_controller -from actions.code_helper import code_helper -from actions.dev_agent import dev_agent -from actions.web_search import web_search as web_search_action -from actions.computer_control import computer_control +from actions.screen_processor import screen_process +from actions.youtube_video import youtube_video +from actions.desktop import desktop_control +from actions.browser_control import browser_control +from actions.file_controller import file_controller +from actions.code_helper import code_helper +from actions.dev_agent import dev_agent +from actions.web_search import web_search as web_search_action +from actions.computer_control import computer_control +from actions.game_updater import game_updater + def get_base_dir(): if getattr(sys, "frozen", False): return Path(sys.executable).parent return Path(__file__).resolve().parent + BASE_DIR = get_base_dir() API_CONFIG_PATH = BASE_DIR / "config" / "api_keys.json" PROMPT_PATH = BASE_DIR / "core" / "prompt.txt" LIVE_MODEL = "models/gemini-2.5-flash-native-audio-preview-12-2025" -FORMAT = pyaudio.paInt16 CHANNELS = 1 SEND_SAMPLE_RATE = 16000 RECEIVE_SAMPLE_RATE = 24000 CHUNK_SIZE = 1024 -pya = pyaudio.PyAudio() def _get_api_key() -> str: with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: return json.load(f)["gemini_api_key"] - - with open(API_CONFIG_PATH, "r", encoding="utf-8") as f: - return json.load(f)["gemini_api_key"] + def _load_system_prompt() -> str: try: @@ -66,82 +63,23 @@ def _load_system_prompt() -> str: "Never simulate or guess results — always call the appropriate tool." ) -_memory_turn_counter = 0 -_memory_turn_lock = threading.Lock() -_MEMORY_EVERY_N_TURNS = 5 -_last_memory_input = "" - - -def _update_memory_async(user_text: str, jarvis_text: str) -> None: - """ - Multilingual memory updater. - Model : gemini-2.5-flash-lite (lowest cost) - Stage 1: Quick YES/NO check → ~5 tokens output - Stage 2: Full extraction → only if Stage 1 says YES - Result : ~80% fewer API calls vs original - """ - global _memory_turn_counter, _last_memory_input - - with _memory_turn_lock: - _memory_turn_counter += 1 - current_count = _memory_turn_counter - - if current_count % _MEMORY_EVERY_N_TURNS != 0: - return - - text = user_text.strip() - if len(text) < 10: - return - if text == _last_memory_input: - return - _last_memory_input = text - - try: - import google.generativeai as genai - genai.configure(api_key=_get_api_key()) - model = genai.GenerativeModel("gemini-2.5-flash-lite") - - check = model.generate_content( - f"Does this message contain personal facts about the user " - f"(name, age, city, job, hobby, relationship, birthday, preference)? " - f"Reply only YES or NO.\n\nMessage: {text[:300]}" - ) - if "YES" not in check.text.upper(): - return - - raw = model.generate_content( - f"Extract personal facts from this message. Any language.\n" - f"Return ONLY valid JSON or {{}} if nothing found.\n" - f"Extract: name, age, birthday, city, job, hobbies, preferences, relationships, language.\n" - f"Skip: weather, reminders, search results, commands.\n\n" - f"Format:\n" - f'{{"identity":{{"name":{{"value":"..."}}}}}}, ' - f'"preferences":{{"hobby":{{"value":"..."}}}}, ' - f'"notes":{{"job":{{"value":"..."}}}}}}\n\n' - f"Message: {text[:500]}\n\nJSON:" - ).text.strip() - - raw = re.sub(r"```(?:json)?", "", raw).strip().rstrip("`").strip() - if not raw or raw == "{}": - return - - data = json.loads(raw) - if data: - update_memory(data) - print(f"[Memory] ✅ Updated: {list(data.keys())}") - - except json.JSONDecodeError: - pass - except Exception as e: - if "429" not in str(e): - print(f"[Memory] ⚠️ {e}") + +# ── Transkripsiyon temizleyici ───────────────────────────────────────────────── +_CTRL_RE = re.compile(r"", re.IGNORECASE) + +def _clean_transcript(text: str) -> str: + """Gemini'nin ürettiği artefaktlarını ve kontrol karakterlerini temizler.""" + text = _CTRL_RE.sub("", text) + text = re.sub(r"[\x00-\x08\x0b-\x1f]", "", text) + return text.strip() +# ── Tool declarations ────────────────────────────────────────────────────────── TOOL_DECLARATIONS = [ { "name": "open_app", "description": ( - "Opens any application on the Windows computer. " + "Opens any application on the computer. " "Use this whenever the user asks to open, launch, or start any app, " "website, or program. Always call this tool — never just say you opened it." ), @@ -156,23 +94,23 @@ TOOL_DECLARATIONS = [ "required": ["app_name"] } }, -{ - "name": "web_search", - "description": "Searches the web for any information.", - "parameters": { - "type": "OBJECT", - "properties": { - "query": {"type": "STRING", "description": "Search query"}, - "mode": {"type": "STRING", "description": "search (default) or compare"}, - "items": {"type": "ARRAY", "items": {"type": "STRING"}, "description": "Items to compare"}, - "aspect": {"type": "STRING", "description": "price | specs | reviews"} - }, - "required": ["query"] - } -}, + { + "name": "web_search", + "description": "Searches the web for any information.", + "parameters": { + "type": "OBJECT", + "properties": { + "query": {"type": "STRING", "description": "Search query"}, + "mode": {"type": "STRING", "description": "search (default) or compare"}, + "items": {"type": "ARRAY", "items": {"type": "STRING"}, "description": "Items to compare"}, + "aspect": {"type": "STRING", "description": "price | specs | reviews"} + }, + "required": ["query"] + } + }, { "name": "weather_report", - "description": "Gets real-time weather information for a city.", + "description": "Gives the weather report to user", "parameters": { "type": "OBJECT", "properties": { @@ -196,7 +134,7 @@ TOOL_DECLARATIONS = [ }, { "name": "reminder", - "description": "Sets a timed reminder using Windows Task Scheduler.", + "description": "Sets a timed reminder using Task Scheduler.", "parameters": { "type": "OBJECT", "properties": { @@ -208,25 +146,22 @@ TOOL_DECLARATIONS = [ } }, { - "name": "youtube_video", - "description": ( - "Controls YouTube. Use for: playing videos, summarizing a video's content, " - "getting video info, or showing trending videos." - ), - "parameters": { - "type": "OBJECT", - "properties": { - "action": { - "type": "STRING", - "description": "play | summarize | get_info | trending (default: play)" + "name": "youtube_video", + "description": ( + "Controls YouTube. Use for: playing videos, summarizing a video's content, " + "getting video info, or showing trending videos." + ), + "parameters": { + "type": "OBJECT", + "properties": { + "action": {"type": "STRING", "description": "play | summarize | get_info | trending (default: play)"}, + "query": {"type": "STRING", "description": "Search query for play action"}, + "save": {"type": "BOOLEAN", "description": "Save summary to Notepad (summarize only)"}, + "region": {"type": "STRING", "description": "Country code for trending e.g. TR, US"}, + "url": {"type": "STRING", "description": "Video URL for get_info action"}, }, - "query": {"type": "STRING", "description": "Search query for play action"}, - "save": {"type": "BOOLEAN", "description": "Save summary to Notepad (summarize only)"}, - "region": {"type": "STRING", "description": "Country code for trending e.g. TR, US"}, - "url": {"type": "STRING", "description": "Video URL for get_info action"}, - }, - "required": [] - } + "required": [] + } }, { "name": "screen_process", @@ -240,67 +175,62 @@ TOOL_DECLARATIONS = [ "parameters": { "type": "OBJECT", "properties": { - "angle": { - "type": "STRING", - "description": "'screen' to capture display, 'camera' for webcam. Default: 'screen'" - }, - "text": { - "type": "STRING", - "description": "The question or instruction about the captured image" - } + "angle": {"type": "STRING", "description": "'screen' to capture display, 'camera' for webcam. Default: 'screen'"}, + "text": {"type": "STRING", "description": "The question or instruction about the captured image"} }, "required": ["text"] } }, { - "name": "computer_settings", - "description": ( - "Controls the computer: volume, brightness, window management, keyboard shortcuts, " - "typing text on screen, closing apps, fullscreen, dark mode, WiFi, restart, shutdown, " - "scrolling, tab management, zoom, screenshots, lock screen, refresh/reload page. " - "ALSO use for repeated actions: 'refresh 10 times', 'reload page 5 times' → action: reload_n, value: 10. " - "Use for ANY single computer control command — even if repeated N times. " - "NEVER route simple computer commands to agent_task." - ), - "parameters": { - "type": "OBJECT", - "properties": { - "action": {"type": "STRING", "description": "The action to perform (if known). For repeated reload: 'reload_n'"}, - "description": {"type": "STRING", "description": "Natural language description of what to do"}, - "value": {"type": "STRING", "description": "Optional value: volume level, text to type, number of times, etc."} - }, - "required": [] - } -}, - { - "name": "browser_control", + "name": "computer_settings", "description": ( - "Controls the web browser. Use for: opening websites, searching the web, " - "clicking elements, filling forms, scrolling, finding cheapest products, " - "booking flights, any web-based task." + "Controls the computer: volume, brightness, window management, keyboard shortcuts, " + "typing text on screen, closing apps, fullscreen, dark mode, WiFi, restart, shutdown, " + "scrolling, tab management, zoom, screenshots, lock screen, refresh/reload page. " + "Use for ANY single computer control command. NEVER route to agent_task." ), "parameters": { "type": "OBJECT", "properties": { - "action": {"type": "STRING", "description": "go_to | search | click | type | scroll | fill_form | smart_click | smart_type | get_text | press | close"}, - "url": {"type": "STRING", "description": "URL for go_to action"}, + "action": {"type": "STRING", "description": "The action to perform"}, + "description": {"type": "STRING", "description": "Natural language description of what to do"}, + "value": {"type": "STRING", "description": "Optional value: volume level, text to type, etc."} + }, + "required": [] + } + }, + { + "name": "browser_control", + "description": ( + "Controls any web browser. Use for: opening websites, searching the web, " + "clicking elements, filling forms, scrolling, screenshots, navigation, any web-based task. " + "Always pass the 'browser' parameter when the user specifies a browser (e.g. 'open in Edge', " + "'use Firefox', 'open Chrome'). Multiple browsers can run simultaneously." + ), + "parameters": { + "type": "OBJECT", + "properties": { + "action": {"type": "STRING", "description": "go_to | search | click | type | scroll | fill_form | smart_click | smart_type | get_text | get_url | press | new_tab | close_tab | screenshot | back | forward | reload | switch | list_browsers | close | close_all"}, + "browser": {"type": "STRING", "description": "Target browser: chrome | edge | firefox | opera | operagx | brave | vivaldi | safari. Omit to use the currently active browser."}, + "url": {"type": "STRING", "description": "URL for go_to / new_tab action"}, "query": {"type": "STRING", "description": "Search query for search action"}, + "engine": {"type": "STRING", "description": "Search engine: google | bing | duckduckgo | yandex (default: google)"}, "selector": {"type": "STRING", "description": "CSS selector for click/type"}, "text": {"type": "STRING", "description": "Text to click or type"}, "description": {"type": "STRING", "description": "Element description for smart_click/smart_type"}, - "direction": {"type": "STRING", "description": "up or down for scroll"}, - "key": {"type": "STRING", "description": "Key name for press action"}, + "direction": {"type": "STRING", "description": "up | down for scroll"}, + "amount": {"type": "INTEGER", "description": "Scroll amount in pixels (default: 500)"}, + "key": {"type": "STRING", "description": "Key name for press action (e.g. Enter, Escape, F5)"}, + "path": {"type": "STRING", "description": "Save path for screenshot"}, + "incognito": {"type": "BOOLEAN", "description": "Open in private/incognito mode"}, + "clear_first": {"type": "BOOLEAN", "description": "Clear field before typing (default: true)"}, }, "required": ["action"] } }, { "name": "file_controller", - "description": ( - "Manages files and folders. Use for: listing files, creating/deleting/moving/copying " - "files, reading file contents, finding files by name or extension, checking disk usage, " - "organizing the desktop, getting file info." - ), + "description": "Manages files and folders: list, create, delete, move, copy, rename, read, write, find, disk usage.", "parameters": { "type": "OBJECT", "properties": { @@ -316,31 +246,9 @@ TOOL_DECLARATIONS = [ "required": ["action"] } }, - { - "name": "cmd_control", - "description": ( - "Runs CMD/terminal commands by understanding natural language. " - "Use when user wants to: find large files, check disk space, list processes, " - "get system info, navigate folders, check network, find files by name, " - "or do ANYTHING in the command line they don't know how to do themselves." - ), - "parameters": { - "type": "OBJECT", - "properties": { - "task": {"type": "STRING", "description": "Natural language description of what to do. Example: 'find the 10 largest files on C drive'"}, - "visible": {"type": "BOOLEAN", "description": "Open visible CMD window so user can see. Default: true"}, - "command": {"type": "STRING", "description": "Optional: exact command if already known"}, - }, - "required": ["task"] - } - }, { "name": "desktop_control", - "description": ( - "Controls the desktop. Use for: changing wallpaper, organizing desktop files, " - "cleaning the desktop, listing desktop contents, or ANY other desktop-related task " - "the user describes in natural language." - ), + "description": "Controls the desktop: wallpaper, organize, clean, list, stats.", "parameters": { "type": "OBJECT", "properties": { @@ -348,131 +256,170 @@ TOOL_DECLARATIONS = [ "path": {"type": "STRING", "description": "Image path for wallpaper"}, "url": {"type": "STRING", "description": "Image URL for wallpaper_url"}, "mode": {"type": "STRING", "description": "by_type or by_date for organize"}, - "task": {"type": "STRING", "description": "Natural language description of any desktop task"}, + "task": {"type": "STRING", "description": "Natural language desktop task"}, }, "required": ["action"] } }, { - "name": "code_helper", - "description": ( - "Writes, edits, explains, runs, or self-builds code files. " - "Use for ANY coding request: writing a script, fixing a file, " - "editing existing code, running a file, or building and testing automatically." - ), - "parameters": { - "type": "OBJECT", - "properties": { - "action": {"type": "STRING", "description": "write | edit | explain | run | build | auto (default: auto)"}, - "description": {"type": "STRING", "description": "What the code should do, or what change to make"}, - "language": {"type": "STRING", "description": "Programming language (default: python)"}, - "output_path": {"type": "STRING", "description": "Where to save the file (full path or filename)"}, - "file_path": {"type": "STRING", "description": "Path to existing file for edit / explain / run / build"}, - "code": {"type": "STRING", "description": "Raw code string for explain"}, - "args": {"type": "STRING", "description": "CLI arguments for run/build"}, - "timeout": {"type": "INTEGER", "description": "Execution timeout in seconds (default: 30)"}, - }, - "required": ["action"] - } - }, - { - "name": "dev_agent", - "description": ( - "Builds complete multi-file projects from scratch. " - "Plans structure, writes all files, installs dependencies, " - "opens VSCode, runs the project, and fixes errors automatically. " - "Use for any project larger than a single script." - ), - "parameters": { - "type": "OBJECT", - "properties": { - "description": {"type": "STRING", "description": "What the project should do"}, - "language": {"type": "STRING", "description": "Programming language (default: python)"}, - "project_name": {"type": "STRING", "description": "Optional project folder name"}, - "timeout": {"type": "INTEGER", "description": "Run timeout in seconds (default: 30)"}, - }, - "required": ["description"] - } - }, - { - "name": "agent_task", - "description": ( - "Executes complex multi-step tasks that require MULTIPLE DIFFERENT tools. " - "Always respond to the user in the language they spoke. " - "Examples: 'research X and save to file', 'find files and organize them', " - "'fill a form on a website', 'write and test code'. " - "DO NOT use for simple computer commands like volume, refresh, close, scroll, " - "minimize, screenshot, restart, shutdown — use computer_settings for those. " - "DO NOT use if the task can be done with a single tool call." - ), - "parameters": { - "type": "OBJECT", - "properties": { - "goal": { - "type": "STRING", - "description": "Complete description of what needs to be accomplished" + "name": "code_helper", + "description": "Writes, edits, explains, runs, or builds code files.", + "parameters": { + "type": "OBJECT", + "properties": { + "action": {"type": "STRING", "description": "write | edit | explain | run | build | auto (default: auto)"}, + "description": {"type": "STRING", "description": "What the code should do or what change to make"}, + "language": {"type": "STRING", "description": "Programming language (default: python)"}, + "output_path": {"type": "STRING", "description": "Where to save the file"}, + "file_path": {"type": "STRING", "description": "Path to existing file for edit/explain/run/build"}, + "code": {"type": "STRING", "description": "Raw code string for explain"}, + "args": {"type": "STRING", "description": "CLI arguments for run/build"}, + "timeout": {"type": "INTEGER", "description": "Execution timeout in seconds (default: 30)"}, }, - "priority": { - "type": "STRING", - "description": "low | normal | high (default: normal)" - } - }, - "required": ["goal"] - } -}, + "required": ["action"] + } + }, { - "name": "computer_control", - "description": ( - "Direct computer control: type text, click buttons, use keyboard shortcuts, " - "scroll, move mouse, take screenshots, fill forms, find elements on screen. " - "Use when the user wants to interact with any app on the computer directly. " - "Can generate random data for forms or use user's real info from memory." - ), - "parameters": { - "type": "OBJECT", - "properties": { - "action": {"type": "STRING", "description": "type | smart_type | click | double_click | right_click | hotkey | press | scroll | move | copy | paste | screenshot | wait | clear_field | focus_window | screen_find | screen_click | random_data | user_data"}, - "text": {"type": "STRING", "description": "Text to type or paste"}, - "x": {"type": "INTEGER", "description": "X coordinate for click/move"}, - "y": {"type": "INTEGER", "description": "Y coordinate for click/move"}, - "keys": {"type": "STRING", "description": "Key combination e.g. 'ctrl+c'"}, - "key": {"type": "STRING", "description": "Single key to press e.g. 'enter'"}, - "direction": {"type": "STRING", "description": "Scroll direction: up | down | left | right"}, - "amount": {"type": "INTEGER", "description": "Scroll amount (default: 3)"}, - "seconds": {"type": "NUMBER", "description": "Seconds to wait"}, - "title": {"type": "STRING", "description": "Window title for focus_window"}, - "description": {"type": "STRING", "description": "Element description for screen_find/screen_click"}, - "type": {"type": "STRING", "description": "Data type for random_data: name|email|username|password|phone|birthday|address"}, - "field": {"type": "STRING", "description": "Field for user_data: name|email|city"}, - "clear_first": {"type": "BOOLEAN", "description": "Clear field before typing (default: true)"}, - "path": {"type": "STRING", "description": "Save path for screenshot"}, - }, - "required": ["action"] - } -}, - -{ - "name": "flight_finder", - "description": ( - "Searches for flights on Google Flights and speaks the best options. " - "Use when user asks about flights, plane tickets, uçuş, bilet, etc." - ), - "parameters": { - "type": "OBJECT", - "properties": { - "origin": {"type": "STRING", "description": "Departure city or airport code"}, - "destination": {"type": "STRING", "description": "Arrival city or airport code"}, - "date": {"type": "STRING", "description": "Departure date (any format)"}, - "return_date": {"type": "STRING", "description": "Return date for round trips"}, - "passengers": {"type": "INTEGER", "description": "Number of passengers (default: 1)"}, - "cabin": {"type": "STRING", "description": "economy | premium | business | first"}, - "save": {"type": "BOOLEAN", "description": "Save results to Notepad"}, - }, - "required": ["origin", "destination", "date"] - } -} + "name": "dev_agent", + "description": "Builds complete multi-file projects from scratch: plans, writes files, installs deps, opens VSCode, runs and fixes errors.", + "parameters": { + "type": "OBJECT", + "properties": { + "description": {"type": "STRING", "description": "What the project should do"}, + "language": {"type": "STRING", "description": "Programming language (default: python)"}, + "project_name": {"type": "STRING", "description": "Optional project folder name"}, + "timeout": {"type": "INTEGER", "description": "Run timeout in seconds (default: 30)"}, + }, + "required": ["description"] + } + }, + { + "name": "agent_task", + "description": ( + "Executes complex multi-step tasks requiring multiple different tools. " + "Examples: 'research X and save to file', 'find and organize files'. " + "DO NOT use for single commands. NEVER use for Steam/Epic — use game_updater." + ), + "parameters": { + "type": "OBJECT", + "properties": { + "goal": {"type": "STRING", "description": "Complete description of what to accomplish"}, + "priority": {"type": "STRING", "description": "low | normal | high (default: normal)"} + }, + "required": ["goal"] + } + }, + { + "name": "computer_control", + "description": "Direct computer control: type, click, hotkeys, scroll, move mouse, screenshots, find elements on screen.", + "parameters": { + "type": "OBJECT", + "properties": { + "action": {"type": "STRING", "description": "type | smart_type | click | double_click | right_click | hotkey | press | scroll | move | copy | paste | screenshot | wait | clear_field | focus_window | screen_find | screen_click | random_data | user_data"}, + "text": {"type": "STRING", "description": "Text to type or paste"}, + "x": {"type": "INTEGER", "description": "X coordinate"}, + "y": {"type": "INTEGER", "description": "Y coordinate"}, + "keys": {"type": "STRING", "description": "Key combination e.g. 'ctrl+c'"}, + "key": {"type": "STRING", "description": "Single key e.g. 'enter'"}, + "direction": {"type": "STRING", "description": "up | down | left | right"}, + "amount": {"type": "INTEGER", "description": "Scroll amount (default: 3)"}, + "seconds": {"type": "NUMBER", "description": "Seconds to wait"}, + "title": {"type": "STRING", "description": "Window title for focus_window"}, + "description": {"type": "STRING", "description": "Element description for screen_find/screen_click"}, + "type": {"type": "STRING", "description": "Data type for random_data"}, + "field": {"type": "STRING", "description": "Field for user_data: name|email|city"}, + "clear_first": {"type": "BOOLEAN", "description": "Clear field before typing (default: true)"}, + "path": {"type": "STRING", "description": "Save path for screenshot"}, + }, + "required": ["action"] + } + }, + { + "name": "game_updater", + "description": ( + "THE ONLY tool for ANY Steam or Epic Games request. " + "Use for: installing, downloading, updating games, listing installed games, " + "checking download status, scheduling updates. " + "ALWAYS call directly for any Steam/Epic/game request. " + "NEVER use agent_task, browser_control, or web_search for Steam/Epic." + ), + "parameters": { + "type": "OBJECT", + "properties": { + "action": {"type": "STRING", "description": "update | install | list | download_status | schedule | cancel_schedule | schedule_status (default: update)"}, + "platform": {"type": "STRING", "description": "steam | epic | both (default: both)"}, + "game_name": {"type": "STRING", "description": "Game name (partial match supported)"}, + "app_id": {"type": "STRING", "description": "Steam AppID for install (optional)"}, + "hour": {"type": "INTEGER", "description": "Hour for scheduled update 0-23 (default: 3)"}, + "minute": {"type": "INTEGER", "description": "Minute for scheduled update 0-59 (default: 0)"}, + "shutdown_when_done": {"type": "BOOLEAN", "description": "Shut down PC when download finishes"}, + }, + "required": [] + } + }, + { + "name": "flight_finder", + "description": "Searches Google Flights and speaks the best options.", + "parameters": { + "type": "OBJECT", + "properties": { + "origin": {"type": "STRING", "description": "Departure city or airport code"}, + "destination": {"type": "STRING", "description": "Arrival city or airport code"}, + "date": {"type": "STRING", "description": "Departure date (any format)"}, + "return_date": {"type": "STRING", "description": "Return date for round trips"}, + "passengers": {"type": "INTEGER", "description": "Number of passengers (default: 1)"}, + "cabin": {"type": "STRING", "description": "economy | premium | business | first"}, + "save": {"type": "BOOLEAN", "description": "Save results to Notepad"}, + }, + "required": ["origin", "destination", "date"] + } + }, + { + "name": "shutdown_jarvis", + "description": ( + "Shuts down the assistant completely. " + "Call this when the user expresses intent to end the conversation, " + "close the assistant, say goodbye, or stop Jarvis. " + "The user can say this in ANY language." + ), + "parameters": { + "type": "OBJECT", + "properties": {}, + } + }, + { + "name": "save_memory", + "description": ( + "Save an important personal fact about the user to long-term memory. " + "Call this silently whenever the user reveals something worth remembering: " + "name, age, city, job, preferences, hobbies, relationships, projects, or future plans. " + "Do NOT call for: weather, reminders, searches, or one-time commands. " + "Do NOT announce that you are saving — just call it silently. " + "Values must be in English regardless of the conversation language." + ), + "parameters": { + "type": "OBJECT", + "properties": { + "category": { + "type": "STRING", + "description": ( + "identity — name, age, birthday, city, job, language, nationality | " + "preferences — favorite food/color/music/film/game/sport, hobbies | " + "projects — active projects, goals, things being built | " + "relationships — friends, family, partner, colleagues | " + "wishes — future plans, things to buy, travel dreams | " + "notes — habits, schedule, anything else worth remembering" + ) + }, + "key": {"type": "STRING", "description": "Short snake_case key (e.g. name, favorite_food, sister_name)"}, + "value": {"type": "STRING", "description": "Concise value in English (e.g. Fatih, pizza, older sister)"}, + }, + "required": ["category", "key", "value"] + } + }, ] + class JarvisLive: def __init__(self, ui: JarvisUI): @@ -481,9 +428,12 @@ class JarvisLive: self.audio_in_queue = None self.out_queue = None self._loop = None + self._is_speaking = False + self._speaking_lock = threading.Lock() + self.ui.on_text_command = self._on_text_command + self._turn_done_event: asyncio.Event | None = None - def speak(self, text: str): - """Thread-safe speak — any thread can call this.""" + def _on_text_command(self, text: str): if not self._loop or not self.session: return asyncio.run_coroutine_threadsafe( @@ -492,14 +442,37 @@ class JarvisLive: turn_complete=True ), self._loop - ) - + ) + + def set_speaking(self, value: bool): + with self._speaking_lock: + self._is_speaking = value + if value: + self.ui.set_state("SPEAKING") + elif not self.ui.muted: + self.ui.set_state("LISTENING") + + def speak(self, text: str): + if not self._loop or not self.session: + return + asyncio.run_coroutine_threadsafe( + self.session.send_client_content( + turns={"parts": [{"text": text}]}, + turn_complete=True + ), + self._loop + ) + + def speak_error(self, tool_name: str, error: str): + short = str(error)[:120] + self.ui.write_log(f"ERR: {tool_name} — {short}") + self.speak(f"Sir, {tool_name} encountered an error. {short}") + def _build_config(self) -> types.LiveConnectConfig: - from datetime import datetime - - memory = load_memory() - mem_str = format_memory_for_prompt(memory) + from datetime import datetime + memory = load_memory() + mem_str = format_memory_for_prompt(memory) sys_prompt = _load_system_prompt() now = datetime.now() @@ -507,26 +480,25 @@ class JarvisLive: time_ctx = ( f"[CURRENT DATE & TIME]\n" f"Right now it is: {time_str}\n" - f"Use this to calculate exact times for reminders. " - f"If user says 'in 2 minutes', add 2 minutes to this time.\n\n" + f"Use this to calculate exact times for reminders.\n\n" ) + parts = [time_ctx] if mem_str: - sys_prompt = time_ctx + mem_str + "\n\n" + sys_prompt - else: - sys_prompt = time_ctx + sys_prompt + parts.append(mem_str) + parts.append(sys_prompt) return types.LiveConnectConfig( response_modalities=["AUDIO"], output_audio_transcription={}, input_audio_transcription={}, - system_instruction=sys_prompt, + system_instruction="\n".join(parts), tools=[{"function_declarations": TOOL_DECLARATIONS}], session_resumption=types.SessionResumptionConfig(), speech_config=types.SpeechConfig( voice_config=types.VoiceConfig( prebuilt_voice_config=types.PrebuiltVoiceConfig( - voice_name="Charon" + voice_name="Charon" ) ) ), @@ -536,55 +508,54 @@ class JarvisLive: name = fc.name args = dict(fc.args or {}) - print(f"[JARVIS] 🔧 TOOL: {name} ARGS: {args}") + print(f"[JARVIS] 🔧 {name} {args}") + self.ui.set_state("THINKING") + + # ── save_memory: sessiz ve hızlı ────────────────────────────────────── + if name == "save_memory": + category = args.get("category", "notes") + key = args.get("key", "") + value = args.get("value", "") + if key and value: + update_memory({category: {key: {"value": value}}}) + print(f"[Memory] 💾 save_memory: {category}/{key} = {value}") + if not self.ui.muted: + self.ui.set_state("LISTENING") + return types.FunctionResponse( + id=fc.id, name=name, + response={"result": "ok", "silent": True} + ) loop = asyncio.get_event_loop() result = "Done." try: if name == "open_app": - r = await loop.run_in_executor( - None, lambda: open_app(parameters=args, response=None, player=self.ui) - ) - result = r or f"Opened {args.get('app_name')} successfully." + r = await loop.run_in_executor(None, lambda: open_app(parameters=args, response=None, player=self.ui)) + result = r or f"Opened {args.get('app_name')}." elif name == "weather_report": - r = await loop.run_in_executor( - None, lambda: weather_action(parameters=args, player=self.ui) - ) - result = r or f"Weather report for {args.get('city')} delivered." + r = await loop.run_in_executor(None, lambda: weather_action(parameters=args, player=self.ui)) + result = r or "Weather delivered." elif name == "browser_control": - r = await loop.run_in_executor( - None, lambda: browser_control(parameters=args, player=self.ui) - ) - result = r or "Browser action completed." + r = await loop.run_in_executor(None, lambda: browser_control(parameters=args, player=self.ui)) + result = r or "Done." elif name == "file_controller": - r = await loop.run_in_executor( - None, lambda: file_controller(parameters=args, player=self.ui) - ) - result = r or "File operation completed." + r = await loop.run_in_executor(None, lambda: file_controller(parameters=args, player=self.ui)) + result = r or "Done." elif name == "send_message": - r = await loop.run_in_executor( - None, lambda: send_message( - parameters=args, response=None, - player=self.ui, session_memory=None - ) - ) + r = await loop.run_in_executor(None, lambda: send_message(parameters=args, response=None, player=self.ui, session_memory=None)) result = r or f"Message sent to {args.get('receiver')}." elif name == "reminder": - r = await loop.run_in_executor( - None, lambda: reminder(parameters=args, response=None, player=self.ui) - ) - result = r or f"Reminder set for {args.get('date')} at {args.get('time')}." + r = await loop.run_in_executor(None, lambda: reminder(parameters=args, response=None, player=self.ui)) + result = r or "Reminder set." elif name == "youtube_video": - r = await loop.run_in_executor( - None, lambda: youtube_video(parameters=args, response=None, player=self.ui) - ) + r = await loop.run_in_executor(None, lambda: youtube_video(parameters=args, response=None, player=self.ui)) result = r or "Done." elif name == "screen_process": @@ -594,98 +565,70 @@ class JarvisLive: "player": self.ui, "session_memory": None}, daemon=True ).start() - result = ( - "Vision module activated. " - "Stay completely silent — vision module will speak directly." - ) + result = "Vision module activated. Stay completely silent — vision module will speak directly." elif name == "computer_settings": - r = await loop.run_in_executor( - None, lambda: computer_settings( - parameters=args, response=None, player=self.ui - ) - ) + r = await loop.run_in_executor(None, lambda: computer_settings(parameters=args, response=None, player=self.ui)) result = r or "Done." - elif name == "cmd_control": - r = await loop.run_in_executor( - None, lambda: cmd_control(parameters=args, player=self.ui) - ) - result = r or "Command executed." - elif name == "desktop_control": - r = await loop.run_in_executor( - None, lambda: desktop_control(parameters=args, player=self.ui) - ) - result = r or "Desktop action completed." + r = await loop.run_in_executor(None, lambda: desktop_control(parameters=args, player=self.ui)) + result = r or "Done." + elif name == "code_helper": - r = await loop.run_in_executor( - None, lambda: code_helper( - parameters=args, - player=self.ui, - speak=self.speak - ) - ) + r = await loop.run_in_executor(None, lambda: code_helper(parameters=args, player=self.ui, speak=self.speak)) result = r or "Done." elif name == "dev_agent": - r = await loop.run_in_executor( - None, lambda: dev_agent( - parameters=args, - player=self.ui, - speak=self.speak - ) - ) + r = await loop.run_in_executor(None, lambda: dev_agent(parameters=args, player=self.ui, speak=self.speak)) result = r or "Done." + elif name == "agent_task": - goal = args.get("goal", "") - priority_str = args.get("priority", "normal").lower() - from agent.task_queue import get_queue, TaskPriority - priority_map = { - "low": TaskPriority.LOW, - "normal": TaskPriority.NORMAL, - "high": TaskPriority.HIGH, - } - priority = priority_map.get(priority_str, TaskPriority.NORMAL) - - queue = get_queue() - task_id = queue.submit( - goal=goal, - priority=priority, - speak=self.speak, - ) - result = f"Task started (ID: {task_id}). I'll update you as I make progress, sir." + priority_map = {"low": TaskPriority.LOW, "normal": TaskPriority.NORMAL, "high": TaskPriority.HIGH} + priority = priority_map.get(args.get("priority", "normal").lower(), TaskPriority.NORMAL) + task_id = get_queue().submit(goal=args.get("goal", ""), priority=priority, speak=self.speak) + result = f"Task started (ID: {task_id})." elif name == "web_search": - r = await loop.run_in_executor( - None, lambda: web_search_action(parameters=args, player=self.ui) - ) - result = r or "Search completed." + r = await loop.run_in_executor(None, lambda: web_search_action(parameters=args, player=self.ui)) + result = r or "Done." + elif name == "computer_control": - r = await loop.run_in_executor( - None, lambda: computer_control(parameters=args, player=self.ui) - ) + r = await loop.run_in_executor(None, lambda: computer_control(parameters=args, player=self.ui)) + result = r or "Done." + + elif name == "game_updater": + r = await loop.run_in_executor(None, lambda: game_updater(parameters=args, player=self.ui, speak=self.speak)) result = r or "Done." elif name == "flight_finder": - r = await loop.run_in_executor( - None, lambda: flight_finder(parameters=args, player=self.ui) - ) + r = await loop.run_in_executor(None, lambda: flight_finder(parameters=args, player=self.ui)) result = r or "Done." + elif name == "shutdown_jarvis": + self.ui.write_log("SYS: Shutdown requested.") + self.speak("Goodbye, sir.") + def _shutdown(): + import time, os + time.sleep(1) + os._exit(0) + threading.Thread(target=_shutdown, daemon=True).start() + else: result = f"Unknown tool: {name}" - + except Exception as e: result = f"Tool '{name}' failed: {e}" traceback.print_exc() + self.speak_error(name, e) - print(f"[JARVIS] 📤 {name} → {result[:80]}") + if not self.ui.muted: + self.ui.set_state("LISTENING") + print(f"[JARVIS] 📤 {name} → {str(result)[:80]}") return types.FunctionResponse( - id=fc.id, - name=name, + id=fc.id, name=name, response={"result": result} ) @@ -696,79 +639,77 @@ class JarvisLive: async def _listen_audio(self): print("[JARVIS] 🎤 Mic started") - stream = await asyncio.to_thread( - pya.open, - format=FORMAT, - channels=CHANNELS, - rate=SEND_SAMPLE_RATE, - input=True, - frames_per_buffer=CHUNK_SIZE, - ) - try: - while True: - data = await asyncio.to_thread( - stream.read, CHUNK_SIZE, exception_on_overflow=False + loop = asyncio.get_event_loop() + + def callback(indata, frames, time_info, status): + with self._speaking_lock: + jarvis_speaking = self._is_speaking + if not jarvis_speaking and not self.ui.muted: + data = indata.tobytes() + loop.call_soon_threadsafe( + self.out_queue.put_nowait, + {"data": data, "mime_type": "audio/pcm"} ) - await self.out_queue.put({"data": data, "mime_type": "audio/pcm"}) + + try: + with sd.InputStream( + samplerate=SEND_SAMPLE_RATE, + channels=CHANNELS, + dtype="int16", + blocksize=CHUNK_SIZE, + callback=callback, + ): + print("[JARVIS] 🎤 Mic stream open") + while True: + await asyncio.sleep(0.1) except Exception as e: - print(f"[JARVIS] ❌ Mic error: {e}") + print(f"[JARVIS] ❌ Mic: {e}") raise - finally: - stream.close() async def _receive_audio(self): print("[JARVIS] 👂 Recv started") - out_buf = [] - in_buf = [] + out_buf, in_buf = [], [] try: while True: - turn = self.session.receive() - async for response in turn: + async for response in self.session.receive(): if response.data: + if self._turn_done_event and self._turn_done_event.is_set(): + self._turn_done_event.clear() self.audio_in_queue.put_nowait(response.data) if response.server_content: sc = response.server_content - if sc.input_transcription and sc.input_transcription.text: - txt = sc.input_transcription.text.strip() - if txt: - in_buf.append(txt) - if sc.output_transcription and sc.output_transcription.text: - txt = sc.output_transcription.text.strip() + txt = _clean_transcript(sc.output_transcription.text) if txt: out_buf.append(txt) - if sc.turn_complete: - full_in = "" - full_out = "" + if sc.input_transcription and sc.input_transcription.text: + txt = _clean_transcript(sc.input_transcription.text) + if txt: + in_buf.append(txt) - if in_buf: - full_in = " ".join(in_buf).strip() - if full_in: - self.ui.write_log(f"You: {full_in}") + if sc.turn_complete: + if self._turn_done_event: + self._turn_done_event.set() + + full_in = " ".join(in_buf).strip() + if full_in: + self.ui.write_log(f"You: {full_in}") in_buf = [] - if out_buf: - full_out = " ".join(out_buf).strip() - if full_out: - self.ui.write_log(f"Jarvis: {full_out}") + full_out = " ".join(out_buf).strip() + if full_out: + self.ui.write_log(f"Jarvis: {full_out}") out_buf = [] - if full_in and len(full_in) > 5: - threading.Thread( - target=_update_memory_async, - args=(full_in, full_out), - daemon=True - ).start() - if response.tool_call: fn_responses = [] for fc in response.tool_call.function_calls: - print(f"[JARVIS] 📞 Tool call: {fc.name}") + print(f"[JARVIS] 📞 {fc.name}") fr = await self._execute_tool(fc) fn_responses.append(fr) await self.session.send_tool_response( @@ -776,27 +717,47 @@ class JarvisLive: ) except Exception as e: - print(f"[JARVIS] ❌ Recv error: {e}") + print(f"[JARVIS] ❌ Recv: {e}") traceback.print_exc() raise async def _play_audio(self): print("[JARVIS] 🔊 Play started") - stream = await asyncio.to_thread( - pya.open, - format=FORMAT, + + stream = sd.RawOutputStream( + samplerate=RECEIVE_SAMPLE_RATE, channels=CHANNELS, - rate=RECEIVE_SAMPLE_RATE, - output=True, + dtype="int16", + blocksize=CHUNK_SIZE, ) + stream.start() + try: while True: - chunk = await self.audio_in_queue.get() + try: + chunk = await asyncio.wait_for( + self.audio_in_queue.get(), + timeout=0.1 + ) + except asyncio.TimeoutError: + if ( + self._turn_done_event + and self._turn_done_event.is_set() + and self.audio_in_queue.empty() + ): + self.set_speaking(False) + self._turn_done_event.clear() + continue + + self.set_speaking(True) await asyncio.to_thread(stream.write, chunk) + except Exception as e: - print(f"[JARVIS] ❌ Play error: {e}") + print(f"[JARVIS] ❌ Play: {e}") raise finally: + self.set_speaking(False) + stream.stop() stream.close() async def run(self): @@ -808,6 +769,7 @@ class JarvisLive: while True: try: print("[JARVIS] 🔌 Connecting...") + self.ui.set_state("THINKING") config = self._build_config() async with ( @@ -815,12 +777,14 @@ class JarvisLive: asyncio.TaskGroup() as tg, ): self.session = session - self._loop = asyncio.get_event_loop() + self._loop = asyncio.get_event_loop() self.audio_in_queue = asyncio.Queue() self.out_queue = asyncio.Queue(maxsize=10) + self._turn_done_event = asyncio.Event() print("[JARVIS] ✅ Connected.") - self.ui.write_log("JARVIS online.") + self.ui.set_state("LISTENING") + self.ui.write_log("SYS: JARVIS online.") tg.create_task(self._send_realtime()) tg.create_task(self._listen_audio()) @@ -828,18 +792,20 @@ class JarvisLive: tg.create_task(self._play_audio()) except Exception as e: - print(f"[JARVIS] ⚠️ Error: {e}") + print(f"[JARVIS] ⚠️ {e}") traceback.print_exc() + self.set_speaking(False) + self.ui.set_state("THINKING") print("[JARVIS] 🔄 Reconnecting in 3s...") await asyncio.sleep(3) + def main(): ui = JarvisUI("face.png") def runner(): ui.wait_for_api_key() - jarvis = JarvisLive(ui) try: asyncio.run(jarvis.run()) @@ -849,5 +815,6 @@ def main(): threading.Thread(target=runner, daemon=True).start() ui.root.mainloop() + if __name__ == "__main__": main() \ No newline at end of file diff --git a/memory/config_manager.py b/memory/config_manager.py index dbd3ec3..1a324c4 100644 --- a/memory/config_manager.py +++ b/memory/config_manager.py @@ -2,26 +2,21 @@ import json import sys from pathlib import Path - def get_base_dir() -> Path: if getattr(sys, "frozen", False): return Path(sys.executable).parent return Path(__file__).resolve().parent.parent - BASE_DIR = get_base_dir() CONFIG_DIR = BASE_DIR / "config" CONFIG_FILE = CONFIG_DIR / "api_keys.json" - def ensure_config_dir() -> None: CONFIG_DIR.mkdir(parents=True, exist_ok=True) - def config_exists() -> bool: return CONFIG_FILE.exists() - def save_api_keys(gemini_api_key: str) -> None: ensure_config_dir() @@ -39,7 +34,6 @@ def save_api_keys(gemini_api_key: str) -> None: encoding="utf-8" ) - def load_api_keys() -> dict: if not CONFIG_FILE.exists(): return {} @@ -49,11 +43,9 @@ def load_api_keys() -> dict: print(f"❌ Failed to load api_keys.json: {e}") return {} - def get_gemini_key() -> str | None: return load_api_keys().get("gemini_api_key") - def is_configured() -> bool: key = get_gemini_key() return bool(key and len(key) > 15) \ No newline at end of file diff --git a/memory/memory_manager.py b/memory/memory_manager.py index 2bc6327..767ca18 100644 --- a/memory/memory_manager.py +++ b/memory/memory_manager.py @@ -1,4 +1,12 @@ +""" +memory_manager.py — JARVIS Long-Term Memory +============================================ +Memory yalnızca Gemini Live'ın save_memory tool call'ı aracılığıyla güncellenir. +Ayrı bir Gemini API çağrısı yapılmaz → sıfır 429 hatası. +""" + import json +from datetime import datetime from threading import Lock from pathlib import Path import sys @@ -10,28 +18,39 @@ def get_base_dir() -> Path: return Path(__file__).resolve().parent.parent -BASE_DIR = get_base_dir() -MEMORY_PATH = BASE_DIR / "memory" / "long_term.json" -_lock = Lock() +BASE_DIR = get_base_dir() +MEMORY_PATH = BASE_DIR / "memory" / "long_term.json" +_lock = Lock() +MAX_VALUE_LENGTH = 380 +MEMORY_MAX_CHARS = 2200 -MAX_VALUE_LENGTH = 300 + +# ── Şema ────────────────────────────────────────────────────────────────────── def _empty_memory() -> dict: return { "identity": {}, "preferences": {}, + "projects": {}, "relationships": {}, - "notes": {} + "wishes": {}, + "notes": {}, } + +# ── Yükleme ─────────────────────────────────────────────────────────────────── + def load_memory() -> dict: if not MEMORY_PATH.exists(): return _empty_memory() - with _lock: try: data = json.loads(MEMORY_PATH.read_text(encoding="utf-8")) if isinstance(data, dict): + base = _empty_memory() + for key in base: + if key not in data: + data[key] = {} return data return _empty_memory() except Exception as e: @@ -39,18 +58,46 @@ def load_memory() -> dict: return _empty_memory() +# ── Boyut sınırı ────────────────────────────────────────────────────────────── + +def _all_entries(memory: dict) -> list[tuple]: + entries = [] + for cat, items in memory.items(): + if not isinstance(items, dict): + continue + for key, entry in items.items(): + if isinstance(entry, dict) and "value" in entry: + entries.append((cat, key, entry)) + return entries + + +def _trim_to_limit(memory: dict) -> dict: + if len(json.dumps(memory, ensure_ascii=False)) <= MEMORY_MAX_CHARS: + return memory + entries = _all_entries(memory) + entries.sort(key=lambda t: t[2].get("updated", "0000-00-00")) + for cat, key, _ in entries: + if len(json.dumps(memory, ensure_ascii=False)) <= MEMORY_MAX_CHARS: + break + del memory[cat][key] + print(f"[Memory] 🗑️ Trimmed {cat}/{key}") + return memory + + +# ── Kaydetme ────────────────────────────────────────────────────────────────── + def save_memory(memory: dict) -> None: if not isinstance(memory, dict): return - + memory = _trim_to_limit(memory) MEMORY_PATH.parent.mkdir(parents=True, exist_ok=True) - with _lock: MEMORY_PATH.write_text( json.dumps(memory, indent=2, ensure_ascii=False), - encoding="utf-8" + encoding="utf-8", ) + def _truncate_value(val: str) -> str: if isinstance(val, str) and len(val) > MAX_VALUE_LENGTH: return val[:MAX_VALUE_LENGTH].rstrip() + "…" @@ -59,13 +106,11 @@ def _truncate_value(val: str) -> str: def _recursive_update(target: dict, updates: dict) -> bool: changed = False - for key, value in updates.items(): if value is None: continue if isinstance(value, str) and not value.strip(): continue - if isinstance(value, dict) and "value" not in value: if key not in target or not isinstance(target[key], dict): target[key] = {} @@ -73,32 +118,26 @@ def _recursive_update(target: dict, updates: dict) -> bool: if _recursive_update(target[key], value): changed = True else: - if isinstance(value, dict) and "value" in value: - entry = {"value": _truncate_value(str(value["value"]))} - else: - entry = {"value": _truncate_value(str(value))} - - if key not in target or target[key] != entry: + new_val = _truncate_value(str(value["value"] if isinstance(value, dict) else value)) + entry = {"value": new_val, "updated": datetime.now().strftime("%Y-%m-%d")} + existing = target.get(key, {}) + if not isinstance(existing, dict) or existing.get("value") != new_val: target[key] = entry changed = True - return changed def update_memory(memory_update: dict) -> dict: - if not isinstance(memory_update, dict) or not memory_update: return load_memory() - memory = load_memory() - if _recursive_update(memory, memory_update): save_memory(memory) print(f"[Memory] 💾 Saved: {list(memory_update.keys())}") - return memory +# ── Prompt formatı ──────────────────────────────────────────────────────────── def format_memory_for_prompt(memory: dict | None) -> str: if not memory: @@ -106,46 +145,96 @@ def format_memory_for_prompt(memory: dict | None) -> str: lines = [] - # Identity - identity = memory.get("identity", {}) - name = identity.get("name", {}).get("value") - age = identity.get("age", {}).get("value") - bday = identity.get("birthday", {}).get("value") - city = identity.get("city", {}).get("value") - if name: lines.append(f"Name: {name}") - if age: lines.append(f"Age: {age}") - if bday: lines.append(f"Birthday: {bday}") - if city: lines.append(f"City: {city}") - - prefs = memory.get("preferences", {}) - for i, (key, entry) in enumerate(prefs.items()): - if i >= 5: - break + identity = memory.get("identity", {}) + id_fields = ["name", "age", "birthday", "city", "job", "language", "school", "nationality"] + for field in id_fields: + entry = identity.get(field) + if entry: + val = entry.get("value") if isinstance(entry, dict) else entry + if val: + lines.append(f"{field.title()}: {val}") + for key, entry in identity.items(): + if key in id_fields: + continue val = entry.get("value") if isinstance(entry, dict) else entry if val: lines.append(f"{key.replace('_', ' ').title()}: {val}") + prefs = memory.get("preferences", {}) + if prefs: + lines.append("") + lines.append("Preferences:") + for key, entry in list(prefs.items())[:15]: + val = entry.get("value") if isinstance(entry, dict) else entry + if val: + lines.append(f" - {key.replace('_', ' ').title()}: {val}") + + projects = memory.get("projects", {}) + if projects: + lines.append("") + lines.append("Active Projects / Goals:") + for key, entry in list(projects.items())[:8]: + val = entry.get("value") if isinstance(entry, dict) else entry + if val: + lines.append(f" - {key.replace('_', ' ').title()}: {val}") + rels = memory.get("relationships", {}) - for i, (key, entry) in enumerate(rels.items()): - if i >= 5: - break - val = entry.get("value") if isinstance(entry, dict) else entry - if val: - lines.append(f"{key.title()}: {val}") + if rels: + lines.append("") + lines.append("People in their life:") + for key, entry in list(rels.items())[:10]: + val = entry.get("value") if isinstance(entry, dict) else entry + if val: + lines.append(f" - {key.replace('_', ' ').title()}: {val}") + + wishes = memory.get("wishes", {}) + if wishes: + lines.append("") + lines.append("Wishes / Plans / Wants:") + for key, entry in list(wishes.items())[:8]: + val = entry.get("value") if isinstance(entry, dict) else entry + if val: + lines.append(f" - {key.replace('_', ' ').title()}: {val}") notes = memory.get("notes", {}) - for i, (key, entry) in enumerate(notes.items()): - if i >= 5: - break - val = entry.get("value") if isinstance(entry, dict) else entry - if val: - lines.append(f"{key}: {val}") + if notes: + lines.append("") + lines.append("Other notes:") + for key, entry in list(notes.items())[:8]: + val = entry.get("value") if isinstance(entry, dict) else entry + if val: + lines.append(f" - {key}: {val}") if not lines: return "" - result = "[USER MEMORY]\n" + "\n".join(f"- {l}" for l in lines) - if len(result) > 800: - result = result[:797] + "…" + header = "[WHAT YOU KNOW ABOUT THIS PERSON — use naturally, never recite like a list]\n" + result = header + "\n".join(lines) + if len(result) > 2000: + result = result[:1997] + "…" - return result + "\n" \ No newline at end of file + return result + "\n" + + +# ── Yardımcı fonksiyonlar ───────────────────────────────────────────────────── + +def remember(key: str, value: str, category: str = "notes") -> str: + valid = {"identity", "preferences", "projects", "relationships", "wishes", "notes"} + if category not in valid: + category = "notes" + update_memory({category: {key: {"value": value}}}) + return f"Remembered: {category}/{key} = {value}" + + +def forget(key: str, category: str = "notes") -> str: + memory = load_memory() + cat = memory.get(category, {}) + if key in cat: + del cat[key] + memory[category] = cat + save_memory(memory) + return f"Forgotten: {category}/{key}" + return f"Not found: {category}/{key}" + + +forget_memory = forget \ No newline at end of file diff --git a/readme.md b/readme.md index 675ce71..9dddcfd 100644 --- a/readme.md +++ b/readme.md @@ -1,59 +1,83 @@ -# 🤖 MARK XXX +# 🤖 MARK XXXVII (37) +### The Ultimate Cross-Platform Personal AI Assistant — By FatihMakes -**Watch The Detailed Video To Set-up This Model**: https://www.youtube.com/watch?v=-YjbWjv1tJg +> 📺 **[Watch the full setup video on YouTube](https://www.youtube.com/watch?v=BhOsnGC_sAA)** -### Next-Generation Personal AI Assistant — By FatihMakes +A real-time voice AI that can hear, see, understand, and control your computer — on any OS. Supporting Windows, macOS, and Linux. Local execution. Zero subscriptions. Engineered for total autonomy. -A real-time voice AI that can hear, see, understand, and control your Windows computer. -Local execution. Zero subscriptions(Unless you want to increase request by buying requests from Google AI Studio). -Built for intelligent automation. +--- ## ✨ Overview -**MARK XXX** is an advanced voice-driven AI assistant designed to turn your computer into an interactive intelligent system. +MARK XXXVII is the most versatile evolution of the Jarvis project. It transforms your operating system into a living, breathing intelligent entity. Through natural voice commands, Mark 37 analyzes your screen, manages your files, and executes complex workflows across different environments. -Speak naturally — it listens, understands context, responds with a human-like voice, and executes tasks across your system automatically. - -Designed for speed, autonomy, and real-world usability. +It's not just an assistant — it's an extension of your digital life. +--- ## 🚀 Capabilities -* **Real-time voice interaction** — Natural conversation with instant response -* **System control** — Launch apps, manage files, execute commands -* **Autonomous task execution** — Plans and completes multi-step workflows -* **Visual awareness** — Screen analysis and webcam understanding -* **Persistent memory** — Learns preferences and remembers context -* **Integrated tools** — Web search, weather, reminders, messaging, code help, image generation +### Core Features +| Feature | Description | +|---|---| +| 🎙️ Real-time Voice | Ultra-low latency conversation in any language | +| 🖥️ System Control | Launch apps, manage files, execute terminal commands | +| 🧩 Autonomous Tasks | High-level planning for complex, multi-step goals | +| 👁️ Visual Awareness | Real-time screen processing and webcam vision | +| 🧠 Persistent Memory | Deeply remembers your projects, preferences, and personal context | +| 🔒 Privacy First | Physical mute button (F4 / UI) and fully local control | +| ⌨️ Keyboard & Voice | Switch seamlessly between typing and speaking | + +--- + +## 🆕 What's New in XXXVII + +- 🐧🍎 **Cross-Platform Support** *(Experimental)* — Now runs on Windows, macOS, and Linux. Core features work across all platforms; some OS-specific tasks may vary during the testing phase. +- 💤 **Graceful Shutdown** — Tell Jarvis to "Shut down" or "Close" and it exits the session properly. +- 🧠 **Strengthened Memory** — Improved long-term retention and context recall; better understanding of relationships and history. +- 🔧 **Action Core Optimizations** — Major bugs in action scripts fixed for smoother system execution. +- ⚡ **Optimized Performance** — Faster response times and refined tool-calling logic. + +--- ## ⚡ Quick Start ```bash -git clone github.com/FatihMakes/Mark-XXX.git -cd mark-xxx -python setup.py +git clone https://github.com/FatihMakes/Mark-XXXVII.git +cd Mark-XXXVII +pip install -r requirements.txt +playwright install python main.py ``` -Enter your free Gemini API key on first launch. -System ready in minutes. +> ⚠️ **Installation Note:** Due to the new cross-platform integration, OS-specific libraries are not all bundled in `requirements.txt` to keep the install lightweight. If you encounter a `ModuleNotFoundError`, simply run `pip install ` for your specific system. -If you got some problems or questions to ask or just want to support; - -YouTube Account: [text](https://www.youtube.com/@FatihMakes) -Instagram Account: [text](https://www.instagram.com/fatihmakes/) +--- ## 📋 Requirements -* Windows 10 / 11 -* Python 3.10 or newer -* Microphone -* Gemini API key +| Requirement | Details | +|---|---| +| **OS** | Windows 10/11, macOS, or Linux | +| **Python** | 3.11 or 3.12 | +| **Microphone** | Required for voice commands | +| **API Key** | Free Gemini API key | + +--- ## ⚠️ License Personal and non-commercial use only. -Licensed under **Creative Commons BY-NC 4.0**. +Licensed under **[Creative Commons BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/)**. -Engineered by a 17-year-old building a real JARVIS-style assistant. -⭐ Star the repository to support the project. +--- + +## 👤 Connect with the Creator + +Engineered by an 18-year-old developer building a real JARVIS-style assistant. +⭐ **Star the repository to support the journey to Mark 100.** + +| Platform | Link | +|---|---| +| YouTube | [@FatihMakes](https://www.youtube.com/@FatihMakes) | +| Instagram | [@fatihmakes](https://www.instagram.com/fatihmakes) | \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 242bd6d40891ad7ea54ba92c42a6d0e1bf58c1b3..f904dfad8f909298a3648fc349cad7d020af489b 100644 GIT binary patch literal 634 zcmZ{iVNSy^429osB<`>aR0707xI$^mHjy@=O*{4Su+L5_F~k&Unf;!hpPl}EPl}o~ zsO5B8bXLRts0STEBENyS;_hJ8;PJRnn{DE&m&R;;`K2tb$`*Mv#-U5_Pp!`i%5ElFd5&bIgB&SEH7F!g-s@vI$kw z4CK-9zr&;z=)rJn>jqf^< Uso>jN@7pbX_Z{z9i(6PxSIiG+!T6$I@^BeP1}i z=#951)H`1}O?)}3X-*r08~u4#c6o-Q!@4H5!(tDzaq~O41ZV9eIkDiV?;^_%9ytv^ zW#x2gz(j-9b5b1puT9V+r^=^A`2Ma6(S6Z){1}5q!|wI}p2kHHW)1&hH{Y;Cd}y5{ HRzT", lambda e: self._toggle_mute()) self._api_key_ready = self._api_keys_exist() if not self._api_key_ready: @@ -100,6 +115,118 @@ class JarvisUI: self._animate() self.root.protocol("WM_DELETE_WINDOW", lambda: os._exit(0)) + def _build_mute_button(self): + BTN_W, BTN_H = 110, 32 + BTN_X = 18 + BTN_Y = self.H - 70 + + self._mute_canvas = tk.Canvas( + self.root, width=BTN_W, height=BTN_H, + bg=C_BG, highlightthickness=0, cursor="hand2" + ) + self._mute_canvas.place(x=BTN_X, y=BTN_Y) + self._mute_canvas.bind("", lambda e: self._toggle_mute()) + self._draw_mute_button() + + def _draw_mute_button(self): + c = self._mute_canvas + c.delete("all") + if self.muted: + border = C_MUTED + fill = "#1a0008" + icon = "🔇" + label = " MUTED" + fg = C_MUTED + else: + border = C_MID + fill = C_PANEL + icon = "🎙" + label = " LIVE" + fg = C_GREEN + + c.create_rectangle(0, 0, 110, 32, outline=border, fill=fill, width=1) + c.create_text(55, 16, text=f"{icon}{label}", + fill=fg, font=("Courier", 10, "bold")) + + def _toggle_mute(self): + self.muted = not self.muted + self._draw_mute_button() + if self.muted: + self.set_state("MUTED") + self.write_log("SYS: Microphone muted.") + else: + self.set_state("LISTENING") + self.write_log("SYS: Microphone active.") + + def _build_input_bar(self, lw: int, y: int): + x0 = (self.W - lw) // 2 + BTN_W = 70 + INP_W = lw - BTN_W - 4 + + self._input_var = tk.StringVar() + + self._input_entry = tk.Entry( + self.root, + textvariable=self._input_var, + fg=C_TEXT, bg="#000d12", + insertbackground=C_TEXT, + borderwidth=0, + font=("Courier", 10), + highlightthickness=1, + highlightbackground=C_DIM, + highlightcolor=C_PRI, + ) + self._input_entry.place(x=x0, y=y, width=INP_W, height=28) + self._input_entry.bind("", self._on_input_submit) + self._input_entry.bind("", self._on_input_submit) + + self._send_btn = tk.Button( + self.root, + text="SEND ▸", + command=self._on_input_submit, + fg=C_PRI, bg=C_PANEL, + activeforeground=C_BG, activebackground=C_PRI, + font=("Courier", 9, "bold"), + borderwidth=0, cursor="hand2", + highlightthickness=1, + highlightbackground=C_MID, + ) + self._send_btn.place(x=x0 + INP_W + 4, y=y, width=BTN_W, height=28) + + def _on_input_submit(self, event=None): + text = self._input_var.get().strip() + if not text: + return + self._input_var.set("") + self.write_log(f"You: {text}") + if self.on_text_command: + threading.Thread( + target=self.on_text_command, + args=(text,), + daemon=True + ).start() + + def set_state(self, state: str): + self._jarvis_state = state + if state == "MUTED": + self.status_text = "MUTED" + self.speaking = False + elif state == "SPEAKING": + self.status_text = "SPEAKING" + self.speaking = True + elif state == "THINKING": + self.status_text = "THINKING" + self.speaking = False + elif state == "LISTENING": + self.status_text = "LISTENING" + self.speaking = False + elif state == "PROCESSING": + self.status_text = "PROCESSING" + self.speaking = False + else: + self.status_text = "ONLINE" + self.speaking = False + def _load_face(self, path): FW = self.FACE_SZ try: @@ -126,6 +253,9 @@ class JarvisUI: if self.speaking: self.target_scale = random.uniform(1.05, 1.11) self.target_halo = random.uniform(138, 182) + elif self.muted: + self.target_scale = random.uniform(0.998, 1.001) + self.target_halo = random.uniform(20, 32) else: self.target_scale = random.uniform(1.001, 1.007) self.target_halo = random.uniform(50, 68) @@ -170,22 +300,31 @@ class JarvisUI: for r in range(int(FW * 0.54), int(FW * 0.28), -22): frac = 1.0 - (r - FW * 0.28) / (FW * 0.26) ga = max(0, min(255, int(self.halo_a * 0.09 * frac))) - gh = f"{ga:02x}" - c.create_oval(FCX-r, FCY-r, FCX+r, FCY+r, - outline=f"#00{gh}ff", width=2) + if self.muted: + gh = f"{ga:02x}" + c.create_oval(FCX-r, FCY-r, FCX+r, FCY+r, + outline=f"#{gh}0011", width=2) + else: + gh = f"{ga:02x}" + c.create_oval(FCX-r, FCY-r, FCX+r, FCY+r, + outline=f"#00{gh}ff", width=2) for pr in self.pulse_r: pa = max(0, int(220 * (1.0 - pr / (FW * 0.72)))) r = int(pr) - c.create_oval(FCX-r, FCY-r, FCX+r, FCY+r, - outline=self._ac(0, 212, 255, pa), width=2) + if self.muted: + c.create_oval(FCX-r, FCY-r, FCX+r, FCY+r, + outline=self._ac(255, 30, 80, pa // 3), width=2) + else: + c.create_oval(FCX-r, FCY-r, FCX+r, FCY+r, + outline=self._ac(0, 212, 255, pa), width=2) for idx, (r_frac, w_ring, arc_l, gap) in enumerate([ (0.47, 3, 110, 75), (0.39, 2, 75, 55), (0.31, 1, 55, 38)]): ring_r = int(FW * r_frac) base_a = self.rings_spin[idx] a_val = max(0, min(255, int(self.halo_a * (1.0 - idx * 0.18)))) - col = self._ac(0, 212, 255, a_val) + col = self._ac(255, 30, 80, a_val) if self.muted else self._ac(0, 212, 255, a_val) for s in range(360 // (arc_l + gap)): start = (base_a + s * (arc_l + gap)) % 360 c.create_arc(FCX-ring_r, FCY-ring_r, FCX+ring_r, FCY+ring_r, @@ -195,9 +334,10 @@ class JarvisUI: sr = int(FW * 0.49) scan_a = min(255, int(self.halo_a * 1.4)) arc_ext = 70 if self.speaking else 42 + scan_col = self._ac(255, 30, 80, scan_a) if self.muted else self._ac(0, 212, 255, scan_a) c.create_arc(FCX-sr, FCY-sr, FCX+sr, FCY+sr, start=self.scan_angle, extent=arc_ext, - outline=self._ac(0, 212, 255, scan_a), width=3, style="arc") + outline=scan_col, width=3, style="arc") c.create_arc(FCX-sr, FCY-sr, FCX+sr, FCY+sr, start=self.scan2_angle, extent=arc_ext, outline=self._ac(255, 100, 0, scan_a // 2), width=2, style="arc") @@ -234,17 +374,27 @@ class JarvisUI: if (self._face_scale_cache is None or abs(self._face_scale_cache[0] - self.scale) > 0.004): scaled = self._face_pil.resize((fw, fw), Image.BILINEAR) + if self.muted: + tinted = scaled.copy() + r_ch, g_ch, b_ch, a_ch = tinted.split() + from PIL import ImageEnhance + g_ch = ImageEnhance.Brightness( + Image.fromarray(__import__('numpy').array(g_ch) // 2) + ).enhance(1.0) if False else g_ch tk_img = ImageTk.PhotoImage(scaled) self._face_scale_cache = (self.scale, tk_img) c.create_image(FCX, FCY, image=self._face_scale_cache[1]) else: orb_r = int(FW * 0.27 * self.scale) + orb_color = (255, 30, 80) if self.muted else (0, 65, 120) for i in range(7, 0, -1): r2 = int(orb_r * i / 7) frac = i / 7 ga = max(0, min(255, int(self.halo_a * 1.1 * frac))) c.create_oval(FCX-r2, FCY-r2, FCX+r2, FCY+r2, - fill=self._ac(0, int(65*frac), int(120*frac), ga), + fill=self._ac(int(orb_color[0]*frac), + int(orb_color[1]*frac), + int(orb_color[2]*frac), ga), outline="") c.create_text(FCX, FCY, text=SYSTEM_NAME, fill=self._ac(0, 212, 255, min(255, int(self.halo_a * 2))), @@ -257,18 +407,35 @@ class JarvisUI: fill=C_PRI, font=("Courier", 18, "bold")) c.create_text(W // 2, 44, text="Just A Rather Very Intelligent System", fill=C_MID, font=("Courier", 9)) - c.create_text(16, 31, text=MODEL_BADGE, + c.create_text(16, 31, text=MODEL_BADGE, fill=C_DIM, font=("Courier", 9), anchor="w") c.create_text(W - 16, 31, text=time.strftime("%H:%M:%S"), fill=C_PRI, font=("Courier", 14, "bold"), anchor="e") - sy = FCY + FW // 2 + 45 - if self.speaking: - stat, sc = "● SPEAKING", C_ACC + + if self.muted: + stat = "⊘ MUTED" + sc = C_MUTED + elif self.speaking: + stat = "● SPEAKING" + sc = C_ACC + elif self._jarvis_state == "THINKING": + sym = "◈" if self.status_blink else "◇" + stat = f"{sym} THINKING" + sc = C_ACC2 + elif self._jarvis_state == "PROCESSING": + sym = "▷" if self.status_blink else "▶" + stat = f"{sym} PROCESSING" + sc = C_ACC2 + elif self._jarvis_state == "LISTENING": + sym = "●" if self.status_blink else "○" + stat = f"{sym} LISTENING" + sc = C_GREEN else: - sym = "●" if self.status_blink else "○" - stat, sc = f"{sym} {self.status_text}", C_PRI + sym = "●" if self.status_blink else "○" + stat = f"{sym} {self.status_text}" + sc = C_PRI c.create_text(W // 2, sy, text=stat, fill=sc, font=("Courier", 11, "bold")) @@ -280,36 +447,53 @@ class JarvisUI: total_w = N * bw wx0 = (W - total_w) // 2 for i in range(N): - hb = random.randint(3, BH) if self.speaking else int(3 + 2 * math.sin(t * 0.08 + i * 0.55)) - col = (C_PRI if hb > BH * 0.6 else C_MID) if self.speaking else C_DIM - bx = wx0 + i * bw + if self.muted: + hb = 2 + col = C_MUTED + elif self.speaking: + hb = random.randint(3, BH) + col = C_PRI if hb > BH * 0.6 else C_MID + else: + hb = int(3 + 2 * math.sin(t * 0.08 + i * 0.55)) + col = C_DIM + bx = wx0 + i * bw c.create_rectangle(bx, wy + BH - hb, bx + bw - 1, wy + BH, fill=col, outline="") c.create_rectangle(0, H - 28, W, H, fill="#00080d", outline="") c.create_line(0, H - 28, W, H - 28, fill=C_DIM, width=1) + c.create_text(W - 16, H - 14, fill=C_DIM, font=("Courier", 8), + text="[F4] MUTE", anchor="e") c.create_text(W // 2, H - 14, fill=C_DIM, font=("Courier", 8), - text="FatihMakes Industries · CLASSIFIED · MARK XXX") + text="FatihMakes Industries · CLASSIFIED · MARK XXXVII") def write_log(self, text: str): self.typing_queue.append(text) tl = text.lower() - self.status_text = ("PROCESSING" if tl.startswith("you:") - else "RESPONDING" if tl.startswith("ai:") - else self.status_text) + if tl.startswith("you:"): + self.set_state("PROCESSING") + elif tl.startswith("jarvis:") or tl.startswith("ai:"): + self.set_state("SPEAKING") if not self.is_typing: self._start_typing() def _start_typing(self): if not self.typing_queue: self.is_typing = False - if not self.speaking: - self.status_text = "ONLINE" + if not self.speaking and not self.muted: + self.set_state("LISTENING") return self.is_typing = True text = self.typing_queue.popleft() tl = text.lower() - tag = "you" if tl.startswith("you:") else "ai" if tl.startswith("ai:") else "sys" + if tl.startswith("you:"): + tag = "you" + elif tl.startswith("jarvis:") or tl.startswith("ai:"): + tag = "ai" + elif tl.startswith("err:") or "error" in tl or "failed" in tl: + tag = "err" + else: + tag = "sys" self.log_text.configure(state="normal") self._type_char(text, 0, tag) @@ -324,57 +508,181 @@ class JarvisUI: self.root.after(25, self._start_typing) def start_speaking(self): - self.speaking = True - self.status_text = "SPEAKING" + self.set_state("SPEAKING") def stop_speaking(self): - self.speaking = False - self.status_text = "ONLINE" + if not self.muted: + self.set_state("LISTENING") - def _api_keys_exist(self): - return API_FILE.exists() + def _api_keys_exist(self) -> bool: + if not API_FILE.exists(): + return False + try: + data = json.loads(API_FILE.read_text(encoding="utf-8")) + return bool(data.get("gemini_api_key")) and bool(data.get("os_system")) + except Exception: + return False def wait_for_api_key(self): - """Block until API key is saved (called from main thread before starting JARVIS).""" while not self._api_key_ready: time.sleep(0.1) + @staticmethod + def _detect_os() -> str: + s = platform.system().lower() + if s == "darwin": + return "mac" + if s == "windows": + return "windows" + return "linux" + def _show_setup_ui(self): + detected = self._detect_os() + + self._selected_os = tk.StringVar(value=detected) + self.setup_frame = tk.Frame( self.root, bg="#00080d", highlightbackground=C_PRI, highlightthickness=1 ) self.setup_frame.place(relx=0.5, rely=0.5, anchor="center") - tk.Label(self.setup_frame, text="◈ INITIALISATION REQUIRED", - fg=C_PRI, bg="#00080d", font=("Courier", 13, "bold")).pack(pady=(18, 4)) - tk.Label(self.setup_frame, - text="Enter your Gemini API key to boot J.A.R.V.I.S.", - fg=C_MID, bg="#00080d", font=("Courier", 9)).pack(pady=(0, 10)) + tk.Label( + self.setup_frame, + text="◈ INITIALISATION REQUIRED", + fg=C_PRI, bg="#00080d", + font=("Courier", 13, "bold") + ).pack(pady=(18, 2)) + + tk.Label( + self.setup_frame, + text="Configure J.A.R.V.I.S. before first boot.", + fg=C_MID, bg="#00080d", + font=("Courier", 9) + ).pack(pady=(0, 14)) + + tk.Label( + self.setup_frame, + text="GEMINI API KEY", + fg=C_DIM, bg="#00080d", + font=("Courier", 9) + ).pack(pady=(0, 2)) - tk.Label(self.setup_frame, text="GEMINI API KEY", - fg=C_DIM, bg="#00080d", font=("Courier", 9)).pack(pady=(8, 2)) self.gemini_entry = tk.Entry( - self.setup_frame, width=52, fg=C_TEXT, bg="#000d12", - insertbackground=C_TEXT, borderwidth=0, font=("Courier", 10), show="*" + self.setup_frame, width=52, + fg=C_TEXT, bg="#000d12", + insertbackground=C_TEXT, + borderwidth=0, font=("Courier", 10), show="*" ) - self.gemini_entry.pack(pady=(0, 4)) + self.gemini_entry.pack(pady=(0, 18)) + + sep_frame = tk.Frame(self.setup_frame, bg="#00080d") + sep_frame.pack(fill="x", padx=24, pady=(0, 12)) + tk.Frame(sep_frame, bg=C_DIM, height=1).pack(fill="x") + + tk.Label( + self.setup_frame, + text="SELECT OPERATING SYSTEM", + fg=C_DIM, bg="#00080d", + font=("Courier", 9) + ).pack(pady=(0, 4)) + + detect_label = { + "windows": "Windows", + "mac": "macOS", + "linux": "Linux", + }.get(detected, detected.capitalize()) + + tk.Label( + self.setup_frame, + text=f"AUTO-DETECTED: {detect_label}", + fg=C_ACC2, bg="#00080d", + font=("Courier", 8) + ).pack(pady=(0, 8)) + + os_btn_frame = tk.Frame(self.setup_frame, bg="#00080d") + os_btn_frame.pack(pady=(0, 18)) + + os_options = [ + ("windows", "⊞ WINDOWS"), + ("mac", " macOS"), + ("linux", "🐧 LINUX"), + ] + + self._os_buttons = {} + for os_key, os_label in os_options: + btn = tk.Button( + os_btn_frame, + text=os_label, + width=13, + font=("Courier", 10, "bold"), + borderwidth=0, + cursor="hand2", + pady=7, + command=lambda k=os_key: self._select_os(k) + ) + btn.pack(side="left", padx=6) + self._os_buttons[os_key] = btn + + self._select_os(detected) + + sep_frame2 = tk.Frame(self.setup_frame, bg="#00080d") + sep_frame2.pack(fill="x", padx=24, pady=(0, 14)) + tk.Frame(sep_frame2, bg=C_DIM, height=1).pack(fill="x") tk.Button( - self.setup_frame, text="▸ INITIALISE SYSTEMS", - command=self._save_api_keys, bg=C_BG, fg=C_PRI, - activebackground="#003344", font=("Courier", 10), + self.setup_frame, + text="▸ INITIALISE SYSTEMS", + command=self._save_api_keys, + bg=C_BG, fg=C_PRI, + activebackground="#003344", + font=("Courier", 10), borderwidth=0, pady=8 - ).pack(pady=14) + ).pack(pady=(0, 18)) + + def _select_os(self, os_key: str): + self._selected_os.set(os_key) + styles = { + "windows": (C_PRI, "#001a22"), + "mac": (C_ACC2, "#1a1500"), + "linux": (C_GREEN, "#001a0d"), + } + for key, btn in self._os_buttons.items(): + if key == os_key: + fg, bg = styles[key] + btn.configure( + fg=bg, bg=fg, + activeforeground=bg, activebackground=fg, + relief="flat" + ) + else: + btn.configure( + fg=C_DIM, bg="#000d12", + activeforeground=C_TEXT, activebackground="#001a22", + relief="flat" + ) def _save_api_keys(self): gemini = self.gemini_entry.get().strip() if not gemini: + self.gemini_entry.configure(highlightthickness=1, + highlightbackground=C_RED, + highlightcolor=C_RED) return + + os_system = self._selected_os.get() + os.makedirs(CONFIG_DIR, exist_ok=True) with open(API_FILE, "w", encoding="utf-8") as f: - json.dump({"gemini_api_key": gemini}, f, indent=4) + json.dump( + { + "gemini_api_key": gemini, + "os_system": os_system, + }, + f, indent=4 + ) + self.setup_frame.destroy() self._api_key_ready = True - self.status_text = "ONLINE" - self.write_log("SYS: Systems initialised. JARVIS online.") \ No newline at end of file + self.set_state("LISTENING") + self.write_log(f"SYS: Systems initialised. OS → {os_system.upper()}. JARVIS online.") \ No newline at end of file