cdx-manager 0.25.5 → 0.25.6

package/README.md

@@ -4,7 +4,7 @@
 
 <br clear="left"/>
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.25.5-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.25.6-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **The right AI coding account, when you need it.** CDX Manager keeps your Codex and Claude accounts in separate profiles, shows which ones have quota, and helps you pick the next usable session from your terminal.
 

package/VERSION

@@ -1 +1 @@
-0.25.5
+0.25.6

package/changelogs/CHANGELOGS_0_25_6.md

@@ -0,0 +1,15 @@
+# CDX Manager 0.25.6
+
+Release date: 2026-11-02
+
+This patch release fixes provider update detection and verifies installed versions after updates.
+
+## Fixes
+
+- Detect advertised provider updaters and version output on both stdout and stderr. After an update, verify the installed version and report failure if it is missing, unchanged, downgraded, or still below the published version. Successful text output shows the version transition, and JSON results include before, after, and latest versions. (#87)
+- Fall back to the latest stable GitHub release when Ollama's vendor API returns an empty, invalid, or failed response. Keep Linux Ollama updates manual, with an explicit maintenance reason. (#87)
+
+## Maintenance
+
+- Record tray companion checksums for v0.25.5. (`b64a372f9ab4abb61f1440943fca19703ad555eb`)
+- Record release archive checksums for v0.25.5. (`1218145eae4201e40b8140e7a94cbcec18454e17`)

package/changelogs/CHANGELOGS_UNRELEASED.md

@@ -2,6 +2,9 @@
 
 ## Truthful workstation updates
 
+- Detect native updater subcommands in both stdout and stderr, including Antigravity's indented `Available subcommands:` help. Verify the installed CLI version after updating, fail unchanged or unverified updates, and expose before/after versions without hiding major upgrades.
+- Fall back from empty or failed Ollama vendor responses (including Linux HTTP 204) to the latest stable `ollama/ollama` GitHub release. Keep Linux updates manual with `update_available`, a null command, and a service-safety reason; never replace a potentially active binary or restart models automatically.
+
 - Verify latest versions from npm, RTK GitHub releases, and Antigravity/Ollama vendor update endpoints with short read-only probes. Report `unknown` on unavailable evidence; reserve `up_to_date` for identical known versions, including Ponytail revisions.
 - Preserve the existing JSON fields and `update_available` status, show uncertainty and manual-update reasons in text, and apply only supported native commands or verified Homebrew package upgrades. Cover matching/outdated versions, source failures, missing tools, and command execution with faked sources.
 

package/checksums/release-archives.json

@@ -738,6 +738,17 @@
         "x86_64-pc-windows-msvc": "8e2c1925f025a7227ef909f27e8b4696c03bb5a86e0c61c989da6a942b5638a6",
         "x86_64-unknown-linux-musl": "9ae1164abc3ff4b30d25c44696569855138f8ac0e3b6e1c3451c716d20f221fa"
       }
+    },
+    "v0.25.5": {
+      "github_tarball_sha256": "4a2ece21e32f59a84d8bc7b2a565817c6c90bb314f179319bc19cf85a0c71a60",
+      "github_zip_sha256": "959de4dca501fd53c937f4045936b12acbea58d255a4e3cae510ec82a230bef8",
+      "tray_assets": {
+        "aarch64-apple-darwin": "727c4ded1ee4d9d8ed9853badcb10efd1cc76bd6dcd6012b6739920d42e6273c",
+        "aarch64-unknown-linux-musl": "9270224db6be83d4a4787f9b523a6fa059267f56ed1cf12f022f65bf68c0474f",
+        "x86_64-apple-darwin": "10c555671cdeb3ce4c0372f6f8a48e6cfeac9132e980c466fe5a8978dc1a2862",
+        "x86_64-pc-windows-msvc": "85945b30580cb82c64ece94652ae0633a6156dfd85e02108c0d4b7676cab9911",
+        "x86_64-unknown-linux-musl": "7c5a23938b84c5952be71b5956ed3167c218d05ce661940b0c86f2dde2d8221f"
+      }
     }
   }
 }

