cdx-manager 0.3.4 → 0.4.1

package/README.md

@@ -1,12 +1,15 @@
 # CDX Manager
 
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.4.1-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+
 **Run multiple Codex and Claude sessions from one terminal. Switch between accounts instantly.**
 
 If you use AI coding tools at scale ; multiple accounts, multiple providers : you know the friction: re-authenticating, losing context, juggling environment variables. `cdx` removes all of that.
 
 One command to launch any session. Zero auth juggling.
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.3.4-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+<img width="213" height="227" alt="image" src="https://github.com/user-attachments/assets/f15f449c-d23e-47fe-a455-17c7386f9be2" />
+<img width="645" height="129" alt="image" src="https://github.com/user-attachments/assets/34bcb395-f832-4da6-9247-3e5022e75e56" />
 
 ---
 
@@ -66,10 +69,12 @@ One command to launch any session. Zero auth juggling.
 
 ### Prerequisites
 
+- Node.js 18+ with npm
 - Python 3.9+
-- npm
 - `codex` and/or `claude` CLI installed and available in your PATH
 
+On Windows, the npm launcher looks for Python in this order: `py -3`, `python`, then `python3`. Make sure at least one of those commands resolves to Python 3.
+
 ### Install
 
 From npm:
@@ -99,19 +104,24 @@ npm install -g cdx-manager
 With the standalone PowerShell installer:
 
 ```powershell
-irm https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.ps1 | iex
+Invoke-WebRequest https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.ps1 -OutFile install.ps1
+# Optional: set CDX_SHA256 before running if you have a trusted checksum
+powershell -ExecutionPolicy Bypass -File .\install.ps1
 ```
 
 With the standalone GitHub installer:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh | sh
+curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
+# Optional: set CDX_SHA256 before running if you have a trusted checksum
+sh install.sh
 ```
 
 For a specific version:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh | CDX_VERSION=v0.3.4 sh
+curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
+CDX_VERSION=v0.4.1 sh install.sh
 ```
 
 From source:
