cdx-manager 0.4.0 → 0.4.2

package/README.md

@@ -1,6 +1,6 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.4.0-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.4.2-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.**
 
@@ -48,6 +48,7 @@ One command to launch any session. Zero auth juggling.
 - Environment isolation per session:
   - Codex sessions override `CODEX_HOME` to a dedicated profile directory.
   - Claude sessions override `HOME` to a dedicated profile directory.
+  - New Codex sessions seed their auth home from your existing global `~/.codex/auth.json` when available, so an already logged-in Codex CLI can be reused without giving up per-session isolation afterward.
 - Persistence:
   - Session registry at `~/.cdx/sessions.json` (versioned JSON store).
   - Per-session state at `~/.cdx/state/<name>.json`.
@@ -69,10 +70,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:
@@ -119,7 +122,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.4.0 sh install.sh
+CDX_VERSION=v0.4.2 sh install.sh
 ```
 
 From source:
@@ -336,8 +339,8 @@ Notes:
 ## 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
 
@@ -350,6 +353,7 @@ Notes:
   - `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`.
@@ -365,7 +369,9 @@ Notes:
 
 ```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
@@ -419,6 +425,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_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 entry point 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 entry point.
+
+### Windows npm launcher
+
+- 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 existing Python script under `bin/cdx` as the primary CLI entry point.
+- 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 shared portable Node wrapper for the npm test and lint scripts.
+- Bumped the package versions for the npm and PyPI release workflows.
+
+### Validation
+
+```bash
+npm run lint
+npm test
+node bin/cdx.js --version
+```

package/changelogs/CHANGELOGS_0_4_2.md

@@ -0,0 +1,32 @@
+# CHANGELOGS_0_4_2
+
+Release date: 2026-04-19
+
+## CDX Manager 0.4.2
+
+CDX Manager 0.4.2 fixes Codex session bootstrap on Windows so `cdx add` can reuse an existing logged-in Codex CLI without requiring a second manual login flow. It also hardens executable resolution for the Codex probe so Windows shell shims and direct process spawning behave consistently.
+
+### Codex auth bootstrap
+
+- Seeded new Codex session auth homes from the global `~/.codex/auth.json` when available.
+- Short-circuited the Codex auth probe when a session already has an auth file in its isolated home.
+- Kept the per-session auth directory model intact after bootstrap so session isolation still applies.
+
+### Windows command resolution
+
+- Resolved `codex` through the active `PATH` before invoking the login-status probe.
+- Applied the same command-resolution path to interactive provider launches when the default process spawner is used.
+- Added regression coverage for Codex auth bootstrap and resolved-command spawning on Windows.
+
+### Documentation
+
+- Documented the Codex auth bootstrap behavior in the README.
+
+### Validation
+
+```bash
+npm run lint
+npm test
+node bin/cdx.js rmv main --force
+node bin/cdx.js add main
+```

package/checksums/release-archives.json

@@ -4,6 +4,10 @@
     "v0.3.4": {
       "github_tarball_sha256": "8e8111d6ec41b819fc0249800f175b5741cd11b1439c7e88a3feec770774b12d",
       "github_zip_sha256": "e0bd79f731d86b83787e99b8f2220c8c5fbaa3d7507ebc52823aa5b8d11f0666"
+    },
+    "v0.4.0": {
+      "github_tarball_sha256": "47a99ff2663f4fee33339098d2cfe7c27fbd0f74a16a1f6711f3003287409ae8",
+      "github_zip_sha256": "ae7eff748e569c621ef203abb6b395fbf893370471e962252e8c781e7751e5c8"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",
@@ -35,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.4.0"
+version = "0.4.2"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/cli.py

@@ -44,7 +44,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.4.0"
+VERSION = "0.4.2"
 
 
 # ---------------------------------------------------------------------------

package/src/provider_runtime.py

@@ -2,6 +2,7 @@ import json
 import os
 import signal
 import shlex
+import shutil
 import subprocess
 import sys
 from datetime import datetime, timezone
@@ -157,26 +158,49 @@ def _build_auth_action_spec(session, action, cwd=None, env_override=None):
             "options": {"cwd": cwd, "env": env}, "label": f"codex {action}"}
 
 
