flexitracker 0.3.0__tar.gz → 0.4.0__tar.gz

{flexitracker-0.3.0 → flexitracker-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexitracker
-Version: 0.3.0
+Version: 0.4.0
 Summary: FlexiTracker activity daemon — pure-Python.
 License-Expression: MIT
 Requires-Python: >=3.11
@@ -23,10 +23,12 @@ Recommended (all platforms):
 uv tool install flexitracker
 ```
 
-Or, on a machine that allows executables, download the standalone
-`flexitracker` / `flexitracker.exe` from the GitHub **Releases** page (it bundles
-its own Python runtime). See `install/README.md` for per-OS auto-start and the
-Windows SmartScreen trust step.
+Or, on a machine that allows executables, download the standalone build from
+the GitHub **Releases** page (it bundles its own Python runtime): one binary
+on Linux, or on Windows two — a console one for `login`/`test` and a
+windowless one for auto-start. See `install/README.md` for per-OS auto-start
+(a single copy-pasteable command, no installer script) and the Windows
+SmartScreen trust step.
 
 ## Use
 

{flexitracker-0.3.0 → flexitracker-0.4.0}/README.md

@@ -15,10 +15,12 @@ Recommended (all platforms):
 uv tool install flexitracker
 ```
 
-Or, on a machine that allows executables, download the standalone
-`flexitracker` / `flexitracker.exe` from the GitHub **Releases** page (it bundles
-its own Python runtime). See `install/README.md` for per-OS auto-start and the
-Windows SmartScreen trust step.
+Or, on a machine that allows executables, download the standalone build from
+the GitHub **Releases** page (it bundles its own Python runtime): one binary
+on Linux, or on Windows two — a console one for `login`/`test` and a
+windowless one for auto-start. See `install/README.md` for per-OS auto-start
+(a single copy-pasteable command, no installer script) and the Windows
+SmartScreen trust step.
 
 ## Use
 

flexitracker-0.4.0/install/README.md

@@ -0,0 +1,95 @@
+# Installing the FlexiTracker daemon
+
+The daemon is a pure-Python program. The **recommended** install on every OS is
+with [uv](https://docs.astral.sh/uv/) — no administrator rights, no compiler, and
+it works on managed machines that block unsigned executables and installer
+scripts alike.
+
+Every auto-start step below is a single command you run yourself and can read
+before pasting — **no installer script (PowerShell, VBScript, or shell) is
+downloaded or executed for you.** This also renders on the web app's Machines
+tab, matching your detected OS, with a copy button.
+
+## Recommended: uv (all platforms)
+
+```bash
+uv tool install flexitracker
+flexitracker login
+flexitracker test
+```
+
+`login` opens your browser to authorize the machine — sign in, approve, and the
+key lands in the config automatically; you never see or paste it. On a
+headless or scripted box, use `flexitracker login --key <YOUR_ACCESS_KEY>`
+with a key from the web UI's "Add machine" button instead.
+
+`uv tool install` places two commands on `PATH`: the console `flexitracker`
+used above (for `login`/`test`, where you want to see the output), and a
+second, windowless `flexitracker-daemon` command for auto-start below — it runs
+the identical daemon with no console window.
+
+### Auto-start on login
+
+- **Windows** — run this once in `cmd.exe` or PowerShell (no admin rights
+  needed; it only touches your own user's registry):
+
+  ```
+  reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" /v FlexiTracker /t REG_SZ /d "\"%USERPROFILE%\.local\bin\flexitracker-daemon.exe\"" /f
+  ```
+
+  To undo it: `reg delete "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" /v FlexiTracker /f`
+
+- **Linux** — systemd *user* service:
+
+  ```bash
+  mkdir -p ~/.config/systemd/user
+  cp flexitracker.service ~/.config/systemd/user/
+  systemctl --user daemon-reload
+  systemctl --user enable --now flexitracker.service
+  ```
+
+  (`flexitracker.service` is the unit file in this directory — it's a plain
+  declarative unit, not a script.) Check status/logs with
+  `systemctl --user status flexitracker` / `journalctl --user -u flexitracker -f`.
+  If the machine doesn't keep a session open past logout, also run
+  `loginctl enable-linger "$USER"` once so the user service can still start.
+  To undo it: `systemctl --user disable --now flexitracker.service`.
+
+## Alternative: standalone executables (machines that allow exes)
+
+If your machine permits running executables, download from the project's
+GitHub **Releases** page — it bundles its own Python runtime, so nothing else
+is needed. Windows ships **two** executables; use the right one for the job:
+
+| File | Use it for |
+|------|------------|
+| `flexitracker-windows-x86_64.exe` | `login` and `test`, run from a terminal — it has a console, so you see the output. |
+| `flexitracker-daemon-windows-x86_64.exe` | Auto-start only — a windowless build with no console window, ever. |
+
+Linux has one binary, `flexitracker-linux-x86_64`, used for everything.
+
+```bat
+flexitracker-windows-x86_64.exe login
+flexitracker-windows-x86_64.exe test
+```
+
+### Auto-start on login (standalone executable)
+
+Save `flexitracker-daemon-windows-x86_64.exe` somewhere permanent (e.g.
+`%LOCALAPPDATA%\flexitracker\flexitracker-daemon.exe`), then register it the
+same way as the `uv` path, pointed at that path instead:
+
+```
+reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" /v FlexiTracker /t REG_SZ /d "\"<path to flexitracker-daemon-windows-x86_64.exe>\"" /f
+```
+
+On Linux, use the same `flexitracker.service` + `systemctl --user` steps
+above, pointing `ExecStart` at wherever you saved `flexitracker-linux-x86_64`.
+
+### Windows SmartScreen (unsigned executables)
+
+Both standalone executables are **not code-signed**, so Windows SmartScreen may
+warn on first run. To allow one: click **More info → Run anyway**, or
+right-click the file → **Properties** → tick **Unblock** → **OK**. If your
+organization blocks unsigned executables entirely, use the **uv** path above
+instead — it does not run a downloaded executable.

{flexitracker-0.3.0 → flexitracker-0.4.0}/pyproject.toml

@@ -17,6 +17,12 @@ dependencies = []
 [project.scripts]
 flexitracker = "flexitracker.cli:main"
 
+# Windows-subsystem launcher (no console ever) for `uv tool install`, used only
+# for the auto-started background daemon. `login`/`test` use the console
+# `flexitracker` entry point above so their output is visible.
+[project.gui-scripts]
+flexitracker-daemon = "flexitracker.cli:main"
+
 [dependency-groups]
 dev = ["pytest>=8"]
 # Freezing tool for the standalone single-file executable (GitHub Release asset,

{flexitracker-0.3.0 → flexitracker-0.4.0}/src/flexitracker/cli.py

@@ -9,6 +9,7 @@ sends no data), and the default daemon run.
 from __future__ import annotations
 
 import json
+import logging
 import os
 import socket
 import sys
@@ -18,12 +19,16 @@ from typing import Optional
 
 from ._backend import default_backend_url
 from .config import Config
-from .core import machine_descriptor
+from .core import EventKind, machine_descriptor
 from .idle import Sample, platform_source
+from .logging_setup import LOGGER_NAME, configure_logging
 from .login import LoginError, browser_login
 from .outbox import Outbox
 from .sender import SenderError, fetch_thresholds, post_batch, whoami
 from .state_machine import Persisted, StateMachine, Tick
+from .version import get_version
+
+logger = logging.getLogger(LOGGER_NAME)
 
 HELP = """flexitracker — activity tracking daemon
 
@@ -100,8 +105,6 @@ def parse_args(argv: list) -> Args:
         elif arg == "--once":
             a.once = True
         elif arg in ("--version", "-V"):
-            from .version import get_version
-
             print(f"flexitracker {get_version()}")
             sys.exit(0)
         elif arg in ("--help", "-h"):
@@ -138,7 +141,17 @@ def flush(cfg: Config, ob: Outbox) -> None:
         post_batch(cfg.backend_url, cfg.access_key, batch)
         ob.ack()
     except SenderError as e:
-        print(f"flush deferred ({ob.pending_len()} pending): {e}", file=sys.stderr)
+        logger.warning("flush deferred (%d pending): %s", ob.pending_len(), e)
+
+
+def log_events(events: list) -> None:
+    """INFO for a work/idle span start or end; DEBUG for a heartbeat, so a
+    default-level log stays small no matter how long the daemon runs."""
+    for e in events:
+        if e["kind"] == EventKind.HEARTBEAT:
+            logger.debug("heartbeat ts=%s", e["ts"])
+        else:
+            logger.info("%s ts=%s", e["kind"], e["ts"])
 
 
 def load_state(path: Path) -> Optional[Persisted]:
@@ -253,12 +266,29 @@ def run(argv: list) -> int:
         return 1
     cfg.save(config_path)
 
+    configure_logging(config_path)
+    machine = machine_desc()
+    logger.info(
+        "flexitracker %s starting (backend=%s, config=%s)", get_version(), cfg.backend_url, config_path
+    )
+    logger.info("machine: hostname=%s os=%s", machine["hostname"], machine["os"])
+
+    try:
+        return _run_daemon(args, cfg, config_path, machine)
+    except Exception:
+        # No console to see a traceback on under the windowed/no-console build
+        # — the rotating log file is the only place this can land.
+        logger.exception("daemon loop crashed")
+        return 1
+
+
+def _run_daemon(args: Args, cfg: Config, config_path: Path, machine: dict) -> int:
     # Refresh thresholds; fall back to cached/defaults offline.
     try:
         cfg.thresholds = fetch_thresholds(cfg.backend_url, cfg.access_key, cfg.thresholds.poll_sec)
         cfg.save(config_path)
     except SenderError as e:
-        print(f"warning: using cached thresholds ({e})", file=sys.stderr)
+        logger.warning("using cached thresholds (%s)", e)
     thresholds = cfg.thresholds.to_thresholds()
 
     state_path = config_path.with_name("state.json")
@@ -266,8 +296,8 @@ def run(argv: list) -> int:
     ob = Outbox.open(outbox_path)
     dropped = ob.trim_expired(now_ms())
     if dropped > 0:
-        print(f"dropped {dropped} outbox event(s) older than the backend edit window", file=sys.stderr)
-    ob.set_machine(machine_desc())
+        logger.warning("dropped %d outbox event(s) older than the backend edit window", dropped)
+    ob.set_machine(machine)
 
     if args.simulate:
         return simulate(cfg, ob)
@@ -275,25 +305,29 @@ def run(argv: list) -> int:
     persisted = load_state(state_path) or Persisted()
     sm = StateMachine(thresholds, persisted)
 
-    ob.append(sm.recover(now_ms()))
+    recovered = sm.recover(now_ms())
+    log_events(recovered)
+    ob.append(recovered)
     save_state(state_path, sm.p)
     flush(cfg, ob)
 
     try:
         source = platform_source()
     except OSError as e:
-        print(f"error: idle source: {e}", file=sys.stderr)
+        logger.error("idle source: %s", e)
         return 1
 
     last_mono: Optional[float] = None
     while True:
         s: Sample = source.sample()
+        logger.debug("sample idle_ms=%s locked=%s", s.idle_ms, s.locked)
         mono_now = time.monotonic()
         mono_elapsed_ms = None if last_mono is None else int((mono_now - last_mono) * 1000)
         last_mono = mono_now
         events = sm.step(
             Tick(now=now_ms(), idle_ms=s.idle_ms, locked=s.locked, mono_elapsed_ms=mono_elapsed_ms)
         )
+        log_events(events)
         ob.append(events)
         save_state(state_path, sm.p)
         flush(cfg, ob)

flexitracker-0.4.0/src/flexitracker/logging_setup.py

@@ -0,0 +1,64 @@
+"""Rotating file logging for the background daemon loop.
+
+Only the daemon loop uses this — `login`, `test`, `--version`, `--help`, and
+`--simulate` stay on plain `print()`, since those are explicit, human-invoked,
+foreground commands, not the silent background loop this exists for.
+
+INFO records lifecycle events only (startup, the detected machine descriptor,
+work/idle span start+end). Per-tick sampling and heartbeats are DEBUG-only, so
+a default-level log stays small no matter how long the daemon runs. A
+`StreamHandler` on `stderr` is added only when `stderr` is actually attached
+(interactive `login`/`test`/foreground runs) — a `--windowed` frozen build has
+no console, so `sys.stderr` is `None` there and must not be touched.
+"""
+
+from __future__ import annotations
+
+import logging
+import logging.handlers
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+LOGGER_NAME = "flexitracker"
+
+# ~8MB worst case (current + 3 backups) — generous for INFO-level lifecycle
+# logging across many days, bounded enough to never become a disk concern.
+MAX_BYTES = 2_000_000
+BACKUP_COUNT = 3
+
+
+def configure_logging(
+    config_path: Path,
+    level: Optional[str] = None,
+    max_bytes: int = MAX_BYTES,
+    backup_count: int = BACKUP_COUNT,
+) -> logging.Logger:
+    """Attach a rotating file handler (plus an optional stderr mirror) to the
+    module logger. Idempotent: a second call is a no-op so re-entrant daemon
+    code paths and tests can call it freely."""
+    logger = logging.getLogger(LOGGER_NAME)
+    if logger.handlers:
+        return logger
+
+    resolved_level = (level or os.environ.get("FLEXITRACKER_LOG_LEVEL") or "INFO").upper()
+    logger.setLevel(resolved_level)
+
+    log_path = config_path.with_name("flexitracker.log")
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    file_handler = logging.handlers.RotatingFileHandler(
+        log_path, maxBytes=max_bytes, backupCount=backup_count, encoding="utf-8"
+    )
+    file_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+    logger.addHandler(file_handler)
+
+    # None under a --windowed frozen build (no console attached) — never a
+    # closed/broken stream, so this is the correct, sufficient guard.
+    if sys.stderr is not None:
+        stream_handler = logging.StreamHandler(sys.stderr)
+        stream_handler.setLevel(logging.WARNING)
+        stream_handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
+        logger.addHandler(stream_handler)
+
+    return logger

{flexitracker-0.3.0 → flexitracker-0.4.0}/src/flexitracker/outbox.py

@@ -9,10 +9,15 @@ either implementation can resume the other's outbox (proven by the harness).
 from __future__ import annotations
 
 import json
+import logging
 import os
 from pathlib import Path
 from typing import Optional
 
+from .logging_setup import LOGGER_NAME
+
+logger = logging.getLogger(LOGGER_NAME)
+
 # Events older than the backend's edit window are rejected on arrival; holding
 # them only grows the file.
 MAX_EVENT_AGE_MS = 120 * 86_400_000
@@ -49,7 +54,7 @@ class Outbox:
             except OSError:
                 pass
             extra = f" (previous contents kept at {aside})" if moved else ""
-            print(f"warning: outbox unreadable ({e}); starting with an empty queue{extra}")
+            logger.warning("outbox unreadable (%s); starting with an empty queue%s", e, extra)
             return cls(path, 0, [], None)
         return cls(
             path,

{flexitracker-0.3.0 → flexitracker-0.4.0}/src/flexitracker/sender.py

@@ -14,6 +14,14 @@ from dataclasses import dataclass
 from typing import Optional
 
 from .config import ThresholdCfg
+from .version import get_version
+
+# Cloudflare's bot-fight mode blocks urllib's default "Python-urllib/x.y" User-
+# Agent outright (HTTP 403, body "error code: 1010") on every route, Access-
+# bypassed or not — it's a zone-level WAF check, unrelated to Access. Every
+# real request this client makes needs a non-default UA or it never leaves
+# the edge.
+USER_AGENT = f"flexitracker-daemon/{get_version()}"
 
 
 class SenderError(Exception):
@@ -22,7 +30,7 @@ class SenderError(Exception):
 
 def _request(url: str, key: Optional[str], method: str, body: Optional[dict]) -> dict:
     data = None
-    headers = {}
+    headers = {"user-agent": USER_AGENT}
     if key:
         headers["authorization"] = f"Bearer {key}"
     if body is not None:

{flexitracker-0.3.0 → flexitracker-0.4.0}/tests/test_cli.py

@@ -1,7 +1,9 @@
+import logging
+
 import pytest
 
 from flexitracker import cli as cli_mod
-from flexitracker.cli import parse_args, run
+from flexitracker.cli import log_events, parse_args, run
 from flexitracker.config import Config
 from flexitracker.login import LoginError
 
@@ -80,3 +82,19 @@ def test_login_browser_failure_writes_no_config(tmp_path, monkeypatch):
     rc = run(["login", "--backend-url", "https://backend.example", "--config", str(config_path)])
     assert rc == 1
     assert not config_path.exists()
+
+
+def test_log_events_logs_spans_at_info_and_heartbeat_at_debug(caplog):
+    events = [
+        {"ts": 1000, "kind": "active"},
+        {"ts": 2000, "kind": "heartbeat"},
+        {"ts": 3000, "kind": "idle"},
+    ]
+    with caplog.at_level(logging.DEBUG, logger="flexitracker"):
+        log_events(events)
+    info_messages = [r.message for r in caplog.records if r.levelno == logging.INFO]
+    debug_messages = [r.message for r in caplog.records if r.levelno == logging.DEBUG]
+    assert any("active" in m for m in info_messages)
+    assert any("idle" in m for m in info_messages)
+    assert any("heartbeat" in m for m in debug_messages)
+    assert not any("heartbeat" in m for m in info_messages)

flexitracker-0.4.0/tests/test_logging_setup.py

@@ -0,0 +1,83 @@
+import logging
+
+import pytest
+
+from flexitracker.logging_setup import LOGGER_NAME, configure_logging
+
+
+@pytest.fixture(autouse=True)
+def _reset_logger():
+    # configure_logging is idempotent (no-op once handlers exist), so each
+    # test needs a clean slate rather than reusing the process-wide singleton.
+    logger = logging.getLogger(LOGGER_NAME)
+    logger.handlers.clear()
+    logger.setLevel(logging.NOTSET)
+    yield
+    logger.handlers.clear()
+    logger.setLevel(logging.NOTSET)
+
+
+def _log_path(tmp_path):
+    return tmp_path / "flexitracker.log"
+
+
+def test_writes_to_a_rotating_file_next_to_config(tmp_path):
+    config_path = tmp_path / "config.toml"
+    logger = configure_logging(config_path)
+    logger.info("hello")
+    for h in logger.handlers:
+        h.flush()
+    assert "hello" in _log_path(tmp_path).read_text(encoding="utf-8")
+
+
+def test_default_level_is_info_debug_is_suppressed(tmp_path):
+    config_path = tmp_path / "config.toml"
+    logger = configure_logging(config_path)
+    logger.info("span start")
+    logger.debug("heartbeat tick")
+    for h in logger.handlers:
+        h.flush()
+    text = _log_path(tmp_path).read_text(encoding="utf-8")
+    assert "span start" in text
+    assert "heartbeat tick" not in text
+
+
+def test_env_var_raises_level_to_debug(tmp_path, monkeypatch):
+    monkeypatch.setenv("FLEXITRACKER_LOG_LEVEL", "DEBUG")
+    config_path = tmp_path / "config.toml"
+    logger = configure_logging(config_path)
+    logger.debug("heartbeat tick")
+    for h in logger.handlers:
+        h.flush()
+    assert "heartbeat tick" in _log_path(tmp_path).read_text(encoding="utf-8")
+
+
+def test_rotates_past_the_size_limit(tmp_path):
+    config_path = tmp_path / "config.toml"
+    logger = configure_logging(config_path, max_bytes=500, backup_count=2)
+    for i in range(200):
+        logger.info("padding line number %d to force rotation", i)
+    assert _log_path(tmp_path).exists()
+    assert (tmp_path / "flexitracker.log.1").exists()
+
+
+def test_no_stderr_handler_when_stderr_is_absent(tmp_path, monkeypatch):
+    # Mirrors a --windowed frozen build, where sys.stderr is None.
+    monkeypatch.setattr("flexitracker.logging_setup.sys.stderr", None)
+    config_path = tmp_path / "config.toml"
+    logger = configure_logging(config_path)
+    assert len(logger.handlers) == 1
+
+
+def test_stderr_handler_present_when_stderr_is_attached(tmp_path):
+    config_path = tmp_path / "config.toml"
+    logger = configure_logging(config_path)
+    assert len(logger.handlers) == 2
+
+
+def test_second_call_is_a_no_op(tmp_path):
+    config_path = tmp_path / "config.toml"
+    configure_logging(config_path)
+    handlers_after_first = list(logging.getLogger(LOGGER_NAME).handlers)
+    configure_logging(config_path)
+    assert logging.getLogger(LOGGER_NAME).handlers == handlers_after_first

flexitracker-0.3.0/install/README.md

@@ -1,43 +0,0 @@
-# Installing the FlexiTracker daemon
-
-The daemon is a pure-Python program. The **recommended** install on every OS is
-with [uv](https://docs.astral.sh/uv/) — no administrator rights, no compiler, and
-it works on managed machines that block unsigned executables.
-
-## Recommended: uv (all platforms)
-
-```bash
-uv tool install flexitracker
-flexitracker login
-flexitracker test
-```
-
-`login` opens your browser to authorize the machine — sign in, approve, and the
-key lands in the config automatically; you never see or paste it. On a
-headless or scripted box, use `flexitracker login --key <YOUR_ACCESS_KEY>`
-with a key from the web UI's "Add machine" button instead.
-
-Then enable auto-start on login:
-
-- **Linux:** `./install.sh` (installs a systemd *user* service).
-- **Windows:** `powershell -ExecutionPolicy Bypass -File install.ps1` (registers a
-  login task).
-
-## Alternative: standalone executable (machines that allow exes)
-
-If your machine permits running executables, download the standalone
-`flexitracker.exe` (Windows) or `flexitracker` (Linux) from the project's GitHub
-**Releases** page — it bundles its own Python runtime, so nothing else is needed.
-
-```bat
-flexitracker.exe login
-flexitracker.exe test
-```
-
-### Windows SmartScreen (unsigned executable)
-
-The standalone executable is **not code-signed**, so Windows SmartScreen may warn
-on first run. To allow it: click **More info → Run anyway**, or right-click the
-file → **Properties** → tick **Unblock** → **OK**. If your organization blocks
-unsigned executables entirely, use the **uv** path above instead — it does not run
-an executable.

flexitracker-0.3.0/install/install.ps1

@@ -1,35 +0,0 @@
-# FlexiTracker (Windows) — install the daemon into your user profile with uv
-# (no admin, no compiler) and register a login task so it starts on sign-in.
-#
-# This is the recommended path on managed machines that block unsigned
-# executables but permit a user-scope Python toolchain. If your machine allows
-# executables, you can instead download the standalone flexitracker.exe from the
-# GitHub Releases page (see install/README.md for the SmartScreen trust step).
-
-$ErrorActionPreference = "Stop"
-
-if (-not (Get-Command uv -ErrorAction SilentlyContinue)) {
-    Write-Error "uv is required: https://docs.astral.sh/uv/ (run: irm https://astral.sh/uv/install.ps1 | iex)"
-    exit 1
-}
-
-Write-Host "Installing flexitracker with uv…"
-uv tool install --upgrade flexitracker
-
-$bin = (Get-Command flexitracker -ErrorAction SilentlyContinue).Source
-if (-not $bin) { $bin = Join-Path $env:USERPROFILE ".local\bin\flexitracker.exe" }
-
-# Authorize this machine if not already configured.
-$cfg = Join-Path $env:APPDATA ".config\flexitracker\config.toml"
-if (-not (Test-Path $cfg)) {
-    Write-Host "`nAuthorize this machine (paste the access key from the web app):"
-    & $bin configure
-}
-
-# Register a login task that starts the daemon windowless.
-$action  = New-ScheduledTaskAction -Execute $bin
-$trigger = New-ScheduledTaskTrigger -AtLogOn
-$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -Hidden
-Register-ScheduledTask -TaskName "FlexiTracker" -Action $action -Trigger $trigger -Settings $settings -Force | Out-Null
-
-Write-Host "`nInstalled and registered to start on login. Check with:  flexitracker test"

flexitracker-0.3.0/install/install.sh

@@ -1,35 +0,0 @@
-#!/bin/sh
-# FlexiTracker (Linux) — install the daemon into your user profile with uv
-# (no admin, no compiler) and enable it as a systemd user service on login.
-set -e
-
-if ! command -v uv >/dev/null 2>&1; then
-    echo "uv is required: https://docs.astral.sh/uv/  (curl -LsSf https://astral.sh/uv/install.sh | sh)" >&2
-    exit 1
-fi
-
-echo "Installing flexitracker with uv…"
-uv tool install --upgrade flexitracker
-
-BIN="$HOME/.local/bin/flexitracker"
-if [ ! -x "$BIN" ]; then
-    # Fall back to whatever uv put on PATH.
-    BIN="$(command -v flexitracker || echo "$BIN")"
-fi
-
-# Authorize this machine if not already configured.
-if [ ! -f "$HOME/.config/flexitracker/config.toml" ]; then
-    echo
-    echo "Authorize this machine (paste the access key from the web app):"
-    "$BIN" configure
-fi
-
-# Install + enable the user service.
-mkdir -p "$HOME/.config/systemd/user"
-cp "$(dirname "$0")/flexitracker.service" "$HOME/.config/systemd/user/flexitracker.service"
-systemctl --user daemon-reload
-systemctl --user enable --now flexitracker.service
-
-echo
-echo "Installed and started. Check with:  flexitracker test"
-echo "Auto-starts on login. (You may need: loginctl enable-linger \"$USER\")"