cdx-manager 0.21.5 → 0.22.0

package/src/status_view.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timedelta
+from datetime import datetime
 from decimal import ROUND_HALF_UP, Decimal, InvalidOperation
 
 from .cli_render import (
@@ -10,6 +10,7 @@ from .cli_render import (
     _style_pct,
 )
 from .session_ranking import rank_sessions
+from .session_status import reset_iso
 
 RESET_COUNTDOWN_SAFETY_SECONDS = 60
 PRIORITY_EMPTY_AVAILABLE_THRESHOLD = 5
@@ -339,32 +340,21 @@ def _parse_reset_timestamp(value):
     if not value:
         return None
     text = str(value).strip()
+    # A year-less display ("Dec 31 23:00") becomes ISO first: reset_iso picks
+    # the year closest to now and the offset valid on that date, so neither a
+    # new-year wrap nor a DST change shifts the reset.
+    display = reset_iso(text)
+    if display is not None:
+        if "T" not in display:
+            return None  # a reset with no time of day has no countdown
+        text = display
     try:
         parsed = datetime.fromisoformat(text.replace("Z", "+00:00"))
-        if parsed.tzinfo is None:
-            parsed = parsed.replace(tzinfo=datetime.now().astimezone().tzinfo)
-        return parsed.timestamp()
     except (TypeError, ValueError):
-        pass
-    now = datetime.now().astimezone()
-    parsed = None
-    # Parse with an explicit year: strptime's implicit 1900 rejects "Feb 29",
-    # and the current year may not hold the date at all around new year.
-    for year in (now.year, now.year + 1):
-        try:
-            parsed = datetime.strptime(f"{year} {text}", "%Y %b %d %H:%M").replace(tzinfo=now.tzinfo)
-            break
-        except (TypeError, ValueError):
-            continue
-    if parsed is None:
         return None
-    # A year-less date nearly a year in the past is a year wrap ("Jan 2"
-    # rendered on Dec 31), not a reset that passed months ago.
-    if parsed < now - timedelta(days=182):
-        try:
-            parsed = parsed.replace(year=parsed.year + 1)
-        except ValueError:
-            pass
+    if parsed.tzinfo is None:
+        # Naive means local; astimezone() resolves the offset for that date.
+        parsed = parsed.astimezone()
     return parsed.timestamp()
 
 
@@ -390,11 +380,21 @@ def _format_status_detail(row, use_color=False):
         f"{_style('Reset expiry:', '1', use_color)} {_style_reset_time(_nearest_reset_expiry(row), use_color)}",
         f"{_style('5h reset:', '1', use_color)} {_style_reset_time(row.get('reset_5h_at'), use_color)}",
         f"{_style('Week reset:', '1', use_color)} {_style_reset_time(row.get('reset_week_at'), use_color)}",
+        *([f"{_style('Runs out:', '1', use_color)} {_style(_format_runs_out(row['runs_out_at_iso']), '33', use_color)}"] if row.get("runs_out_at_iso") else []),
         f"{_style('Updated:', '1', use_color)} {_dim(_format_relative_age(row.get('updated_at')), use_color)}",
     ]
     return "\n".join(lines)
 
 
+def _format_runs_out(iso):
+    """`~16:20 at this pace` (or with the date when it is not today)."""
+    from datetime import datetime
+
+    when = datetime.fromisoformat(iso).astimezone()
+    stamp = when.strftime("%H:%M") if when.date() == datetime.now().astimezone().date() else when.strftime("%b %d %H:%M")
+    return f"~{stamp} at this pace"
+
+
 def _nearest_reset_expiry(row):
     values = [credit.get("expires_at") for credit in row.get("reset_credits") or [] if credit.get("expires_at")]
     return min(values, key=lambda value: _parse_reset_timestamp(value) or float("inf")) if values else None

package/src/tray_autostart.py

@@ -18,8 +18,27 @@ RUN_KEY = r"HKCU\Software\Microsoft\Windows\CurrentVersion\Run"
 RUN_VALUE = "CDXTray"
 
 
+def _operator_home():
+    """The operator's real home from passwd. Inside a cdx session HOME is the
+    profile home, where launchd and the XDG autostart never look."""
+    try:
+        import pwd
+
+        return pwd.getpwuid(os.getuid()).pw_dir
+    except (ImportError, KeyError):
+        return None
+
+
 def _home(env):
