xsync-cli 0.1.1__tar.gz → 0.1.2__tar.gz

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: xsync-cli
-Version: 0.1.1
+Version: 0.1.2
 Summary: Sync the model list of an OpenAI-compatible endpoint into the Codex model catalog.
 License-Expression: MIT
 License-File: LICENSE
@@ -77,7 +77,8 @@ Run this command again when the endpoint changes.
 | `xsync codex --profile <name>` | Use another profile for one run. |
 | `xsync codex --init` | Connect Codex to the endpoint of the profile. |
 | `xsync codex --reset` | Remove everything that xSync wrote. |
-| `xsync codex --reset --force` | Reset when no state file exists. |
+| `xsync codex --reset --force` | Reset when no state file exists. It asks first. |
+| `xsync codex --reset --force --yes` | Reset with no question. Use this in a script. |
 
 Exit codes: `0` for success, `1` for an error, `2` when the endpoint does not
 answer.
@@ -120,8 +121,21 @@ A profile uses `api_key` or `api_key_env`, but not both. Use `api_key_env`
 when you share the file. A profile with neither key sends no `Authorization`
 header.
 
-The `include` and `exclude` lists hold glob patterns. An empty `include`
-list keeps every model. The `exclude` list always wins.
+## The filters
+
+A glob pattern selects a model by name. The sign `*` means any characters.
+
+| Rule | Effect |
+|---|---|
+| `include = []` | Keep every model. This is the default. |
+| `include = ["cx/*", "ed3n/*"]` | Keep only the models of those two providers. |
+| `exclude = ["*embedding*"]` | Drop every model with `embedding` in the name. |
+| `exclude = ["*-image-*", "*-tts-*"]` | Drop the image models and the speech models. |
+
+The `exclude` list always wins over the `include` list. Use the filters when
+an endpoint serves many models that you never choose in Codex.
+
+The match ignores the letter case.
 
 ## Safety
 
@@ -136,9 +150,21 @@ list keeps every model. The `exclude` list always wins.
 - `--reset` removes only what the state file `~/.codex/.xsync-state.json`
   records. It never restores an old copy of `config.toml`, because Codex
   adds project entries to that file over time.
+- `--reset` keeps the catalog backup `<name>.bak`. The backup is the only
+  way back after a reset.
 - With no state file, `--reset` prints the keys that it would remove and
-  then stops. Add `--force` to continue.
-- xSync never prints an API key.
+  then stops. Add `--force` to continue. The command then asks a question
+  before it removes anything. Add `--yes` to answer the question in a
+  script.
+- The setup hides the API key while you type it. It then shows the first
+  five characters only, and it never shows the length of the key.
+- xSync never prints a whole API key.
+
+## The color
+
+xSync writes color for a terminal. It writes plain text for a pipe, for a
+dumb terminal, and when `NO_COLOR` holds a value. Set `FORCE_COLOR=1` to
+keep the color in a pipe.
 
 ## What xSync reads and what it writes
 

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/README.md

@@ -65,7 +65,8 @@ Run this command again when the endpoint changes.
 | `xsync codex --profile <name>` | Use another profile for one run. |
 | `xsync codex --init` | Connect Codex to the endpoint of the profile. |
 | `xsync codex --reset` | Remove everything that xSync wrote. |
-| `xsync codex --reset --force` | Reset when no state file exists. |
+| `xsync codex --reset --force` | Reset when no state file exists. It asks first. |
+| `xsync codex --reset --force --yes` | Reset with no question. Use this in a script. |
 
 Exit codes: `0` for success, `1` for an error, `2` when the endpoint does not
 answer.
@@ -108,8 +109,21 @@ A profile uses `api_key` or `api_key_env`, but not both. Use `api_key_env`
 when you share the file. A profile with neither key sends no `Authorization`
 header.
 
-The `include` and `exclude` lists hold glob patterns. An empty `include`
-list keeps every model. The `exclude` list always wins.
+## The filters
+
+A glob pattern selects a model by name. The sign `*` means any characters.
+
+| Rule | Effect |
+|---|---|
+| `include = []` | Keep every model. This is the default. |
+| `include = ["cx/*", "ed3n/*"]` | Keep only the models of those two providers. |
+| `exclude = ["*embedding*"]` | Drop every model with `embedding` in the name. |
+| `exclude = ["*-image-*", "*-tts-*"]` | Drop the image models and the speech models. |
+
+The `exclude` list always wins over the `include` list. Use the filters when
+an endpoint serves many models that you never choose in Codex.
+
+The match ignores the letter case.
 
 ## Safety
 
@@ -124,9 +138,21 @@ list keeps every model. The `exclude` list always wins.
 - `--reset` removes only what the state file `~/.codex/.xsync-state.json`
   records. It never restores an old copy of `config.toml`, because Codex
   adds project entries to that file over time.
+- `--reset` keeps the catalog backup `<name>.bak`. The backup is the only
+  way back after a reset.
 - With no state file, `--reset` prints the keys that it would remove and
