feat: add comprehensive logging system and export logs button

- Add utils/logger.py with file + console logging, exception capture
- Add Export Logs button to GUI dashboard for easy debugging
- Add global Tkinter exception handler to catch all GUI errors
- Update launcher with detailed startup logging and error reporting
- Logs saved to %APPDATA%\.config\tp-opencode\logs"

Author: 2241812

src/opencode_telegram_bot/gui.py

@@ -7,6 +7,8 @@
 import shutil
 import sys
 import threading
+import traceback
+from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable
 
@@ -17,6 +19,7 @@
 from opencode_telegram_bot.core.config import Settings, DEFAULT_CONFIG_DIR
 from opencode_telegram_bot.utils.scheduler import TaskScheduler
 from opencode_telegram_bot.utils.i18n import get_available_locales
+from opencode_telegram_bot.utils.logger import setup_logging, log_exception, get_log_contents, LOG_DIR, LOG_FILE
 
 logger = logging.getLogger(__name__)
 
@@ -348,7 +351,10 @@ def _build(self) -> None:
         logging.getLogger("opencode_telegram_bot").addHandler(log_handler)
         logging.getLogger("telegram").addHandler(log_handler)
 
-        _CTkButtonSecondary(right_panel, text="Clear Logs", command=self._clear_logs, height=36).grid(row=2, column=0, pady=(8, 0), sticky="e")
+        btn_logs_frame = ctk.CTkFrame(right_panel, fg_color=COLORS["bg"])
+        btn_logs_frame.grid(row=2, column=0, pady=(8, 0), sticky="e")
+        _CTkButtonSecondary(btn_logs_frame, text="Clear Logs", command=self._clear_logs, height=36, width=120).pack(side="left", padx=(0, 8))
+        _CTkButtonSecondary(btn_logs_frame, text="Export Logs", command=self._export_logs, height=36, width=120).pack(side="left")
 
     def _log_callback(self, msg: str) -> None:
         self.after(0, lambda: self._append_log(msg))
@@ -360,6 +366,18 @@ def _append_log(self, msg: str) -> None:
     def _clear_logs(self) -> None:
         self.log_text.delete("1.0", "end")
 
+    def _export_logs(self) -> None:
+        try:
+            log_content = get_log_contents()
+            gui_log = self.log_text.get("1.0", "end")
+            combined = f"=== FILE LOG ({LOG_FILE}) ===\n{log_content}\n\n=== GUI LOG ===\n{gui_log}"
+            export_file = LOG_DIR / f"tp-opencode-logs-{datetime.now().strftime('%Y%m%d-%H%M%S')}.txt"
+            export_file.write_text(combined, encoding="utf-8")
+            self._append_log(f"Logs exported to: {export_file}")
+            self._append_log("Share this file for debugging support.")
+        except Exception as exc:
+            self._append_log(f"Failed to export logs: {exc}")
+
     def _start_status_poll(self) -> None:
         self._poll_status()
 
@@ -486,8 +504,9 @@ async def run():
                 self.after(0, lambda: self._append_log("Bot polling started."))
                 while not self._stop_event.is_set():
                     await asyncio.sleep(0.5)
-            except Exception as e:
-                self.after(0, lambda: self._append_log(f"Bot error: {e}"))
+            except Exception as exc:
+                err_msg = f"Bot error: {exc}"
+                self.after(0, lambda m=err_msg: self._append_log(m))
                 self.after(0, lambda: self.bot_label.configure(text="Bot: Error", text_color=COLORS["error"]))
             finally:
                 try:
@@ -511,8 +530,9 @@ async def run():
         asyncio.set_event_loop(loop)
         try:
             loop.run_until_complete(run())
-        except Exception as e:
-            self.after(0, lambda: self._append_log(f"Bot loop error: {e}"))
+        except Exception as exc:
+            err_msg = f"Bot loop error: {exc}"
+            self.after(0, lambda m=err_msg: self._append_log(m))
             self.after(0, lambda: self.bot_label.configure(text="Bot: Error", text_color=COLORS["error"]))
         finally:
             loop.close()
@@ -536,9 +556,9 @@ def fetch():
                 asyncio.set_event_loop(loop)
                 providers = loop.run_until_complete(self.client.get_config_providers())
                 loop.close()