package/docs/cli.md

@@ -567,19 +567,33 @@ an installed server, not the latest published release, and is not used.
 Antigravity Hub and IDE 2 have separate feeds and are not substituted for `agy`.
 HTTP and read-only CLI probes have a five-second timeout; source failures leave
 `latest_version: null` and `status: unknown`. Ponytail also reports `unknown`
-when its remote revision is unavailable. An empty Ollama response (including
-HTTP 204 without a published version) remains `unknown`; a different platform
-is never substituted to manufacture a match.
+when its remote revision is unavailable. An empty, failed, or invalid Ollama
+response (including Linux HTTP 204) falls back to the latest stable GitHub
+release for `ollama/ollama`. If that source also fails, status is `unknown`;
+a different platform's vendor response is never substituted.
 
 For an outdated tool, CDX uses a native update command advertised by its
-`--help` (including Claude and Antigravity when available), Codex's updater,
+`--help` on either stdout or stderr (including Claude, Antigravity, and RTK
+when available), Codex's updater,
 or Homebrew only when the resolved executable belongs to a Caskroom/Cellar
 package. An outdated tool without such a path retains `update_available`,
 `update_command: null`, and a human-readable `reason`; it requires the vendor's
-manual update mechanism. Source uncertainty never schedules a guessed install.
+manual update mechanism. On Linux, Ollama always retains `update_available`
+with `update_command: null` and an explicit maintenance reason: its installer
+writes system paths and may restart a service. A binary in `~/.local/bin` can
+also serve running models, so CDX neither replaces it nor restarts services.
+Arrange a manual maintenance window. Source uncertainty never schedules a guessed install.
 The text table shows `UNKNOWN` and the reason, and an empty action list makes
 no claim that all tools are current. JSON consumers, including external
 remote-ops auto-update scripts, should inspect statuses separately from successful
 command execution: exit code zero means no attempted action failed, not that
 every installed tool was verified current. With `--yes`, the returned plan is the
 pre-update inventory; `results` records attempted actions and their exit codes.
+
+After each successful tool update command, CDX probes the CLI version again.
+An unchanged, unreadable, downgraded, or still older-than-published version
+makes the action fail, even if the updater exited zero. Successful text output
+shows the before/after versions, including major upgrades. JSON keeps the
+pre-update plan and existing result fields; tool verification adds
+`version_before`, `version_after`, and `latest_version` to successful-command
+results, plus `reason` and a nonzero `returncode` if verification fails.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.25.5",
+  "version": "0.25.6",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.25.5"
+version = "0.25.6"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9.2"

package/src/commands/maintenance.py

@@ -52,7 +52,8 @@ def _format_update_all_result(result, use_color=False):
     if result.get("skipped"):
         return _warn(f"skipped: {result['name']} (blocked by {result['blocked_by']})", use_color)
     if result.get("returncode") == 0:
-        return _success(f"done: {result['name']}", use_color)
+        versions = f" ({result['version_before']} -> {result['version_after']})" if "version_after" in result else ""
+        return _success(f"done: {result['name']}{versions}", use_color)
     detail = str(result.get("stderr") or result.get("stdout") or "No error output.").strip().replace("\n", " ")
     detail = detail[-500:]
     command = shlex.join(result.get("command") or [])

package/src/update_all.py

@@ -56,7 +56,7 @@ def _version(command, env, runner):
     result = _run([command, "--version"], env, runner, timeout=_SOURCE_TIMEOUT)
     if result["returncode"]:
         return None
-    text = (result["stdout"] or result["stderr"] or "").strip()
+    text = "\n".join((result["stdout"] or "", result["stderr"] or "")).strip()
     # Ollama can print the server version before the CLI version.
     client = re.search(r"client version is (\S+)", text)
     match = client or re.search(r"\b(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b", text)