+def _format_probe_failure(session, spec, error):
+    command = spec["command"]
+    if isinstance(error, FileNotFoundError):
+        return CdxError(
+            f"Failed to check login status for {session['name']}: {command} CLI not found on PATH. "
+            f"Install {command} and retry cdx add {session['name']}.",
+            127,
+        )
+    message = getattr(error, "message", None) or str(error)
+    return CdxError(f"Failed to check login status for {session['name']}: {message}")
+
+
+def _resolve_command(command, env=None):
+    env = env or os.environ
+    return shutil.which(command, path=env.get("PATH")) or command
+
+
 def _probe_provider_auth(session, spawn_sync=None, env_override=None):
     spawn_sync = spawn_sync or subprocess.run
     spec = _build_login_status_spec(session, env_override)
-    if spawn_sync is subprocess.run:
-        result = subprocess.run(
-            [spec["command"]] + spec["args"],
-            env=spec["env"],
-            capture_output=True, text=True,
-        )
-        output = (result.stdout or "") + (result.stderr or "")
-    else:
-        result = spawn_sync(spec["command"], spec["args"], spec)
-        error = result.get("error") if isinstance(result, dict) else getattr(result, "error", None)
-        if error:
-            raise CdxError(
-                f"Failed to check login status for {session['name']}: {getattr(error, 'message', str(error))}"
+    if session.get("provider") == "codex":
+        auth_path = os.path.join(_get_auth_home(session), "auth.json")
+        if os.path.isfile(auth_path):
+            return True
+    try:
+        if spawn_sync is subprocess.run:
+            command = _resolve_command(spec["command"], spec["env"])
+            result = subprocess.run(
+                [command] + spec["args"],
+                env=spec["env"],
+                capture_output=True, text=True,
             )
-        stdout = result.get("stdout") if isinstance(result, dict) else getattr(result, "stdout", "")
-        stderr = result.get("stderr") if isinstance(result, dict) else getattr(result, "stderr", "")
-        output = (stdout or "") + (stderr or "")
+            output = (result.stdout or "") + (result.stderr or "")
+        else:
+            result = spawn_sync(spec["command"], spec["args"], spec)
+            error = result.get("error") if isinstance(result, dict) else getattr(result, "error", None)
+            if error:
+                raise _format_probe_failure(session, spec, error)
+            stdout = result.get("stdout") if isinstance(result, dict) else getattr(result, "stdout", "")
+            stderr = result.get("stderr") if isinstance(result, dict) else getattr(result, "stderr", "")
+            output = (stdout or "") + (stderr or "")
+    except FileNotFoundError as error:
+        raise _format_probe_failure(session, spec, error)
     return spec["parser"](output)
 
 
@@ -205,8 +229,11 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
         else _build_auth_action_spec(session, action, cwd=cwd, env_override=env_override)
     )
     def start_child(current_spec):
+        command = current_spec["command"]
+        if spawn is subprocess.Popen:
+            command = _resolve_command(command, current_spec.get("options", {}).get("env"))
         return spawn(
-            [current_spec["command"]] + current_spec["args"],
+            [command] + current_spec["args"],
             **{k: v for k, v in current_spec.get("options", {}).items() if k != "stdio"},
         )
 

package/src/session_service.py

@@ -55,6 +55,21 @@ def _ensure_private_dir(path):
         pass
 
 
+def _get_global_codex_home(env=None):
+    env = env or os.environ
+    return env.get("CODEX_HOME") or os.path.join(os.path.expanduser("~"), ".codex")
+
+
+def _seed_codex_auth_from_global(auth_home, env=None):
+    source_home = _get_global_codex_home(env)
+    source_auth = os.path.join(source_home, "auth.json")
+    dest_auth = os.path.join(auth_home, "auth.json")
+    if source_home == auth_home or os.path.exists(dest_auth) or not os.path.isfile(source_auth):
+        return False
+    shutil.copy2(source_auth, dest_auth)
+    return True
+
+
 def _local_now_iso():
     return datetime.now().astimezone().isoformat()
 
@@ -303,6 +318,8 @@ def create_session_service(options=None):
         _ensure_private_dir(os.path.join(base_dir, "profiles"))
         _ensure_private_dir(session_root)
         _ensure_private_dir(auth_home)
+        if normalized_provider == "codex":
+            _seed_codex_auth_from_global(auth_home, env=env)
         now = _local_now_iso()
         session = {
             "name": name,