-                self.after(0, lambda: self._render_models(providers))
-            except Exception as e:
-                self.after(0, lambda: self._append_log(f"Failed to load models: {e}"))
+                self.after(0, lambda p=providers: self._render_models(p))
+            except Exception as exc:
+                self.after(0, lambda e=str(exc): self._append_log(f"Failed to load models: {e}"))
 
         threading.Thread(target=fetch, daemon=True).start()
 
@@ -591,9 +611,22 @@ def __init__(self) -> None:
         ctk.set_appearance_mode("light")
         ctk.set_default_color_theme("blue")
 
+        setup_logging()
+        self._logger = logging.getLogger("tp-opencode.gui")
+        self._logger.info("GUI application starting")
+
         self.settings: Settings | None = None
+        self._bind_error_handler()
         self._build()
 
+    def _bind_error_handler(self) -> None:
+        original_report = self.report_callback_exception
+        def handle_exception(exc, val, tb):
+            log_exception(exc, "Tkinter callback")
+            self._logger.error("Unhandled GUI error: %s", val)
+            original_report(exc, val, tb)
+        self.report_callback_exception = handle_exception
+
     def _build(self) -> None:
         env_file = DEFAULT_CONFIG_DIR / ".env"
         if env_file.exists():

src/opencode_telegram_bot/launcher.py

@@ -1,17 +1,16 @@
 from __future__ import annotations
 
-import logging
 import shutil
 import sys
 import time
+import traceback
 from pathlib import Path
 
 from dotenv import load_dotenv
 
 from opencode_telegram_bot.api import OpenCodeServer
 from opencode_telegram_bot.core.config import DEFAULT_CONFIG_DIR
-
-logger = logging.getLogger("tp-opencode-launcher")
+from opencode_telegram_bot.utils.logger import setup_logging, log_exception
 
 
 def _find_opencode() -> str:
@@ -31,31 +30,57 @@ def _find_opencode() -> str:
 
 
 def launch() -> None:
+    logger = setup_logging()
+    logger.info("=" * 60)
+    logger.info("tp-opencode starting")
+    logger.info("Python: %s", sys.version)
+    logger.info("Platform: %s", sys.platform)
+    logger.info("Config dir: %s", DEFAULT_CONFIG_DIR)
+
     env_file = DEFAULT_CONFIG_DIR / ".env"
     if env_file.exists():
         load_dotenv(env_file, override=True)
+        logger.info("Loaded config from %s", env_file)
+    else:
+        logger.warning("No .env file found at %s", env_file)
+
+    try:
+        from opencode_telegram_bot.core.config import Settings
+
+        settings = Settings()
+        logger.info("Settings loaded. API URL: %s", settings.opencode_api_url)
+        logger.info("Auto-start: %s", settings.opencode_auto_start)
 
-    from opencode_telegram_bot.core.config import Settings
+        opencode_cmd = settings.opencode_command or _find_opencode()
+        logger.info("OpenCode command: %s", opencode_cmd)
 
-    settings = Settings()
-    opencode_cmd = settings.opencode_command or _find_opencode()
+        server = OpenCodeServer(
+            command=opencode_cmd,
+            work_dir=settings.opencode_work_dir or None,
+        )
 
-    server = OpenCodeServer(
-        command=opencode_cmd,
-        work_dir=settings.opencode_work_dir or None,
-    )
+        if settings.opencode_auto_start and not server.is_running:
+            try:
+                logger.info("Starting OpenCode server...")
+                server.start()
+                time.sleep(3)
+                logger.info("OpenCode server started (PID: %s)", server.get_pid())
+            except FileNotFoundError:
+                logger.warning("opencode command not found at '%s'. GUI will still open.", opencode_cmd)
+            except Exception as e:
+                log_exception(e, "Starting OpenCode server")
+                logger.warning("Failed to start OpenCode server. GUI will still open.")
 
-    if settings.opencode_auto_start and not server.is_running:
-        try:
-            logger.info("Starting OpenCode server...")
-            server.start()
-            time.sleep(3)
-            logger.info("OpenCode server started.")
-        except FileNotFoundError:
-            logger.warning("opencode command not found. GUI will still open.")
+        logger.info("Launching GUI...")
+        from opencode_telegram_bot.gui import main as gui_main
+        gui_main()
 