-    return env.get("HOME") or os.path.expanduser("~")
+    return _operator_home() or env.get("HOME") or os.path.expanduser("~")
+
+
+def _desktop_exec(executable):
+    """Quote one argument per the desktop-entry spec: backslash-escape the four
+    reserved characters inside double quotes, then apply the string-value escape
+    to backslashes, and double `%` so it is not read as a field code."""
+    quoted = "".join("\\" + c if c in '"`$\\' else c for c in executable)
+    return '"' + quoted.replace("\\", "\\\\").replace("%", "%%") + '"'
 
 
 def artifact_path(env=None, system=None):
@@ -86,7 +105,7 @@ def enable(executable, env=None, system=None, run=None):
         with open(path, "w", encoding="utf-8") as handle:
             handle.write(
                 "[Desktop Entry]\nType=Application\nName=CDX Tray\n"
-                f"Exec={executable}\nX-GNOME-Autostart-enabled=true\n"
+                f"Exec={_desktop_exec(executable)}\nX-GNOME-Autostart-enabled=true\n"
             )
     return path
 

package/src/tray_events.py

@@ -24,6 +24,8 @@ import json
 import os
 import time
 
+from .errors import CdxError
+
 SCHEMA_VERSION = 1
 # The tray heartbeats once per poll: 30s native, 60s across WSL. This window has
 # to clear the slowest of those with room for a late tick, or a live tray reads
@@ -130,12 +132,13 @@ def publish(base_dir, title, message, kind="complete", now=None, event_id=None,
         path = events_path(base_dir)
         os.makedirs(os.path.dirname(path), exist_ok=True)
         line = json.dumps(event, ensure_ascii=False) + "\n"
-        # O_APPEND makes this atomic against other hooks firing at the same
-        # instant, which a read-modify-write of a JSON array would not be.
-        with open(path, "a", encoding="utf-8") as handle:
+        # O_APPEND keeps concurrent hooks apart; the lock keeps this append
+        # out of acknowledge()'s read-and-replace, which would otherwise
+        # overwrite it and lose the notification.
+        with _spool_lock(path), open(path, "a", encoding="utf-8") as handle:
             handle.write(line)
         return True
-    except OSError:
+    except (OSError, CdxError):
         return False
 
 
@@ -171,6 +174,11 @@ def read_events(base_dir, include_acknowledged=False):
     return events[-MAX_SPOOLED_EVENTS:]
 
 
+# A hook must never stall an agent's turn on this lock; giving up only means
+# the alert is delivered directly instead.
+SPOOL_LOCK_TIMEOUT_SECONDS = 2
+
+
 def acknowledge(base_dir, ids, now=None):
     """Mark events consumed, idempotently, and compact when it is worth it.
 
@@ -183,6 +191,17 @@ def acknowledge(base_dir, ids, now=None):
     if not wanted:
         return {"acknowledged": 0, "compacted": False}
 
+    with _spool_lock(events_path(base_dir)):
+        return _acknowledge_locked(base_dir, wanted, now)
+
+
+def _spool_lock(path):
+    from .run_registry import _registry_lock
+
+    return _registry_lock(path, timeout_seconds=SPOOL_LOCK_TIMEOUT_SECONDS, label="tray events")
+
+
+def _acknowledge_locked(base_dir, wanted, now):
     try:
         with open(events_path(base_dir), encoding="utf-8") as handle:
             lines = handle.readlines()

package/src/tray_instance.py

@@ -2,7 +2,9 @@
 
 The companion owns the lock; this only reads it. Both sides must agree on the
 path, which is why the rule is written in one sentence in both places: the
-per-user temporary directory, then `cdx-tray/companion.pid`.
+per-user directory (LOCALAPPDATA on Windows, TMPDIR on macOS, XDG_RUNTIME_DIR on
+Linux, else the temp dir with the uid in the folder name), then
+`cdx-tray/companion.pid`.
 """
 import os
 import platform
@@ -13,8 +15,15 @@ from .session_helpers import _process_is_running
 
 def lock_path(env=None):
     env = os.environ if env is None else env
-    if platform.system() == "Windows":
+    system = platform.system()
+    if system == "Windows":
         base = env.get("LOCALAPPDATA") or tempfile.gettempdir()
+    elif system == "Linux":
+        # /tmp is shared on Linux: one user's lock would block another's tray.
+        if env.get("XDG_RUNTIME_DIR"):
+            return os.path.join(env["XDG_RUNTIME_DIR"], "cdx-tray", "companion.pid")
+        base = env.get("TMPDIR") or tempfile.gettempdir()
+        return os.path.join(base, f"cdx-tray-{os.getuid()}", "companion.pid")
     else:
         base = env.get("TMPDIR") or tempfile.gettempdir()
     return os.path.join(base, "cdx-tray", "companion.pid")

package/src/tray_logics.py

@@ -88,7 +88,7 @@ def _status(env=None, runner=None, executable=None, directories=None):
         try:
             completed = (runner or subprocess.run)(
                 [executable, "status", "--format", "json"], capture_output=True,
-                text=True, timeout=ADAPTER_TIMEOUT_SECONDS, check=False, **({"cwd": root} if root else {}),
+                text=True, encoding="utf-8", errors="replace", timeout=ADAPTER_TIMEOUT_SECONDS, check=False, **({"cwd": root} if root else {}),
             )
             payload = json.loads(completed.stdout) if getattr(completed, "returncode", 1) == 0 else None
         except (OSError, subprocess.SubprocessError, TypeError, ValueError):

package/src/update_all.py

@@ -33,7 +33,7 @@ def _which(command, env):
 def _run(command, env, runner=None, timeout=15):
     runner = runner or subprocess.run
     try:
-        result = runner(command, env=env, capture_output=True, text=True, check=False, timeout=timeout)
+        result = runner(command, env=env, capture_output=True, text=True, encoding="utf-8", errors="replace", check=False, timeout=timeout)
     except (OSError, subprocess.TimeoutExpired) as error:
         return {"returncode": 1, "stdout": "", "stderr": str(error)}
     if isinstance(result, dict):

package/src/update_check.py

@@ -143,7 +143,7 @@ def _installed_logics_manager_version(env=None, runner=None):
         result = runner(
             [executable, "--version"],
             capture_output=True,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             timeout=2,
             env=env,
         )

package/src/update_manager.py

@@ -43,7 +43,7 @@ def _is_git_dirty(package_root):
         result = subprocess.run(
             ["git", "-C", str(package_root), "status", "--porcelain"],
             capture_output=True,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             check=False,
         )
     except FileNotFoundError as error:
@@ -140,11 +140,14 @@ def _build_python_step(target_version):
     }
 
 