-  then stops. Add `--force` to continue.
-- xSync never prints an API key.
+  then stops. Add `--force` to continue. The command then asks a question
+  before it removes anything. Add `--yes` to answer the question in a
+  script.
+- The setup hides the API key while you type it. It then shows the first
+  five characters only, and it never shows the length of the key.
+- xSync never prints a whole API key.
+
+## The color
+
+xSync writes color for a terminal. It writes plain text for a pipe, for a
+dumb terminal, and when `NO_COLOR` holds a value. Set `FORCE_COLOR=1` to
+keep the color in a pipe.
 
 ## What xSync reads and what it writes
 

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "xsync-cli"
-version = "0.1.1"
+version = "0.1.2"
 description = "Sync the model list of an OpenAI-compatible endpoint into the Codex model catalog."
 readme = "README.md"
 requires-python = ">=3.11"

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/src/xsync_cli/adapters/codex_config.py

@@ -68,6 +68,21 @@ def check_provider_match(config: dict[str, Any], profile: Profile) -> str | None
     return None
 
 
+def wire_api_for_url(config: dict[str, Any], base_url: str) -> str | None:
+    """The wire API that Codex already uses for one base URL.
+
+    The function gives None when no provider block holds that URL.
+    """
+    wanted = base_url.rstrip("/")
+    for table in (config.get("model_providers") or {}).values():
+        if not isinstance(table, dict):
+            continue
+        if str(table.get("base_url", "")).rstrip("/") == wanted:
+            value = table.get("wire_api")
+            return str(value) if value else None
+    return None
+
+
 def catalog_path_for(profile: Profile, codex_home: Path) -> Path:
     """The catalog file of one profile."""
     return codex_home / f"{profile.name}-models.json"

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/src/xsync_cli/adapters/codex_wiring.py