-    from opencode_telegram_bot.gui import main as gui_main
-    gui_main()
+    except Exception as e:
+        log_exception(e, "Launcher")
+        print(f"\nFatal error: {e}")
+        traceback.print_exc()
+        input("Press Enter to exit...")
+        raise
 
 
 if __name__ == "__main__":

src/opencode_telegram_bot/utils/logger.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import logging
+import sys
+import traceback
+from datetime import datetime
+from pathlib import Path
+
+from opencode_telegram_bot.core.config import DEFAULT_CONFIG_DIR
+
+LOG_DIR = DEFAULT_CONFIG_DIR / "logs"
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+LOG_FILE = LOG_DIR / f"tp-opencode-{datetime.now().strftime('%Y-%m-%d')}.log"
+
+
+def setup_logging(level: str = "DEBUG") -> logging.Logger:
+    root = logging.getLogger("tp-opencode")
+    root.setLevel(getattr(logging, level.upper(), logging.DEBUG))
+
+    if root.handlers:
+        return root
+
+    fmt = logging.Formatter(
+        "%(asctime)s [%(levelname)s] %(name)s (%(filename)s:%(lineno)d): %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    fh = logging.FileHandler(LOG_FILE, encoding="utf-8")
+    fh.setLevel(logging.DEBUG)
+    fh.setFormatter(fmt)
+    root.addHandler(fh)
+
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.INFO)
+    ch.setFormatter(fmt)
+    root.addHandler(ch)
+
+    return root
+
+
+def log_exception(exc: Exception, context: str = "") -> None:
+    root = logging.getLogger("tp-opencode")
+    tb = traceback.format_exc()
+    root.error("=== EXCEPTION ===")
+    if context:
+        root.error("Context: %s", context)
+    root.error("Type: %s", type(exc).__name__)
+    root.error("Message: %s", str(exc))
+    root.error("Traceback:\n%s", tb)
+    root.error("=== END EXCEPTION ===")
+
+
+def get_log_contents(max_lines: int = 500) -> str:
+    if not LOG_FILE.exists():
+        return "No log file found."
+    lines = LOG_FILE.read_text(encoding="utf-8").splitlines()
+    return "\n".join(lines[-max_lines:])

src/opencode_telegram_bot/utils/scheduler.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import asyncio
+import inspect
 import logging
 from typing import Any, Callable
 
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.interval import IntervalTrigger
 from apscheduler.triggers.cron import CronTrigger
 
@@ -15,21 +17,37 @@ class TaskScheduler:
 
     def __init__(self, max_tasks: int = 10) -> None:
         self.max_tasks = max_tasks
-        self._scheduler = AsyncIOScheduler()
+        self._scheduler = BackgroundScheduler(daemon=True)
         self._tasks: dict[str, dict[str, Any]] = {}
         self._callbacks: dict[str, Callable] = {}
 
     def start(self) -> None:
-        self._scheduler.start()
-        logger.info("Task scheduler started")
+        if not self._scheduler.running:
+            self._scheduler.start()
+            logger.info("Task scheduler started")
 
     def stop(self) -> None:
-        self._scheduler.shutdown(wait=False)
-        logger.info("Task scheduler stopped")
+        if self._scheduler.running:
+            self._scheduler.shutdown(wait=False)
+            logger.info("Task scheduler stopped")
 
     def register_callback(self, name: str, callback: Callable) -> None:
         self._callbacks[name] = callback
 
+    def _wrap_callback(self, callback: Callable) -> Callable:
+        if inspect.iscoroutinefunction(callback):
+            def async_wrapper(*args, **kwargs):
+                try:
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    loop.run_until_complete(callback(*args, **kwargs))
+                except Exception:
+                    logger.exception("Scheduled async task failed")
+                finally:
+                    loop.close()
+            return async_wrapper
+        return callback
+
     def add_interval_task(
         self,
         task_id: str,
@@ -51,7 +69,7 @@ def add_interval_task(
 
         trigger = IntervalTrigger(minutes=interval_minutes)
         self._scheduler.add_job(
-            callback,
+            self._wrap_callback(callback),
             trigger,
             args=[prompt, project_id, model_provider, model_id],
             id=task_id,
@@ -101,7 +119,7 @@ def add_cron_task(
             return False
 
         self._scheduler.add_job(
-            callback,
+            self._wrap_callback(callback),
             trigger,
             args=[prompt, project_id, model_provider, model_id],
             id=task_id,