@@ -85,9 +85,19 @@ def _latest_version(name):
         if name == PROVIDER_OLLAMA:
             arch = {"x86_64": "amd64", "aarch64": "arm64"}.get(platform.machine().lower(), platform.machine().lower())
             query = urlencode({"os": platform.system().lower(), "arch": arch, "version": "0.0.0"})
-            release = _fetch_json(f"https://ollama.com/api/update?{query}")
-            # The vendor updater extracts the release tag from the artifact URL.
-            return _parse_version(os.path.basename(os.path.dirname(urlparse(release["url"]).path)))
+            try:
+                release = _fetch_json(f"https://ollama.com/api/update?{query}")
+                # The vendor updater extracts the release tag from the artifact URL.
+                version = _parse_version(os.path.basename(os.path.dirname(urlparse(release["url"]).path)))
+                if version:
+                    return version
+            except Exception:
+                # Linux can return HTTP 204 with no JSON body.
+                pass
+            release = _fetch_json("https://api.github.com/repos/ollama/ollama/releases/latest")
+            if release.get("draft") or release.get("prerelease"):
+                return None
+            return _parse_version(release["tag_name"])
     except Exception:
         # A failed or changed source is uncertainty, never evidence of currency.
         return None
@@ -101,6 +111,8 @@ def _newer(latest, current):
 
 
 def _native_update_command(name, command, path, env, runner):
+    if name == PROVIDER_OLLAMA and platform.system().lower() == "linux":
+        return None
     real_path = os.path.realpath(path)
     cask = re.search(r"/Caskroom/([^/]+)/", real_path)
     formula = re.search(r"/Cellar/([^/]+)/", real_path)
@@ -111,7 +123,7 @@ def _native_update_command(name, command, path, env, runner):
         return [command, "update"]
     help_result = _run([command, "--help"], env, runner, timeout=_SOURCE_TIMEOUT)
     if help_result["returncode"] == 0:
-        help_text = help_result["stdout"]
+        help_text = "\n".join((help_result["stdout"] or "", help_result["stderr"] or ""))
         for subcommand in ("self-update", "update", "--update"):
             if re.search(r"(?m)^\s*" + re.escape(subcommand) + r"(?:\s|$)", help_text):
                 return [command, subcommand]
@@ -153,6 +165,9 @@ def collect_update_all_plan(service, env=None, runner=None):
                     steps.append({"name": name, "command": item["update_command"], "env": {}})
                 else:
                     item["reason"] = "No supported CLI updater or verified Homebrew installation; use the vendor's updater manually."
+                    if name == PROVIDER_OLLAMA and platform.system().lower() == "linux":
+                        item["reason"] = ("No supported safe automatic Linux update: Ollama's installer writes system paths and may restart a service. "
+                                          "Even a user-local binary may serve running models; arrange a manual maintenance window.")
             else:
                 item["status"] = "unknown"
                 item["reason"] = "Latest version unavailable from the official source." if not latest else "Installed version unavailable or does not match the published release."
@@ -214,6 +229,15 @@ def apply_update_all_plan(plan, service, env=None, runner=None, progress=None):
             continue
         result = _run(step["command"], {**env, **step.get("env", {})}, runner, timeout=120)
         result = {"name": step["name"], "command": step["command"], **result}
+        item = next((item for item in plan.get("items", []) if item["name"] == step["name"]), None)
+        if result["returncode"] == 0 and item:
+            after = _version(item["command"], env, runner)
+            result.update(version_before=item["version"], version_after=after, latest_version=item["latest_version"])
+            if not (_newer(after, item["version"]) and
+                    (after == item["latest_version"] or _newer(after, item["latest_version"]))):
+                result["returncode"] = 1
+                result["reason"] = "Update verification failed: installed version did not advance to the published release."
+                result["stderr"] = (result["stderr"] + "\n" + result["reason"]).strip()
         results.append(result)
         if result["returncode"] == 0 and step.get("id"):
             completed.add(step["id"])