-def _build_npm_step(target_version):
+def _build_npm_step(target_version, env=None):
     spec = f"cdx-manager@{target_version}" if target_version else "cdx-manager@latest"
+    # Resolved here because Windows ships npm as npm.cmd, which a shell-less
+    # spawn of "npm" never finds.
+    npm = shutil.which("npm", path=(env or os.environ).get("PATH")) or "npm"
     return {
         "label": "npm global upgrade",
-        "command": ["npm", "install", "-g", spec],
+        "command": [npm, "install", "-g", spec],
         "cwd": None,
         "env": {},
     }
@@ -162,7 +165,7 @@ def build_update_plan(target_version=None, package_root=None, env=None, prefix=N
     elif mode == "python":
         steps = [_build_python_step(version)]
     elif mode == "npm":
-        steps = [_build_npm_step(version)]
+        steps = [_build_npm_step(version, env)]
     else:
         raise CdxError(
             "Unable to determine how cdx-manager was installed. "
@@ -195,7 +198,10 @@ def run_update_plan(plan, runner=None, env=None):
     for step in plan["steps"]:
         step_env = {**(env or os.environ), **(step.get("env") or {})}
         kwargs = {"cwd": step.get("cwd"), "env": step_env, "check": False}
-        result = runner(step["command"], **kwargs)
+        try:
+            result = runner(step["command"], **kwargs)
+        except OSError as error:
+            result = {"returncode": None, "stdout": "", "stderr": f"could not run {step['command'][0]}: {error}"}
         code = _result_code(result)
         results.append({
             "label": step["label"],
@@ -216,7 +222,11 @@ def _version_check_env(env):
     source = env or os.environ
     allowed = {
         key: source[key]
-        for key in ("PATH", "PATHEXT", "SystemRoot", "COMSPEC", "WINDIR")
+        # The home variables let the child find its home directory: without
+        # USERPROFILE, Windows Python's Path.home() raises and `cdx -v` prints
+        # a traceback instead of the version.
+        for key in ("PATH", "PATHEXT", "SystemRoot", "COMSPEC", "WINDIR",
+                    "HOME", "USERPROFILE", "HOMEDRIVE", "HOMEPATH", "CDX_HOME")
         if source.get(key)
     }
     return allowed
@@ -244,7 +254,7 @@ def verify_updated_command(target_version, runner=None, env=None):
             env=_version_check_env(env),
             check=False,
             capture_output=True,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
         )
     except OSError as error:
         return {