@@ -103,7 +103,11 @@ def init_config(
 
 
 def reset_config(config_path: Path, state: State) -> list[str]:
-    """Remove every item that the state file records."""
+    """Remove every item that the state file records.
+
+    The function keeps the backup file `<name>.bak`. The backup is the
+    only way back after a reset.
+    """
     before = file_sha256(config_path)
     document = _load_document(config_path)
     removed: list[str] = []
@@ -129,9 +133,5 @@ def reset_config(config_path: Path, state: State) -> list[str]:
         if path.exists():
             path.unlink()
             removed.append(name)
-        backup = path.with_name(path.name + ".bak")
-        if backup.exists():
-            backup.unlink()
-            removed.append(str(backup))
 
     return removed

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/src/xsync_cli/cli.py

@@ -6,9 +6,11 @@ import argparse
 import json
 import os
 import sys
+from getpass import getpass
 from pathlib import Path
 
 from xsync_cli.adapters.codex import load_rules, render_catalog
+from xsync_cli.core import term
 from xsync_cli.adapters.codex_config import (
     STATE_FILENAME,
     ConfigError,
@@ -19,6 +21,7 @@ from xsync_cli.adapters.codex_config import (
     default_codex_home,
     read_config,
     read_state,
+    wire_api_for_url,
     write_state,
 )
 from xsync_cli.adapters.codex_wiring import init_config, known_removals, reset_config
@@ -55,62 +58,120 @@ def open_store() -> ProfileStore:
     return store
 
 
-def _ask(prompt: str, default: str = "") -> str:
-    suffix = f" [{default}]" if default else ""
-    answer = input(f"{prompt}{suffix}: ").strip()
+def _ask(prompt: str, default: str = "", hint: str = "") -> str:
+    """Ask one question. An empty answer gives the default."""
+    if hint:
+        print(term.dim(f"   {hint}"))
+    suffix = term.dim(f" [{default}]") if default else ""
+    answer = input(f"{term.cyan('?')} {term.bold(prompt)}{suffix}: ").strip()
     return answer or default
 
 
-def _ask_list(prompt: str) -> list[str]:
-    answer = _ask(prompt)
+def _ask_secret(prompt: str, hint: str = "") -> str:
+    """Ask for a secret. The terminal shows no character."""
+    if hint:
+        print(term.dim(f"   {hint}"))
+    return getpass(f"{term.cyan('?')} {term.bold(prompt)}: ").strip()
+
+
+def _ask_list(prompt: str, hint: str = "") -> list[str]:
+    answer = _ask(prompt, hint=hint)
     return [part.strip() for part in answer.split(",") if part.strip()]
 
 
+def _ok(text: str) -> None:
+    print(f"{term.green('✓')} {text}")
+
+
+def _warn(text: str) -> None:
+    print(f"{term.yellow('!')} {text}")
+
+
+def _fail(text: str) -> None:
+    print(f"{term.red('✗')} {text}", file=sys.stderr)
+
+
 def cmd_setup(args: argparse.Namespace) -> int:
     """Make a profile."""
     store = open_store()
 
-    name = _ask("profile name")
+    print(term.heading("New xsync profile"))
+    print(term.rule())
+
+    name = _ask("Profile name", hint="a short label, for example 9router")
     if not name:
-        print("the profile name cannot be empty.", file=sys.stderr)
+        _fail("the profile name cannot be empty.")
         return EXIT_ERROR
+    if name in store.names():
+        _warn(f"the profile {name!r} exists. The answers replace it.")
 
-    base_url = _ask("base URL (for example http://127.0.0.1:20128/v1)")
+    base_url = _ask(
+        "Base URL", hint="the endpoint, for example http://127.0.0.1:20128/v1"
+    )
     if not base_url:
-        print("the base URL cannot be empty.", file=sys.stderr)
+        _fail("the base URL cannot be empty.")
         return EXIT_ERROR
 
-    api_key = _ask("API key (leave empty when the endpoint needs none)")
-    include = _ask_list("include globs, separated by a comma (optional)")
-    exclude = _ask_list("exclude globs, separated by a comma (optional)")
+    api_key = _ask_secret(
+        "API key", hint="the terminal shows nothing. Press Enter when there is no key"
+    )
+    print(f"   {term.dim('key:')} {term.dim(term.mask_key(api_key))}")
+
+    print(term.heading("Filters"))
+    print(
+        term.dim(
+            "   A glob pattern selects models by name. The sign * means any\n"
+            "   characters. Leave both empty to keep every model."
+        )
+    )
+    include = _ask_list(
+        "Include only these", hint="for example cx/*, ed3n/*    (empty keeps all)"
+    )
+    exclude = _ask_list(
+        "Exclude these", hint="for example *embedding*, *-image-*"
+    )
 
-    print(f"testing {base_url}/models …")
+    print(term.heading(f"Testing {base_url}/models"))
     try:
         models = fetch_models(base_url, api_key or None)
     except EndpointUnreachable as error:
-        print(f"error: {error}", file=sys.stderr)
+        _fail(str(error))
         return EXIT_UNREACHABLE
     except SourceError as error:
-        print(f"error: {error}", file=sys.stderr)
+        _fail(str(error))
         return EXIT_ERROR
 
-    print(f"\n{len(models)} models:")
-    for model in models:
-        window = f"{model.context_window:,}" if model.context_window else "unknown"
-        flags = ",".join(
-            flag
-            for flag, on in (
-                ("tools", model.tools),
-                ("reasoning", model.reasoning),
-                ("vision", model.vision),
-                ("search", model.search),
+    kept = apply_filters(models, include, exclude)
+    _ok(f"the endpoint answered with {term.bold(str(len(models)))} models")
+    if len(kept) != len(models):
+        _ok(f"the filters keep {term.bold(str(len(kept)))} models")
+
+    _print_model_table(kept)
+
+    codex_home = default_codex_home()
+    known = wire_api_for_url(read_config(codex_home / "config.toml"), base_url)
+    print(term.heading("Wire API"))
+    if known:
+        print(
+            term.dim(
+                f"   Codex already talks to this URL with {known!r}. "
+                "Press Enter to keep it."
             )
-            if on
         )
-        print(f"  {model.slug:<48} {window:>12}  {flags}")
-
-    print()
-    wire_api = _ask(f"wire API ({' or '.join(WIRE_APIS)})", "chat")
+    else:
+        print(
+            term.dim(
+                "   Use chat for most OpenAI-compatible servers.\n"
+                "   Use responses for the OpenAI Responses API.\n"
+                "   A wrong value breaks every request."
+            )
+        )
+    wire_api = _ask(f"Wire API ({' or '.join(WIRE_APIS)})", known or "chat")
+    if known and wire_api != known:
+        _warn(
+            f"Codex uses {known!r} for this URL. The answer {wire_api!r} "
+            "disagrees with it."
+        )
 
     try:
         profile = Profile(
@@ -123,27 +184,92 @@ def cmd_setup(args: argparse.Namespace) -> int:
             exclude=exclude,
         )
     except ProfileError as error:
-        print(f"error: {error}", file=sys.stderr)
+        _fail(str(error))
         return EXIT_ERROR
 
     store.add(profile)
     store.save()
-    print(f"\nsaved profile {name!r} to {store.path}")
-    if store.active == name:
-        print(f"profile {name!r} is now active")
+
+    print(term.heading("Saved"))
+    print(term.rule())
+    _print_profile(profile, active=store.active == profile.name)
+    print(term.dim(f"\n   file: {store.path}"))
+    print(term.heading("Next"))
+    print(f"   {term.bold('xsync codex --init')}     connect Codex to this endpoint")
+    print(f"   {term.bold('xsync codex --dry-run')}  see what would change")
+    print(f"   {term.bold('xsync codex')}            write the catalog\n")
     return EXIT_OK
 
 
+def _print_model_table(models: list) -> None:
+    """Show the models in a table."""
+    if not models:
+        _warn("no model passes the filters.")
+        return
+    slug_size = max(len(m.slug) for m in models)
+    print()
+    print(
+        "   "
+        + term.dim(term.pad("MODEL", slug_size))
+        + term.dim("  " + "CONTEXT".rjust(12))
+        + term.dim("  FEATURES")
+    )
+    for model in models:
+        window = f"{model.context_window:,}" if model.context_window else "—"
+        flags = " ".join(
+            term.green(flag)
+            for flag, on in (
+                ("tools", model.tools),
+                ("reason", model.reasoning),
+                ("vision", model.vision),
+                ("search", model.search),
+            )
+            if on
+        )
+        print(
+            "   "
+            + term.pad(model.slug, slug_size)
+            + "  "
+            + window.rjust(12)
+            + "  "
+            + (flags or term.dim("—"))
+        )
+    print()
+
+
+def _print_profile(profile: Profile, active: bool) -> None:
+    """Show one profile as a block."""
+    mark = term.green("●") if active else term.dim("○")
+    label = term.bold(profile.name) + (term.dim("  (active)") if active else "")
+    print(f"{mark} {label}")
+    rows = [
+        ("url", profile.base_url),
+        ("key", term.mask_key(profile.api_key)
+            if profile.api_key
+            else (f"${profile.api_key_env}" if profile.api_key_env else "(none)")),
+        ("wire api", profile.wire_api),
+    ]
+    if profile.include:
+        rows.append(("include", ", ".join(profile.include)))
+    if profile.exclude:
+        rows.append(("exclude", ", ".join(profile.exclude)))
+    for key, value in rows:
+        print(f"   {term.dim(key.ljust(9))} {value}")
+
+
 def cmd_list(args: argparse.Namespace) -> int:
     """Show the profiles."""
     store = open_store()
     if not store.names():
-        print("no profile exists. Run `xsync setup` first.")
+        print(term.heading("No profile"))
+        print(f"   run {term.bold('xsync setup')} to make one.\n")
         return EXIT_OK
+    print(term.heading("Profiles"))
+    print(term.rule())
     for name in store.names():
-        mark = "*" if name == store.active else " "
-        profile = store.get(name)
-        print(f"{mark} {name:<20} {profile.base_url:<40} {profile.wire_api}")
+        _print_profile(store.get(name), active=name == store.active)
+        print()
+    print(term.dim(f"   file: {store.path}\n"))
     return EXIT_OK
 
 
@@ -183,7 +309,17 @@ def _load_catalog(path: Path) -> dict | None:
         return None
 
 
-def _do_reset(codex_home: Path, profile_name: str, force: bool) -> int:
+def _confirm(question: str) -> bool:
+    """Ask for a yes. A pipe or a missing terminal gives no."""
+    if not getattr(sys.stdin, "isatty", lambda: False)():
+        return False
+    answer = input(f"{term.yellow('?')} {term.bold(question)} {term.dim('[yes/no]')}: ")
+    return answer.strip().lower() in ("y", "yes")
+
+
+def _do_reset(
+    codex_home: Path, profile_name: str, force: bool, assume_yes: bool = False
+) -> int:
     """Remove everything that xSync wrote."""
     state_path = codex_home / STATE_FILENAME
     state = read_state(state_path)
@@ -191,12 +327,25 @@ def _do_reset(codex_home: Path, profile_name: str, force: bool) -> int:
     if state is None:
         planned = known_removals(profile_name)
         if not force:
-            print("no state file exists. xSync would remove:")
+            print(term.heading("Reset without a state file"))
+            print(term.dim("   xsync would remove:"))
             for key in planned.keys_written:
-                print(f"  key    {key}")
+                print(f"   {term.red('-')} key    {key}")
             for block in planned.blocks_written:
-                print(f"  block  [{block}]")
-            print("\nadd --force to continue.", file=sys.stderr)
+                print(f"   {term.red('-')} block  [{block}]")
+            _fail("add --force to continue.")
+            return EXIT_ERROR
+        print(term.heading("Reset without a state file"))
+        print(term.dim("   xsync did not record this setup. It would remove:"))
+        for key in planned.keys_written:
+            print(f"   {term.red('-')} key    {key}")
+        for block in planned.blocks_written:
+            print(f"   {term.red('-')} block  [{block}]")
+        print(term.dim("\n   The catalog backup <name>.bak stays on the disk."))
+        if not assume_yes and not _confirm(
+            f"Remove the Codex setup of {profile_name!r}?"
+        ):
+            _fail("stopped. Nothing was removed.")
             return EXIT_ERROR
         state = State(
             profile=profile_name,
@@ -209,9 +358,13 @@ def _do_reset(codex_home: Path, profile_name: str, force: bool) -> int:
 
     removed = reset_config(codex_home / "config.toml", state)
     clear_state(state_path)
+    print(term.heading("Reset"))
+    print(term.rule())
     for name in removed:
-        print(f"removed {name}")
-    print("Codex is back at its own defaults.")
+        print(f"   {term.red('-')} {name}")
+    print(term.rule())
+    _ok("Codex is back at its own defaults.")
+    print()
     return EXIT_OK
 
 
@@ -229,7 +382,7 @@ def cmd_codex(args: argparse.Namespace) -> int:
 
     if args.reset:
         try:
-            return _do_reset(codex_home, profile.name, args.force)
+            return _do_reset(codex_home, profile.name, args.force, args.yes)
         except ConfigError as error:
             print(f"error: {error}", file=sys.stderr)
             return EXIT_ERROR
@@ -244,7 +397,10 @@ def cmd_codex(args: argparse.Namespace) -> int:
             print(f"error: {error}", file=sys.stderr)
             return EXIT_ERROR
         write_state(codex_home / STATE_FILENAME, state)
-        print(f"Codex now routes to {profile.name!r} ({profile.base_url})")
+        _ok(
+            f"Codex now routes to {term.bold(profile.name)} "
+            f"{term.dim('(' + profile.base_url + ')')}"
+        )
 
     try:
         api_key = profile.resolve_key(os.environ)
@@ -262,24 +418,60 @@ def cmd_codex(args: argparse.Namespace) -> int:
     message = check_provider_match(config, profile)
     if message:
         if args.dry_run:
-            print(f"warning:\n{message}\n")
+            _warn(message)
+            print()
         else:
-            print(f"error:\n{message}", file=sys.stderr)
+            _fail(message)
             return EXIT_ERROR
 
     catalog = render_catalog(models, load_rules())
     report = diff_catalogs(_load_catalog(catalog_path), catalog)
-    print(report.render())
+    _print_report(report, profile, len(catalog["models"]))
 
     if args.dry_run:
-        print("no files written (--dry-run)")
+        print(term.dim("   no file written (--dry-run)\n"))
         return EXIT_OK
 
     write_json_atomic(catalog_path, catalog)
-    print(f"wrote {len(catalog['models'])} models to {catalog_path}")
+    _ok(
+        f"wrote {term.bold(str(len(catalog['models'])))} models to "
+        f"{term.dim(str(catalog_path))}"
+    )
+    print()
     return EXIT_OK
 
 
+def _print_report(report, profile: Profile, total: int) -> None:
+    """Show the difference of one sync."""
+    print(term.heading(f"Sync {profile.name} → Codex"))
+    print(term.dim(f"   {profile.base_url}"))
+    print(term.rule())
+
+    if report.is_empty:
+        _ok(f"up to date. {term.bold(str(total))} models, no change")
+        return
+
+    for slug in report.added:
+        print(f"   {term.green('+')} {slug}")
+    for slug in report.removed:
+        print(f"   {term.red('-')} {term.dim(slug)}")
+    for slug, fields in report.changed:
+        head = ", ".join(fields[:3])
+        more = f" +{len(fields) - 3} more" if len(fields) > 3 else ""
+        print(f"   {term.yellow('~')} {slug}{term.dim(f'  ({head}{more})')}")
+
+    print(term.rule())
+    parts = []
+    if report.added:
+        parts.append(term.green(f"{len(report.added)} added"))
+    if report.removed:
+        parts.append(term.red(f"{len(report.removed)} removed"))
+    if report.changed:
+        parts.append(term.yellow(f"{len(report.changed)} changed"))
+    parts.append(term.dim(f"{len(report.unchanged)} unchanged"))
+    print("   " + "   ".join(parts))
+
+
 EPILOG = """\
 examples:
   xsync setup                      make a profile, and read the model list
@@ -328,6 +520,9 @@ def build_parser() -> argparse.ArgumentParser:
         "--reset", action="store_true", help="remove everything xSync wrote"
     )
     codex.add_argument("--force", action="store_true", help="reset without a state file")
+    codex.add_argument(
+        "--yes", action="store_true", help="answer yes to the reset question"
+    )
     codex.set_defaults(func=cmd_codex)
 
     return parser

xsync_cli-0.1.2/src/xsync_cli/core/term.py

@@ -0,0 +1,115 @@
+"""The terminal style.
+
+The module writes ANSI codes only for a terminal. It writes plain text
+for a pipe, for a dumb terminal, and when the variable NO_COLOR holds a
+value. The variable FORCE_COLOR turns the color on again.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+
+RESET = "\x1b[0m"
+_CODES = {
+    "bold": "\x1b[1m",
+    "dim": "\x1b[2m",
+    "red": "\x1b[31m",
+    "green": "\x1b[32m",
+    "yellow": "\x1b[33m",
+    "blue": "\x1b[34m",
+    "magenta": "\x1b[35m",
+    "cyan": "\x1b[36m",
+}
+_ANSI = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _is_set(name: str) -> bool:
+    """True when the variable holds a value other than 0, false, or no."""
+    value = os.environ.get(name)
+    if value is None:
+        return False
+    return value.strip().lower() not in ("", "0", "false", "no")
+
+
+def supports_color() -> bool:
+    """True when the output accepts ANSI codes."""
+    # The rule of no-color.org: the variable disables the color when it
+    # is present and it is not empty. The value 0 also disables it.
+    if os.environ.get("NO_COLOR", "") != "":
+        return False
+    if _is_set("FORCE_COLOR"):
+        return True
+    if os.environ.get("TERM") == "dumb":
+        return False
+    stream = sys.stdout
+    return bool(getattr(stream, "isatty", lambda: False)())
+
+
+def paint(text: str, *names: str) -> str:
+    """Add one or more style codes to the text."""
+    if not names or not supports_color():
+        return text
+    prefix = "".join(_CODES[name] for name in names)
+    return f"{prefix}{text}{RESET}"
+
+
+def bold(text: str) -> str:
+    return paint(text, "bold")
+
+
+def dim(text: str) -> str:
+    return paint(text, "dim")
+
+
+def red(text: str) -> str:
+    return paint(text, "red")
+
+
+def green(text: str) -> str:
+    return paint(text, "green")
+
+
+def yellow(text: str) -> str:
+    return paint(text, "yellow")
+
+
+def blue(text: str) -> str:
+    return paint(text, "blue")
+
+
+def cyan(text: str) -> str:
+    return paint(text, "cyan")
+
+
+def width(text: str) -> int:
+    """The printed width of the text. The style codes count as nothing."""
+    return len(_ANSI.sub("", text))
+
+
+def pad(text: str, size: int) -> str:
+    """Add spaces on the right until the text fills the size."""
+    return text + " " * max(0, size - width(text))
+
+
+def rule(size: int = 64) -> str:
+    """A horizontal line."""
+    return dim("─" * size)
+
+
+def heading(title: str) -> str:
+    """A title line."""
+    return f"\n{bold(cyan(title))}"
+
+
+def mask_key(key: str | None) -> str:
+    """The first five characters of a key, and nothing more.
+
+    The function never shows the length of the key.
+    """
+    if not key:
+        return "(none)"
+    if len(key) <= 5:
+        return "…"
+    return f"{key[:5]}…"

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/tests/test_cli_codex.py

@@ -41,7 +41,7 @@ def test_dry_run_writes_nothing(home, monkeypatch, capsys):
     monkeypatch.setattr(cli, "fetch_models", stub(["a/one"]))
     assert cli.main(["codex", "--dry-run"]) == 0
     assert not (home / "p-models.json").exists()
-    assert "no files written" in capsys.readouterr().out
+    assert "no file written" in capsys.readouterr().out
 
 
 def test_the_report_names_the_added_models(home, monkeypatch, capsys):
@@ -139,3 +139,69 @@ def test_a_profile_override_uses_the_named_profile(home, monkeypatch):
     )
     monkeypatch.setattr(cli, "fetch_models", stub(["a/one"]))
     assert cli.main(["codex", "--profile", "q", "--dry-run"]) == 0
+
+
+def test_the_sync_output_names_the_profile_and_the_endpoint(home, monkeypatch, capsys):
+    monkeypatch.setattr(cli, "fetch_models", stub(["a/one"]))
+    cli.main(["codex", "--dry-run"])
+    out = capsys.readouterr().out
+    assert "p" in out
+    assert "http://h/v1" in out
+
+
+def test_the_sync_output_lists_added_models_on_their_own_lines(
+    home, monkeypatch, capsys
+):
+    monkeypatch.setattr(cli, "fetch_models", stub(["a/one", "b/two"]))
+    cli.main(["codex", "--dry-run"])
+    lines = capsys.readouterr().out.splitlines()
+    assert any(line.strip().endswith("a/one") for line in lines)
+    assert any(line.strip().endswith("b/two") for line in lines)
+
+
+def test_an_unchanged_sync_says_so(home, monkeypatch, capsys):
+    monkeypatch.setattr(cli, "fetch_models", stub(["a/one"]))
+    cli.main(["codex"])
+    capsys.readouterr()
+    cli.main(["codex", "--dry-run"])
+    assert "up to date" in capsys.readouterr().out
+
+
+def test_reset_force_asks_before_it_removes(home, monkeypatch, capsys):
+    asked = {}
+
+    def fake_input(prompt=""):
+        asked["prompt"] = prompt
+        return "no"
+
+    monkeypatch.setattr("builtins.input", fake_input)
+    monkeypatch.setattr(cli.sys.stdin, "isatty", lambda: True, raising=False)
+
+    (home / "config.toml").write_text(
+        'model_provider = "p"\nmodel_catalog_json = "/x.json"\n\n'
+        '[model_providers.p]\nbase_url = "http://h/v1"\n'
+    )
+    assert cli.main(["codex", "--reset", "--force"]) == 1
+    assert "p" in asked["prompt"]
+    assert "model_provider" in (home / "config.toml").read_text()
+
+
+def test_reset_force_removes_after_a_yes(home, monkeypatch):
+    monkeypatch.setattr("builtins.input", lambda prompt="": "yes")
+    monkeypatch.setattr(cli.sys.stdin, "isatty", lambda: True, raising=False)
+
+    (home / "config.toml").write_text(
+        'model_provider = "p"\nmodel_catalog_json = "/x.json"\n\n'
+        '[model_providers.p]\nbase_url = "http://h/v1"\n'
+    )
+    assert cli.main(["codex", "--reset", "--force"]) == 0
+    assert "model_provider" not in (home / "config.toml").read_text()
+
+
+def test_reset_force_needs_no_answer_without_a_terminal(home, monkeypatch):
+    monkeypatch.setattr(cli.sys.stdin, "isatty", lambda: False, raising=False)
+    (home / "config.toml").write_text(
+        'model_provider = "p"\nmodel_catalog_json = "/x.json"\n\n'
+        '[model_providers.p]\nbase_url = "http://h/v1"\n'
+    )
+    assert cli.main(["codex", "--reset", "--force", "--yes"]) == 0

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/tests/test_cli_profiles.py

@@ -20,8 +20,9 @@ def fake_fetch(models):
 
 
 def test_setup_writes_a_profile(store_path, monkeypatch, capsys):
-    answers = iter(["9router", "http://127.0.0.1:20128/v1", "sk-1", "", "", "responses"])
+    answers = iter(["9router", "http://127.0.0.1:20128/v1", "", "", "responses"])
     monkeypatch.setattr("builtins.input", lambda prompt="": next(answers))
+    monkeypatch.setattr(cli, "getpass", lambda prompt="": "sk-1")
     monkeypatch.setattr(cli, "fetch_models", fake_fetch(["a/one", "b/two"]))
 
     assert cli.main(["setup"]) == 0
@@ -31,8 +32,9 @@ def test_setup_writes_a_profile(store_path, monkeypatch, capsys):
 
 
 def test_setup_prints_the_models(store_path, monkeypatch, capsys):
-    answers = iter(["p", "http://h/v1", "", "", "", "chat"])
+    answers = iter(["p", "http://h/v1", "", "", "chat"])
     monkeypatch.setattr("builtins.input", lambda prompt="": next(answers))
+    monkeypatch.setattr(cli, "getpass", lambda prompt="": "")
     monkeypatch.setattr(cli, "fetch_models", fake_fetch(["a/one", "b/two"]))
 
     cli.main(["setup"])
@@ -43,8 +45,9 @@ def test_setup_prints_the_models(store_path, monkeypatch, capsys):
 
 
 def test_setup_never_prints_the_key(store_path, monkeypatch, capsys):
-    answers = iter(["p", "http://h/v1", "sk-secret-value", "", "", "chat"])
+    answers = iter(["p", "http://h/v1", "", "", "chat"])
     monkeypatch.setattr("builtins.input", lambda prompt="": next(answers))
+    monkeypatch.setattr(cli, "getpass", lambda prompt="": "sk-secret-value")
     monkeypatch.setattr(cli, "fetch_models", fake_fetch(["a/one"]))
 
     cli.main(["setup"])
@@ -54,8 +57,9 @@ def test_setup_never_prints_the_key(store_path, monkeypatch, capsys):
 def test_setup_stops_when_the_endpoint_fails(store_path, monkeypatch):
     from xsync_cli.sources.openai_compat import EndpointUnreachable
 
-    answers = iter(["p", "http://h/v1", "", "", "", "chat"])
+    answers = iter(["p", "http://h/v1", "", "", "chat"])
     monkeypatch.setattr("builtins.input", lambda prompt="": next(answers))
+    monkeypatch.setattr(cli, "getpass", lambda prompt="": "")
 
     def failing(*args, **kwargs):
         raise EndpointUnreachable("refused")
@@ -74,8 +78,9 @@ def test_list_marks_the_active_profile(store_path, capsys):
     )
     assert cli.main(["list"]) == 0
     out = capsys.readouterr().out
-    assert "* a" in out
-    assert "  b" in out
+    assert "a" in out and "b" in out
+    assert "(active)" in out
+    assert "http://a/v1" in out
 
 
 def test_use_switches_the_active_profile(store_path):
@@ -117,3 +122,55 @@ def test_the_help_names_the_profile_file(capsys):
 def test_the_help_shows_an_example(capsys):
     cli.main([])
     assert "xsync setup" in capsys.readouterr().out
+
+
+def test_setup_hides_the_key_while_the_user_types(store_path, monkeypatch, capsys):
+    asked = {}
+
+    def fake_getpass(prompt=""):
+        asked["prompt"] = prompt
+        return "sk-92465eb0c2f2e2d5"
+
+    answers = iter(["p", "http://h/v1", "", "", "chat"])
+    monkeypatch.setattr("builtins.input", lambda prompt="": next(answers))
+    monkeypatch.setattr(cli, "getpass", fake_getpass)
+    monkeypatch.setattr(cli, "fetch_models", fake_fetch(["a/one"]))
+
+    assert cli.main(["setup"]) == 0
+    assert "API key" in asked["prompt"]
+
+    out = capsys.readouterr().out
+    assert "sk-92…" in out
+    assert "sk-92465eb0c2f2e2d5" not in out
+
+
+def test_setup_never_shows_the_key_length(store_path, monkeypatch, capsys):
+    answers = iter(["p", "http://h/v1", "", "", "chat"])
+    monkeypatch.setattr("builtins.input", lambda prompt="": next(answers))
+    monkeypatch.setattr(cli, "getpass", lambda prompt="": "sk-92465eb0c2f2e2d5")
+    monkeypatch.setattr(cli, "fetch_models", fake_fetch(["a/one"]))
+
+    cli.main(["setup"])
+    out = capsys.readouterr().out
+    assert "18" not in out
+    assert "chars" not in out
+
+
+def test_setup_takes_the_wire_api_from_an_existing_provider(
+    store_path, tmp_path, monkeypatch, capsys
+):
+    codex = tmp_path / "codex"
+    codex.mkdir()
+    (codex / "config.toml").write_text(
+        '[model_providers.old]\n'
+        'base_url = "http://h/v1"\nwire_api = "responses"\n'
+    )
+    monkeypatch.setenv("CODEX_HOME", str(codex))
+
+    answers = iter(["p", "http://h/v1", "", "", ""])
+    monkeypatch.setattr("builtins.input", lambda prompt="": next(answers))
+    monkeypatch.setattr(cli, "getpass", lambda prompt="": "")
+    monkeypatch.setattr(cli, "fetch_models", fake_fetch(["a/one"]))
+
+    assert cli.main(["setup"]) == 0
+    assert 'wire_api = "responses"' in store_path.read_text()

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/tests/test_codex_config.py

@@ -102,3 +102,34 @@ def test_the_hash_changes_with_the_content(tmp_path):
     first = file_sha256(path)
     path.write_text("a = 2")
     assert file_sha256(path) != first
+
+
+def test_wire_api_for_a_known_url_is_found():
+    from xsync_cli.adapters.codex_config import wire_api_for_url
+
+    config = {
+        "model_providers": {
+            "9router": {
+                "base_url": "http://127.0.0.1:20128/v1",
+                "wire_api": "responses",
+            }
+        }
+    }
+    assert wire_api_for_url(config, "http://127.0.0.1:20128/v1") == "responses"
+
+
+def test_wire_api_ignores_a_trailing_slash():
+    from xsync_cli.adapters.codex_config import wire_api_for_url
+
+    config = {
+        "model_providers": {
+            "p": {"base_url": "http://h/v1/", "wire_api": "chat"}
+        }
+    }
+    assert wire_api_for_url(config, "http://h/v1") == "chat"
+
+
+def test_wire_api_for_an_unknown_url_is_none():
+    from xsync_cli.adapters.codex_config import wire_api_for_url
+
+    assert wire_api_for_url({}, "http://h/v1") is None

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/tests/test_codex_wiring.py

@@ -102,7 +102,7 @@ def test_reset_removes_only_the_recorded_items(tmp_path):
     assert data["model_reasoning_effort"] == "max"
 
 
-def test_reset_deletes_the_catalog_file(tmp_path):
+def test_reset_deletes_the_catalog_but_not_the_backup(tmp_path):
     config = tmp_path / "config.toml"
     config.write_text(EXISTING)
     catalog = tmp_path / "c.json"
@@ -113,7 +113,7 @@ def test_reset_deletes_the_catalog_file(tmp_path):
 
     reset_config(config, state)
     assert not catalog.exists()
-    assert not backup.exists()
+    assert backup.exists()
 
 
 def test_the_hash_guard_stops_a_concurrent_edit(tmp_path, monkeypatch):
@@ -141,3 +141,19 @@ def test_known_removals_names_the_standard_keys():
     state = known_removals("9router")
     assert "model_catalog_json" in state.keys_written
     assert "model_providers.9router" in state.blocks_written
+
+
+def test_reset_keeps_the_backup_of_the_catalog(tmp_path):
+    config = tmp_path / "config.toml"
+    config.write_text(EXISTING)
+    catalog = tmp_path / "c.json"
+    catalog.write_text('{"models": []}')
+    backup = tmp_path / "c.json.bak"
+    backup.write_text('{"models": ["old"]}')
+    state = init_config(config, profile(), catalog, "sk-1")
+
+    reset_config(config, state)
+
+    assert not catalog.exists()
+    assert backup.exists(), "the backup is the only way back. Keep it."
+    assert backup.read_text() == '{"models": ["old"]}'

xsync_cli-0.1.2/tests/test_term.py

@@ -0,0 +1,96 @@
+import io
+
+import pytest
+
+from xsync_cli.core import term
+
+
+@pytest.fixture(autouse=True)
+def plain_env(monkeypatch):
+    monkeypatch.delenv("NO_COLOR", raising=False)
+    monkeypatch.delenv("FORCE_COLOR", raising=False)
+    monkeypatch.setenv("TERM", "xterm-256color")
+
+
+def as_tty(monkeypatch, value: bool):
+    stream = io.StringIO()
+    monkeypatch.setattr(stream, "isatty", lambda: value, raising=False)
+    monkeypatch.setattr(term.sys, "stdout", stream)
+
+
+def test_color_is_on_for_a_terminal(monkeypatch):
+    as_tty(monkeypatch, True)
+    assert term.supports_color() is True
+
+
+def test_color_is_off_for_a_pipe(monkeypatch):
+    as_tty(monkeypatch, False)
+    assert term.supports_color() is False
+
+
+def test_no_color_turns_the_color_off(monkeypatch):
+    as_tty(monkeypatch, True)
+    monkeypatch.setenv("NO_COLOR", "1")
+    assert term.supports_color() is False
+
+
+def test_a_dumb_terminal_gets_no_color(monkeypatch):
+    as_tty(monkeypatch, True)
+    monkeypatch.setenv("TERM", "dumb")
+    assert term.supports_color() is False
+
+
+def test_style_adds_a_code_for_a_terminal(monkeypatch):
+    as_tty(monkeypatch, True)
+    assert term.green("ok") == "\x1b[32mok\x1b[0m"
+
+
+def test_style_adds_nothing_for_a_pipe(monkeypatch):
+    as_tty(monkeypatch, False)
+    assert term.green("ok") == "ok"
+
+
+def test_every_style_keeps_the_text(monkeypatch):
+    as_tty(monkeypatch, False)
+    for style in (term.bold, term.dim, term.green, term.red, term.yellow, term.cyan):
+        assert style("text") == "text"
+
+
+def test_the_width_of_a_styled_string_ignores_the_codes(monkeypatch):
+    as_tty(monkeypatch, True)
+    assert term.width(term.green("abc")) == 3
+
+
+def test_mask_key_keeps_the_first_five_characters():
+    assert term.mask_key("sk-92465eb0c2f2e2d5") == "sk-92…"
+
+
+def test_mask_key_of_a_short_key_shows_no_character():
+    assert term.mask_key("abc") == "…"
+
+
+def test_mask_key_of_no_key_says_none():
+    assert term.mask_key(None) == "(none)"
+    assert term.mask_key("") == "(none)"
+
+
+def test_rule_fills_the_width(monkeypatch):
+    as_tty(monkeypatch, False)
+    assert term.rule(10) == "─" * 10
+
+
+def test_a_heading_holds_the_title(monkeypatch):
+    as_tty(monkeypatch, False)
+    assert "Profiles" in term.heading("Profiles")
+
+
+def test_force_color_zero_does_not_turn_the_color_on(monkeypatch):
+    as_tty(monkeypatch, False)
+    monkeypatch.setenv("FORCE_COLOR", "0")
+    assert term.supports_color() is False
+
+
+def test_no_color_zero_still_turns_the_color_off(monkeypatch):
+    as_tty(monkeypatch, True)
+    monkeypatch.setenv("NO_COLOR", "0")
+    assert term.supports_color() is False

{xsync_cli-0.1.1 → xsync_cli-0.1.2}/uv.lock

@@ -74,7 +74,7 @@ wheels = [
 
 [[package]]
 name = "xsync-cli"
-version = "0.1.0"
+version = "0.1.1"
 source = { editable = "." }
 dependencies = [
     { name = "tomlkit" },