run.py

#!/usr/bin/env python3
"""TimeTracker - Local macOS activity tracker with menu bar UI."""

import sys
import os
import signal
import logging
import threading
import webbrowser

# Add project root to path
sys.path.insert(0, os.path.dirname(__file__))

import config


def run_flask():
    """Run Flask in a background thread."""
    from web.app import create_app
    app = create_app()
    from werkzeug.serving import make_server
    server = make_server(config.HOST, config.PORT, app, threaded=True)
    server.serve_forever()


def main():
    log_file = os.path.join(config.DATA_DIR, "timetracker.log")
    os.makedirs(config.DATA_DIR, exist_ok=True)
    logging.basicConfig(
        level=logging.DEBUG,
        format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
        datefmt="%H:%M:%S",
        handlers=[
            logging.StreamHandler(),
            logging.FileHandler(log_file),
        ],
    )
    logger = logging.getLogger("timetracker")

    import AppKit
    import objc
    from Foundation import NSObject, NSTimer, NSDate
    from AppKit import (
        NSApplication,
        NSStatusBar,
        NSMenu,
        NSMenuItem,
        NSImage,
        NSVariableStatusItemLength,
        NSApplicationActivationPolicyAccessory,
    )

    # Start monitor
    from tracker.monitor import start_monitor_thread
    thread, stop_event = start_monitor_thread()
    logger.info("Monitor running (polling every %ds)", config.POLL_INTERVAL)

    # Start Flask in background thread
    flask_thread = threading.Thread(target=run_flask, daemon=True)
    flask_thread.start()
    logger.info("Dashboard at http://%s:%d", config.HOST, config.PORT)

    # Create NSApplication for menu bar
    app = NSApplication.sharedApplication()
    # Accessory = no dock icon, just menu bar
    app.setActivationPolicy_(NSApplicationActivationPolicyAccessory)

    from tracker.db import list_clients, get_client_budgets
    from tracker.active_task import get_active_task, set_active_task

    class MenuDelegate(NSObject):
        """Rebuilds the menu each time it opens to show current clients/tasks."""
        _appDelegate = None

        def menuNeedsUpdate_(self, menu):
            menu.removeAllItems()

            title_item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
                "TimeTracker", None, ""
            )
            title_item.setEnabled_(False)
            menu.addItem_(title_item)
            menu.addItem_(NSMenuItem.separatorItem())

            # Active task and client data
            try:
                active = get_active_task()
                clients = list_clients()
                budgets_data = get_client_budgets()
                budgets = {b["id"]: b for b in budgets_data.get("clients", [])}
            except Exception:
                active = {"client_id": None, "task_id": None}
                clients = []
                budgets = {}

            # "No Client" option
            no_client_item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
                "No Client", "selectTask:", ""
            )
            no_client_item.setTarget_(self._appDelegate)
            no_client_item.setRepresentedObject_({"client_id": None, "task_id": None})
            if active["client_id"] is None:
                no_client_item.setState_(1)  # checkmark
            menu.addItem_(no_client_item)

            menu.addItem_(NSMenuItem.separatorItem())

            for c in clients:
                b = budgets.get(c["id"], {})
                used = b.get("used_hrs", 0)
                limit = c.get("weekly_limit_hrs")
                if limit:
                    label = f"{c['name']}  ({used}h/{limit}h)"
                else:
                    label = f"{c['name']}  ({used}h)"

                client_item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
                    label, None, ""
                )

                # Submenu with tasks
                sub = NSMenu.alloc().init()

                # General (client-level, no task)
                gen_item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
                    "General", "selectTask:", ""
                )
                gen_item.setTarget_(self._appDelegate)
                gen_item.setRepresentedObject_({"client_id": c["id"], "task_id": None})
                if active["client_id"] == c["id"] and active["task_id"] is None:
                    gen_item.setState_(1)
                sub.addItem_(gen_item)

                for t in c.get("tasks", []):
                    t_item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
                        t["name"], "selectTask:", ""
                    )
                    t_item.setTarget_(self._appDelegate)
                    t_item.setRepresentedObject_({"client_id": c["id"], "task_id": t["id"]})
                    if active["client_id"] == c["id"] and active["task_id"] == t["id"]:
                        t_item.setState_(1)
                    sub.addItem_(t_item)

                client_item.setSubmenu_(sub)
                menu.addItem_(client_item)

            menu.addItem_(NSMenuItem.separatorItem())

            dashboard_item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
                "Open Dashboard", "openDashboard:", "d"
            )
            dashboard_item.setTarget_(self._appDelegate)
            menu.addItem_(dashboard_item)

            menu.addItem_(NSMenuItem.separatorItem())

            quit_item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
                "Quit TimeTracker", "quitApp:", "q"
            )
            quit_item.setTarget_(self._appDelegate)
            menu.addItem_(quit_item)

    class AppDelegate(NSObject):
        statusItem = None

        def applicationDidFinishLaunching_(self, notification):
            # Create status bar item
            self.statusItem = NSStatusBar.systemStatusBar().statusItemWithLength_(
                NSVariableStatusItemLength
            )
            button = self.statusItem.button()
            button.setTitle_("TT")

            menu = NSMenu.alloc().init()
            menuDel = MenuDelegate.alloc().init()
            menuDel._appDelegate = self
            menu.setDelegate_(menuDel)
            # Keep a reference so it doesn't get GC'd
            self._menuDelegate = menuDel
            self.statusItem.setMenu_(menu)

        def selectTask_(self, sender):
            info = sender.representedObject()
            if info:
                set_active_task(info.get("client_id"), info.get("task_id"))

        @objc.python_method
        def _open_dashboard(self):
            webbrowser.open(f"http://{config.HOST}:{config.PORT}")

        def openDashboard_(self, sender):
            self._open_dashboard()

        def quitApp_(self, sender):
            stop_event.set()
            NSApplication.sharedApplication().terminate_(None)

    delegate = AppDelegate.alloc().init()
    app.setDelegate_(delegate)

    # Handle SIGTERM/SIGINT
    def shutdown(signum, frame):
        stop_event.set()
        app.terminate_(None)

    signal.signal(signal.SIGINT, shutdown)
    signal.signal(signal.SIGTERM, shutdown)

    app.run()


if __name__ == "__main__":
    try:
        main()
    except Exception:
        import traceback
        crash_log = os.path.join(os.path.expanduser("~/.timetracker"), "crash.log")
        os.makedirs(os.path.dirname(crash_log), exist_ok=True)
        with open(crash_log, "a") as f:
            f.write(f"\n--- Crash at {__import__('datetime').datetime.now()} ---\n")
            traceback.print_exc(file=f)
        raise