@@ -150,6 +160,13 @@ Alternatively, for a non-symlinked global source install:
 npm install -g .
 ```
 
+Security note:
+
+- The standalone installers try to resolve official release checksums from `checksums/release-archives.json`.
+- You can still override verification explicitly through `CDX_SHA256`.
+- Prefer `npm`, `pipx`, or `uv` when you want registry-backed install flows.
+- If you use the standalone script, download it first, inspect it, and prefer a release with an official checksum entry.
+
 ### Environment
 
 By default, `cdx` stores all data under `~/.cdx/`. Override with:
@@ -220,11 +237,13 @@ cdx status
 | `cdx logout <name> [--json]` | Log out of a session |
 | `cdx rmv <name> [--force] [--json]` | Remove a session and its auth data (prompts for confirmation unless `--force`) |
 | `cdx clean [name] [--json]` | Clear launch transcript logs for one session or all sessions |
+| `cdx export <file> [--include-auth] [--sessions a,b] [--passphrase-env VAR] [--force] [--json]` | Export sessions to a portable bundle; `--include-auth` encrypts auth data with a passphrase |
+| `cdx import <file> [--sessions a,b] [--passphrase-env VAR] [--force] [--json]` | Import sessions from a bundle into the current `CDX_HOME` |
 | `cdx doctor [--json]` | Inspect CLI dependencies, CDX_HOME permissions, missing state, orphan profiles, and pending quarantines |
 | `cdx repair [--dry-run] [--force] [--json]` | Plan or apply safe repairs for missing state files, quarantines, and orphan profiles |
-| `cdx notify <name> --at-reset [--poll seconds] [--once]` | Wait for a session reset time and send a desktop notification when due |
-| `cdx notify --next-ready [--poll seconds] [--once]` | Wait until the recommended session is usable or needs a refresh after reset |
-| `cdx status [--json] [--refresh]` | Show token usage table for all sessions; JSON keeps the same row-array shape and writes live Claude refresh warnings to stderr |
+| `cdx notify <name> --at-reset [--poll seconds] [--once] [--json]` | Wait for a session reset time and send a desktop notification when due |
+| `cdx notify --next-ready [--poll seconds] [--once] [--json]` | Wait until the recommended session is usable or needs a refresh after reset |
+| `cdx status [--json] [--refresh]` | Show token usage table for all sessions; JSON returns a versioned payload with structured warnings |
 | `cdx status --small [--refresh]` / `cdx status -s [--refresh]` | Show compact token usage table without provider, blocking quota, credits, and updated columns |
 | `cdx status <name> [--json] [--refresh]` | Show detailed usage breakdown for one session |
 | `cdx --help` | Show usage |
@@ -246,6 +265,8 @@ Commands with machine-readable output:
 - `cdx ren ... --json`
 - `cdx rmv ... --json`
 - `cdx clean ... --json`
+- `cdx export ... --json`
+- `cdx import ... --json`
 - `cdx login ... --json`
 - `cdx logout ... --json`
 - `cdx doctor --json`
@@ -256,6 +277,7 @@ Success payloads follow a shared envelope:
 
 ```json
 {
+  "schema_version": 1,
   "ok": true,
   "action": "add",
   "message": "Created session work (codex)",
@@ -270,6 +292,7 @@ Errors use a shared stderr JSON envelope whenever `--json` is present:
 
 ```json
 {
+  "schema_version": 1,
   "ok": false,
   "error": {
     "code": "invalid_usage",
@@ -279,15 +302,44 @@ Errors use a shared stderr JSON envelope whenever `--json` is present:
 }
 ```
 
+`status --json` and similar commands also use the same envelope and place non-fatal issues in `warnings` instead of mixing plain-text diagnostics into `stderr`.
+
 This makes `cdx-manager` usable from editor plugins, scripts, and desktop apps without scraping human-readable terminal output.
 
 ---
 
+## Backup And Restore
+
+You can move sessions between machines with portable bundles:
+
+```bash
+cdx export backup.cdx
+cdx import backup.cdx
+```
+
+To migrate auth and avoid logging in again, include auth data in an encrypted bundle:
+
+```bash
+export CDX_BUNDLE_PASSPHRASE='choose-a-strong-passphrase'
+cdx export backup-auth.cdx --include-auth --passphrase-env CDX_BUNDLE_PASSPHRASE
+cdx import backup-auth.cdx --passphrase-env CDX_BUNDLE_PASSPHRASE
+```
+
+Notes:
+
+- `--include-auth` is encrypted and requires a passphrase.
+- Without `--passphrase-env`, `cdx` prompts in an interactive terminal.
+- `--sessions work,perso` exports or imports only a subset.
+- `--force` allows overwriting existing destination sessions during import or replacing an existing bundle file during export.
+- Auth bundles contain credentials. Treat them like secrets and delete them after transfer.
+
+---
+
 ## Available Scripts
 
 - `npm test`: run the Python test suite
-- `npm run test:py`: run the Python unit tests directly
-- `npm run lint`: byte-compile the Python sources and tests
+- `npm run test:py`: run the Python unit tests through the portable launcher
+- `npm run lint`: check the Node launcher and byte-compile the Python sources and tests
 - `npm run link`: link `cdx` globally for local development (`npm link`)
 - `npm run unlink`: remove the global link
 
@@ -300,6 +352,7 @@ This makes `cdx-manager` usable from editor plugins, scripts, and desktop apps w
   - `pipx install cdx-manager`
   - `uv tool install cdx-manager`
   - `install.ps1`
+- The npm launcher resolves Python via `py -3`, `python`, then `python3`, so a global npm install works even when `python3.exe` is missing.
 - `install.sh` is Unix-only.
 - `make install` and `make uninstall` are Unix-oriented convenience commands, not the default Windows path.
 - `cdx` isolates Claude sessions on Windows by setting `HOME`, `USERPROFILE`, `HOMEDRIVE`, and `HOMEPATH`.
@@ -315,12 +368,15 @@ This makes `cdx-manager` usable from editor plugins, scripts, and desktop apps w
 
 ```text
 bin/
-  cdx                   # Entry point — shebang + main() call
+  cdx.js                # Node launcher used by npm
+  python-runner.js      # Shared Python resolver and process wrapper
+  cdx                   # Python entrypoint invoked by the launcher
 
 src/
   cli.py                # Top-level command router
   cli_commands.py       # Command handlers and argument handling
   cli_render.py         # Terminal formatting, tables, colors, and errors
+  backup_bundle.py      # Portable session bundle encoding/decoding + auth encryption
   status_view.py        # Status table/detail rendering and priority ranking
   provider_runtime.py   # Provider launch/auth commands, transcripts, signals
   claude_refresh.py     # Claude usage refresh orchestration
@@ -368,6 +424,7 @@ Session names are URL-encoded when used as directory or file names. CLI command
 ## Troubleshooting
 
 - **`cdx <name>` fails with "not authenticated"** — run `cdx login <name>` first.
+- **`cdx` says no compatible Python 3 interpreter was found** — install Python 3 and make `py -3`, `python`, or `python3` available on PATH.
 - **`cdx add` succeeds but the session does not appear** — check that `CDX_HOME` is consistent between calls; a mismatch creates two separate registries.
 - **Status shows `n/a` for all fields** — the session has not been launched yet, or the provider has not written any status output to its history files. Launch the session and run `/status` inside it at least once.
 - **`cdx rmv` says "Removal requires confirmation in an interactive terminal"** — pass `--force` to bypass the prompt in non-interactive environments (scripts, CI).

package/bin/cdx.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+const path = require("node:path");
+const { runPython } = require("./python-runner");
+
+const scriptPath = path.join(__dirname, "cdx");
+const exitCode = runPython([scriptPath, ...process.argv.slice(2)], { expandGlobs: false });
+
+process.exit(exitCode);

package/bin/python-runner.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const PYTHON_VERSION_CHECK = "import sys; sys.exit(0 if sys.version_info[0] == 3 else 1)";
+const PYTHON_CACHE_PREFIX = path.join(os.tmpdir(), "cdx-manager-pycache");
+const SIGNAL_EXIT_CODES = {
+  SIGHUP: 129,
+  SIGINT: 130,
+  SIGTERM: 143,
+};
+
+const WINDOWS_CANDIDATES = [
+  { command: "py", args: ["-3"], label: "py -3" },
+  { command: "python", args: [], label: "python" },
+  { command: "python3", args: [], label: "python3" },
+];
+
+const UNIX_CANDIDATES = [
+  { command: "python3", args: [], label: "python3" },
+  { command: "python", args: [], label: "python" },
+];
+
+function getCandidates(platform = process.platform) {
+  return platform === "win32" ? WINDOWS_CANDIDATES : UNIX_CANDIDATES;
+}
+
+function probeCandidate(candidate) {
+  const result = spawnSync(
+    candidate.command,
+    [...candidate.args, "-c", PYTHON_VERSION_CHECK],
+    { stdio: "ignore", windowsHide: true }
+  );
+  return result.status === 0;
+}
+
+function findPython(platform = process.platform) {
+  for (const candidate of getCandidates(platform)) {
+    if (probeCandidate(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function hasGlobCharacters(value) {
+  return value.includes("*") || value.includes("?") || value.includes("[");
+}
+
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function segmentToRegExp(segment) {
+  const pattern = escapeRegex(segment).replace(/\\\*/g, ".*").replace(/\\\?/g, ".");
+  return new RegExp(`^${pattern}$`);
+}
+
+function expandGlob(pattern) {
+  const pathLike = pattern.includes("/") || pattern.includes("\\") || path.isAbsolute(pattern);
+  if (!hasGlobCharacters(pattern) || !pathLike) {
+    return [pattern];
+  }
+
+  const absolute = path.isAbsolute(pattern);
+  const root = absolute ? path.parse(pattern).root : process.cwd();
+  const relativePattern = absolute ? path.relative(root, pattern) : pattern;
+  const segments = relativePattern.split(/[\\/]+/).filter(Boolean);
+  const matches = [];
+
+  const walk = (currentPath, index) => {
+    if (index >= segments.length) {
+      if (fs.existsSync(currentPath)) {
+        matches.push(currentPath);
+      }
+      return;
+    }
+
+    const segment = segments[index];
+    const nextIndex = index + 1;
+
+    if (!hasGlobCharacters(segment)) {
+      walk(path.join(currentPath, segment), nextIndex);
+      return;
+    }
+
+    if (!fs.existsSync(currentPath) || !fs.statSync(currentPath).isDirectory()) {
+      return;
+    }
+
+    const matcher = segmentToRegExp(segment);
+    for (const entry of fs.readdirSync(currentPath, { withFileTypes: true })) {
+      if (matcher.test(entry.name)) {
+        walk(path.join(currentPath, entry.name), nextIndex);
+      }
+    }
+  };
+
+  walk(root, 0);
+  return matches.length > 0 ? matches : [pattern];
+}
+
+function expandArgs(args) {
+  const expanded = [];
+  for (const arg of args) {
+    expanded.push(...expandGlob(arg));
+  }
+  return expanded;
+}
+
+function prepareEnv(env = process.env) {
+  const nextEnv = { ...env };
+  if (!nextEnv.PYTHONPYCACHEPREFIX) {
+    fs.mkdirSync(PYTHON_CACHE_PREFIX, { recursive: true });
+    nextEnv.PYTHONPYCACHEPREFIX = PYTHON_CACHE_PREFIX;
+  }
+  return nextEnv;
+}
+
+function runPython(args, options = {}) {
+  const platform = options.platform || process.platform;
+  const candidate = findPython(platform);
+
+  if (!candidate) {
+    const tried = getCandidates(platform).map((item) => item.label).join(", ");
+    console.error(`cdx: no compatible Python 3 interpreter found. Tried: ${tried}.`);
+    console.error("Install Python 3 and make one of those commands available on PATH.");
+    return 127;
+  }
+
+  const finalArgs = options.expandGlobs === false ? args.slice() : expandArgs(args);
+  const result = spawnSync(
+    candidate.command,
+    [...candidate.args, ...finalArgs],
+    {
+      env: prepareEnv(options.env),
+      stdio: "inherit",
+      windowsHide: true,
+    }
+  );
+
+  if (result.error) {
+    console.error(`cdx: failed to launch ${candidate.label}: ${result.error.message}`);
+    return 127;
+  }
+
+  if (result.signal) {
+    return SIGNAL_EXIT_CODES[result.signal] || 128;
+  }
+
+  return typeof result.status === "number" ? result.status : 1;
+}
+
+if (require.main === module) {
+  process.exit(runPython(process.argv.slice(2)));
+}
+
+module.exports = {
+  expandArgs,
+  findPython,
+  runPython,
+};

package/changelogs/CHANGELOGS_0_4_0.md

@@ -0,0 +1,36 @@
+# CHANGELOGS_0_4_0
+
+Release date: 2026-04-16
+
+## CDX Manager 0.4.0
+
+CDX Manager 0.4.0 adds portable session backup and restore, surfaces cached release-update notices inside the CLI, and tightens Codex status isolation across multiple accounts.
+
+### Portable session bundles
+
+- Added `cdx export <file>` and `cdx import <file>` for moving sessions between machines.
+- Added optional encrypted auth export with `--include-auth` and interactive or environment-driven passphrase handling.
+- Added subset export/import support with `--sessions`.
+- Preserved per-session state alongside session records so imported environments keep their local metadata.
+- Added bundle schema validation and integrity checks during import.
+
+### Update awareness and installer hardening
+
+- Added cached GitHub release checks so the CLI can warn when a newer `cdx-manager` release is available without hitting the network on every command.
+- Surfaced update notices in interactive output and structured JSON warnings.
+- Hardened the standalone install scripts to consume official release-archive checksums when available.
+- Documented the checksum-backed installer flow and backup/restore usage in the README.
+
+### Status isolation fix
+
+- Fixed Codex status parsing so boxed blank lines in TUI transcripts no longer drop the `Account:` context line.
+- Restored account-aware status selection when multiple sessions contain similar `/status` blocks.
+- Added regression coverage for mixed-account transcript selection and bundle export/import flows.
+
+### Validation
+
+```bash
+npm run lint
+npm test
+python3 -m build --no-isolation
+```

package/changelogs/CHANGELOGS_0_4_1.md

@@ -0,0 +1,28 @@
+# CHANGELOGS_0_4_1
+
+Release date: 2026-04-19
+
+## CDX Manager 0.4.1
+
+CDX Manager 0.4.1 fixes the Windows npm entrypoint so `cdx` no longer depends on `python3.exe` being present on PATH. It now ships a Node launcher that resolves a usable Python 3 interpreter cross-platform before invoking the existing Python CLI entrypoint.
+
+### Windows npm launcher fix
+
+- Replaced the npm-facing `bin.cdx` target with a Node launcher at `bin/cdx.js`.
+- Added Python discovery that tries `py -3`, then `python`, then `python3` on Windows.
+- Kept the Python script under `bin/cdx` as the logical CLI entrypoint.
+- Added a clear error message when no compatible Python 3 interpreter is available.
+
+### Documentation and packaging
+
+- Updated the README with Windows Python prerequisites and the new launcher behavior.
+- Added a portable shared Node wrapper for the npm test and lint scripts.
+- Bumped the package version for both npm and PyPI release flows.
+
+### Validation
+
+```bash
+npm run lint
+npm test
+node bin/cdx.js --version
+```

package/checksums/release-archives.json

@@ -0,0 +1,13 @@
+{
+  "schema_version": 1,
+  "releases": {
+    "v0.3.4": {
+      "github_tarball_sha256": "8e8111d6ec41b819fc0249800f175b5741cd11b1439c7e88a3feec770774b12d",
+      "github_zip_sha256": "e0bd79f731d86b83787e99b8f2220c8c5fbaa3d7507ebc52823aa5b8d11f0666"
+    },
+    "v0.4.0": {
+      "github_tarball_sha256": "47a99ff2663f4fee33339098d2cfe7c27fbd0f74a16a1f6711f3003287409ae8",
+      "github_zip_sha256": "ae7eff748e569c621ef203abb6b395fbf893370471e962252e8c781e7751e5c8"
+    }
+  }
+}

package/install.ps1

@@ -1,11 +1,16 @@
 param(
     [string]$Version = $env:CDX_VERSION,
-    [string]$Prefix = $env:CDX_PREFIX
+    [string]$Prefix = $env:CDX_PREFIX,
+    [string]$Sha256 = $env:CDX_SHA256,
+    [string]$ChecksumsUrl = $env:CDX_CHECKSUMS_URL
 )
 
 $ErrorActionPreference = "Stop"
 
 $repo = "AlexAgo83/cdx-manager"
+if (-not $ChecksumsUrl) {
+    $ChecksumsUrl = "https://raw.githubusercontent.com/$repo/main/checksums/release-archives.json"
+}
 
 function Require-Command {
     param([string]$Name)
@@ -44,6 +49,21 @@ New-Item -ItemType Directory -Force -Path $tmpRoot, $extractRoot, $binDir, $inst
 
 try {
     Invoke-WebRequest -Uri $archiveUrl -OutFile $archivePath
+    if (-not $Sha256) {
+        try {
+            $checksums = Invoke-RestMethod -Uri $ChecksumsUrl
+            $Sha256 = $checksums.releases.$tag.github_zip_sha256
+        } catch {
+        }
+    }
+    if ($Sha256) {
+        $actualSha256 = (Get-FileHash -Algorithm SHA256 -Path $archivePath).Hash.ToLowerInvariant()
+        if ($actualSha256 -ne $Sha256.ToLowerInvariant()) {
+            throw "cdx install: checksum mismatch for $tag`nexpected: $Sha256`nactual:   $actualSha256"
+        }
+    } else {
+        Write-Warning "No official checksum available for $tag; continuing without verification."
+    }
     Expand-Archive -Path $archivePath -DestinationPath $extractRoot -Force
 
     $sourceDir = Get-ChildItem -Path $extractRoot -Directory | Select-Object -First 1

package/install.sh

@@ -6,6 +6,7 @@ VERSION="${CDX_VERSION:-}"
 PREFIX="${PREFIX:-$HOME/.local}"
 BIN_DIR="${BIN_DIR:-$PREFIX/bin}"
 INSTALL_ROOT="${CDX_INSTALL_ROOT:-$PREFIX/share/cdx-manager}"
+CHECKSUMS_URL="${CDX_CHECKSUMS_URL:-https://raw.githubusercontent.com/$REPO/main/checksums/release-archives.json}"
 
 need() {
   if ! command -v "$1" >/dev/null 2>&1; then
@@ -18,6 +19,38 @@ need curl
 need tar
 need python3
 
+sha256_file() {
+  if command -v sha256sum >/dev/null 2>&1; then
+    sha256sum "$1" | awk '{print $1}'
+    return
+  fi
+  if command -v shasum >/dev/null 2>&1; then
+    shasum -a 256 "$1" | awk '{print $1}'
+    return
+  fi
+  echo "cdx install: missing checksum tool (sha256sum or shasum)" >&2
+  exit 1
+}
+
+resolve_expected_sha256() {
+  curl -fsSL "$CHECKSUMS_URL" |
+    python3 - "$1" <<'PY'
+import json
+import sys
+
+tag = sys.argv[1]
+try:
+    payload = json.load(sys.stdin)
+except Exception:
+    raise SystemExit(1)
+
+release = (payload.get("releases") or {}).get(tag) or {}
+value = release.get("github_tarball_sha256")
+if value:
+    print(value)
+PY
+}
+
 if [ -z "$VERSION" ]; then
   VERSION="$(
     curl -fsSL "https://api.github.com/repos/$REPO/releases/latest" |
@@ -38,6 +71,24 @@ trap cleanup EXIT INT TERM
 
 ARCHIVE_URL="https://github.com/$REPO/archive/refs/tags/$TAG.tar.gz"
 curl -fsSL "$ARCHIVE_URL" -o "$TMP_DIR/cdx-manager.tar.gz"
+
+EXPECTED_SHA256="${CDX_SHA256:-}"
+if [ -z "$EXPECTED_SHA256" ]; then
+  EXPECTED_SHA256="$(resolve_expected_sha256 "$TAG" 2>/dev/null || true)"
+fi
+
+if [ -n "$EXPECTED_SHA256" ]; then
+  ACTUAL_SHA256="$(sha256_file "$TMP_DIR/cdx-manager.tar.gz")"
+  if [ "$ACTUAL_SHA256" != "$EXPECTED_SHA256" ]; then
+    echo "cdx install: checksum mismatch for $TAG" >&2
+    echo "expected: $EXPECTED_SHA256" >&2
+    echo "actual:   $ACTUAL_SHA256" >&2
+    exit 1
+  fi
+else
+  echo "cdx install: warning: no official checksum available for $TAG; continuing without verification" >&2
+fi
+
 tar -xzf "$TMP_DIR/cdx-manager.tar.gz" -C "$TMP_DIR"
 
 SRC_DIR="$(find "$TMP_DIR" -mindepth 1 -maxdepth 1 -type d | head -n 1)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.3.4",
+  "version": "0.4.1",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",
@@ -25,6 +25,7 @@
   },
   "files": [
     "bin",
+    "checksums",
     "changelogs",
     "src",
     "install.sh",
@@ -34,12 +35,12 @@
     "LICENSE"
   ],
   "bin": {
-    "cdx": "bin/cdx"
+    "cdx": "bin/cdx.js"
   },
   "scripts": {
     "test": "npm run test:py",
-    "test:py": "PYTHONPYCACHEPREFIX=/tmp/pycache python3 -m unittest discover -s test -p 'test_*_py.py'",
-    "lint": "PYTHONPYCACHEPREFIX=/tmp/pycache python3 -m py_compile bin/cdx src/*.py test/test_*_py.py",
+    "test:py": "node bin/python-runner.js -m unittest discover -s test -p test_*_py.py",
+    "lint": "node --check bin/cdx.js && node --check bin/python-runner.js && node bin/python-runner.js -m py_compile bin/cdx src/*.py test/test_*_py.py",
     "prepublishOnly": "npm run lint && npm test",
     "link": "npm link",
     "unlink": "npm unlink -g cdx-manager"

package/pyproject.toml

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