chatup 0.2.22__tar.gz → 0.2.23__tar.gz

{chatup-0.2.22/src/chatup.egg-info → chatup-0.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatup
-Version: 0.2.22
+Version: 0.2.23
 Summary: ChatArch setup CLI extracted from ChatTool
 Author-email: rexwzh <1073853456@qq.com>
 License-Expression: MIT
@@ -18,6 +18,7 @@ Requires-Dist: chatstyle[tui]<0.3.0,>=0.2.0
 Requires-Dist: chatenv<0.3.0,>=0.2.11
 Requires-Dist: ChatGlance<0.4.0,>=0.3.0
 Requires-Dist: python-dotenv<2.0,>=1.0
+Requires-Dist: tomlkit<1.0,>=0.13
 Requires-Dist: colorama
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"

{chatup-0.2.22 → chatup-0.2.23}/pyproject.toml

@@ -15,6 +15,7 @@ dependencies = [
     "chatenv>=0.2.11,<0.3.0",
     "ChatGlance>=0.3.0,<0.4.0",
     "python-dotenv>=1.0,<2.0",
+    "tomlkit>=0.13,<1.0",
     "colorama",
 ]
 authors = [{name = "rexwzh", email = "1073853456@qq.com"}]

{chatup-0.2.22 → chatup-0.2.23}/src/chatup/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.22"
+__version__ = "0.2.23"

{chatup-0.2.22 → chatup-0.2.23}/src/chatup/runtime/playwright.py

@@ -11,7 +11,12 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
-from chatup.setup.nodejs import MIN_NODEJS_MAJOR, _detect_nodejs_runtime
+from chatup.setup.nodejs import (
+    MIN_NODEJS_MAJOR,
+    _detect_nodejs_runtime,
+    node_runtime_env,
+    npm_command_for_runtime,
+)
 
 from ._managed_artifact import (
     ManagedArtifactError,
@@ -133,9 +138,7 @@ def _resolve_node_runtime(runtime_resolver: RuntimeResolver) -> dict[str, Any]:
 
 
 def _command_env(runtime: dict[str, Any], browsers_dir: Path) -> dict[str, str]:
-    env = dict(os.environ)
-    node_bin = Path(str(runtime["node_bin"]))
-    env["PATH"] = str(node_bin.parent) + os.pathsep + env.get("PATH", "")
+    env = node_runtime_env(runtime)
     env["PLAYWRIGHT_BROWSERS_PATH"] = str(browsers_dir)
     env["PLAYWRIGHT_SKIP_BROWSER_GC"] = "1"
     return env
@@ -168,16 +171,18 @@ def _install_with_npm(
     env = _command_env(runtime, browsers_dir)
 
     npm_result = runner(
-        [
-            str(runtime["npm_bin"]),
-            "install",
-            "--prefix",
-            str(package_dir),
-            "--ignore-scripts",
-            "--no-audit",
-            "--no-fund",
-            f"playwright@{version}",
-        ],
+        npm_command_for_runtime(
+            runtime,
+            [
+                "install",
+                "--prefix",
+                str(package_dir),
+                "--ignore-scripts",
+                "--no-audit",
+                "--no-fund",
+                f"playwright@{version}",
+            ],
+        ),
         cwd=staging_dir,
         env=env,
         timeout=600,

{chatup-0.2.22 → chatup-0.2.23}/src/chatup/setup/claude.py

@@ -1,4 +1,5 @@
 import json
+import os
 from pathlib import Path
 
 from chatup.utils.platforming import chmod_private
@@ -7,6 +8,13 @@ DEFAULT_BASE_URL = "https://api.anthropic.com/v1"
 DEFAULT_SMALL_FAST_MODEL = "claude-opus-4-6"
 
 
+def resolve_claude_home() -> Path:
+    override = os.getenv("CLAUDE_CONFIG_DIR")
+    if override:
+        return Path(override).expanduser().resolve()
+    return Path.home() / ".claude"
+
+
 def _mask_secret(value):
     if not value:
         return ""
@@ -82,7 +90,7 @@ def setup_claude(
     from chatup.interaction import BACK_VALUE
 
     logger = setup_logger("setup_claude", log_level=str(log_level).upper())
-    claude_dir = Path.home() / ".claude"
+    claude_dir = resolve_claude_home()
     existing = _load_existing_claude_config(claude_dir)
     existing_auth = existing.get("auth_token")
     logger.info("Start claude setup")
@@ -214,22 +222,38 @@ def setup_claude(
 
     claude_dir.mkdir(parents=True, exist_ok=True)
 
-    settings_json = {
-        "env": {
+    settings_path = claude_dir / "settings.json"
+    try:
+        settings_json = json.loads(settings_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError, json.JSONDecodeError):
+        settings_json = {}
+    if not isinstance(settings_json, dict):
+        settings_json = {}
+    settings_env = settings_json.get("env")
+    if not isinstance(settings_env, dict):
+        settings_env = {}
+        settings_json["env"] = settings_env
+    settings_env.update(
+        {
             "ANTHROPIC_AUTH_TOKEN": auth_token,
             "ANTHROPIC_BASE_URL": base_url,
             "ANTHROPIC_SMALL_FAST_MODEL": small_fast_model,
         }
-    }
-    settings_path = claude_dir / "settings.json"
+    )
     settings_path.write_text(
         json.dumps(settings_json, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
     )
     chmod_private(settings_path)
     logger.info(f"Wrote settings file: {settings_path}")
 
-    config_json = {"primaryApiKey": primary_api_key}
     config_path = claude_dir / "config.json"
+    try:
+        config_json = json.loads(config_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError, json.JSONDecodeError):
+        config_json = {}
+    if not isinstance(config_json, dict):
+        config_json = {}
+    config_json["primaryApiKey"] = primary_api_key
     config_path.write_text(
         json.dumps(config_json, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
     )

{chatup-0.2.22 → chatup-0.2.23}/src/chatup/setup/codex.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import re
 import tempfile
 import click
+import tomlkit
 from dotenv import dotenv_values
 
 from chatenv.configs import OpenAIConfig
@@ -32,7 +33,7 @@ from chatup.utils.platforming import chmod_private
 
 DEFAULT_MODEL = "gpt-5.6-terra"
 DEFAULT_BASE_URL = "https://api.openai.com/v1"
-DEFAULT_AUTH_METHOD = "apikey"
+DEFAULT_FORCED_LOGIN_METHOD = "api"
 _ENV_VAR_REF_RE = re.compile(r"\$(?:\{[^}]+\}|[A-Za-z_][A-Za-z0-9_]*)")
 logger = setup_logger("setup_codex")
 
@@ -54,9 +55,17 @@ def _mask_secret(value):
     return f"{value[:3]}{'*' * (len(value) - 7)}{value[-4:]}"
 
 
+def resolve_codex_home() -> Path:
+    """Return the native Codex configuration root without changing user defaults."""
+    configured_home = os.getenv("CODEX_HOME")
+    if configured_home and configured_home.strip():
+        return Path(configured_home).expanduser()
+    return Path.home() / ".codex"
+
+
 def _load_existing_codex_config(codex_dir):
     existing = {
-        "preferred_auth_method": None,
+        "forced_login_method": None,
         "openai_api_key": None,
         "model": None,
         "base_url": None,
@@ -96,7 +105,7 @@ def _load_existing_codex_config(codex_dir):
                 value = value[1:-1]
             values[(section, key)] = value
 
-        existing["preferred_auth_method"] = values.get((None, "preferred_auth_method"))
+        existing["forced_login_method"] = values.get((None, "forced_login_method"))
         existing["model"] = values.get((None, "model"))
         provider_name = values.get((None, "model_provider"))
         if provider_name:
@@ -185,32 +194,62 @@ def _upsert_toml_section(content: str, section: str | None, values: dict) -> tup
     return "\n".join(output).rstrip() + "\n", changed
 
 
+def _remove_root_toml_keys(content: str, keys: set[str]) -> tuple[str, list[str]]:
+    """Remove only obsolete root-level keys while retaining other TOML tables."""
+    output: list[str] = []
+    removed: list[str] = []
+    section: str | None = None
+    for raw_line in content.splitlines():
+        stripped = raw_line.strip()
+        if stripped.startswith("[") and stripped.endswith("]"):
+            section = stripped[1:-1].strip()
+        elif section is None and "=" in stripped and not stripped.startswith("#"):
+            key = stripped.split("=", 1)[0].strip()
+            if key in keys:
+                removed.append(key)
+                continue
+        output.append(raw_line)
+    return "\n".join(output).rstrip() + "\n", removed
+
+
 def _write_codex_config(config_path: Path, *, model: str, base_url: str) -> list[str]:
     content = config_path.read_text(encoding="utf-8") if config_path.exists() else ""
-    content, changed_root = _upsert_toml_section(
-        content,
-        None,
-        {
-            "model_provider": "crs",
-            "model": model,
-            "preferred_auth_method": DEFAULT_AUTH_METHOD,
-        },
-    )
-    content, changed_provider = _upsert_toml_section(
-        content,
-        "model_providers.crs",
-        {
-            "name": "crs",
-            "base_url": base_url,
-            "wire_api": "responses",
-            "requires_openai_auth": True,
-        },
-    )
-    config_path.parent.mkdir(parents=True, exist_ok=True)
-    config_path.write_text(content, encoding="utf-8")
-    chmod_private(config_path)
+    try:
+        document = tomlkit.parse(content)
+    except tomlkit.exceptions.ParseError:
+        raise click.ClickException("Existing Codex config.toml is invalid; it was not modified.") from None
+    changed = []
+    if "preferred_auth_method" in document:
+        del document["preferred_auth_method"]
+        changed.append("preferred_auth_method")
+    root_values = {
+        "model_provider": "crs",
+        "model": model,
+        "forced_login_method": DEFAULT_FORCED_LOGIN_METHOD,
+    }
+    for key, value in root_values.items():
+        if document.get(key) != value:
+            changed.append(key)
+        document[key] = value
+    providers = document.setdefault("model_providers", tomlkit.table())
+    if not isinstance(providers, (tomlkit.items.Table, tomlkit.items.InlineTable)):
+        raise click.ClickException("Codex model_providers must be a TOML table; config was not modified.")
+    provider = providers.setdefault("crs", tomlkit.table())
+    if not isinstance(provider, (tomlkit.items.Table, tomlkit.items.InlineTable)):
+        raise click.ClickException("Codex model_providers.crs must be a TOML table; config was not modified.")
+    values = {
+        "name": "crs",
+        "base_url": base_url,
+        "wire_api": "responses",
+        "requires_openai_auth": True,
+    }
+    for key, value in values.items():
+        if provider.get(key) != value:
+            changed.append("model_providers.crs." + key)
+        provider[key] = value
+    _write_private_text(config_path, tomlkit.dumps(document))
     logger.info(f"Patched config file: {config_path}")
-    return changed_root + changed_provider
+    return changed
 
 
 def _write_private_text(path: Path, content: str) -> None:
@@ -364,7 +403,7 @@ def setup_codex(
     log_level="INFO",
 ):
     _configure_logger(log_level)
-    codex_dir = Path.home() / ".codex"
+    codex_dir = resolve_codex_home()
     existing = _load_existing_codex_config(codex_dir)
     env_values, typed_env_values = split_config_sources(
         OpenAIConfig,

{chatup-0.2.22 → chatup-0.2.23}/src/chatup/setup/cursor_agent.py

@@ -17,6 +17,7 @@ from chatup.utils.custom_logger import setup_logger
 from chatup.utils.platforming import chmod_executable, chmod_private, is_windows, user_bin_candidates
 
 DEFAULT_INSTALL_URL = "https://cursor.com/install"
+WINDOWS_INSTALL_COMMAND = "irm 'https://cursor.com/install?win32=true' | iex"
 CREDENTIAL_STORE_CHOICES = ("native", "file-wrapper")
 CURSOR_ACCESS_TOKEN_KEY = "CURSOR_ACCESS_TOKEN"
 CURSOR_REFRESH_TOKEN_KEY = "CURSOR_REFRESH_TOKEN"
@@ -167,12 +168,20 @@ def _resolve_command_or_user_bin(name: str) -> Path | None:
         candidates.append(Path(found).expanduser())
     candidates.extend(user_bin_candidates(name))
     if is_windows():
+        local_app_data = os.environ.get("LOCALAPPDATA")
         candidates.extend(
             [
                 Path.home() / ".local" / "bin" / f"{name}.cmd",
                 Path.home() / ".local" / "bin" / f"{name}.bat",
             ]
         )
+        if local_app_data:
+            candidates.extend(
+                [
+                    Path(local_app_data) / "cursor-agent" / f"{name}.cmd",
+                    Path(local_app_data) / "cursor-agent" / f"{name}.exe",
+                ]
+            )
     for candidate in candidates:
         if candidate.exists() and (is_windows() or os.access(candidate, os.X_OK)):
             return candidate
@@ -311,9 +320,40 @@ def _install_cursor_agent_if_needed(*, install_url: str = DEFAULT_INSTALL_URL) -
     if _resolve_cursor_agent_binary():
         return False
     if is_windows():
-        raise click.ClickException(
-            "Cursor Agent was not found on PATH. Install Cursor Agent for Windows first, then rerun ChatUp."
+        if install_url != DEFAULT_INSTALL_URL:
+            raise click.ClickException("Windows Cursor Agent installs use the official Cursor installer URL only.")
+        local_app_data = os.environ.get("LOCALAPPDATA")
+        if not local_app_data:
+            raise click.ClickException("LOCALAPPDATA is required for the Windows Cursor Agent installer.")
+        target = Path(local_app_data) / "cursor-agent"
+        if target.exists() or target.is_symlink():
+            raise click.ClickException(
+                f"The official Cursor installer deletes the existing directory {target}; "
+                "refusing to run automatically. Preserve or migrate it manually first."
+            )
+        script = subprocess.run(
+            [
+                "powershell",
+                "-NoProfile",
+                "-NonInteractive",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                WINDOWS_INSTALL_COMMAND,
+            ],
+            text=True,
+            capture_output=True,
+            timeout=300,
         )
+        if script.returncode != 0:
+            raise click.ClickException(
+                f"Cursor Agent Windows installer failed (exit {script.returncode}); see the official installer logs."
+            )
+        if not _resolve_cursor_agent_binary():
+            raise click.ClickException(
+                "Cursor Agent Windows installer finished but cursor-agent was not found in PATH or %LOCALAPPDATA%\\cursor-agent."
+            )
+        return True
     script = subprocess.run(
         ["bash", "-lc", f"curl -fsSL {install_url!r} | bash"],
         text=True,

{chatup-0.2.22 → chatup-0.2.23}/src/chatup/setup/elements.py

@@ -1271,7 +1271,7 @@ SETUP_COMMAND_ELEMENTS = (
     ),
     SetupCommandElement(
         name="nodejs",
-        help="Install nvm and Node.js (default LTS).",
+        help="Install default LTS Node.js (nvm on POSIX; ChatArch portable ZIP on Windows).",
         callback=nodejs_setup,
         options=(
             LOG_LEVEL_OPTION,
@@ -1340,7 +1340,7 @@ SETUP_COMMAND_ELEMENTS = (
     ),
     SetupCommandElement(
         name="codex",
-        help="Configure Codex CLI and config files.",
+        help="Configure Codex CLI and config files (uses CODEX_HOME when set).",
         callback=codex_setup,
         options=(
             LOG_LEVEL_OPTION,

{chatup-0.2.22 → chatup-0.2.23}/src/chatup/setup/frp.py

@@ -32,10 +32,10 @@ def _configure_logger(log_level="INFO"):
 
 
 def get_system_arch():
-    arch = platform.machine()
-    if arch == "x86_64":
+    arch = platform.machine().lower()
+    if arch in {"x86_64", "amd64"}:
         return "amd64"
-    elif arch == "aarch64":
+    elif arch in {"aarch64", "arm64"}:
         return "arm64"
     elif arch == "armv7l":
         return "arm"
@@ -139,6 +139,8 @@ def setup_frp(interactive=None, log_level="INFO"):
     work_dir.mkdir(parents=True, exist_ok=True)
 
     final_bin_path = work_dir / binary_name
+    if final_bin_path.exists() or final_bin_path.is_symlink():
+        raise click.ClickException(f"Refusing to overwrite existing FRP binary: {final_bin_path}")
 
     if install_method == "Download":
         version = ask_text("Enter FRP Version:", default=FRP_VERSION_DEFAULT)
@@ -161,8 +163,7 @@ def setup_frp(interactive=None, log_level="INFO"):
                 shutil.copy2(extracted_bin, final_bin_path)
             except Exception as e:
                 logger.error(f"Error downloading or extracting FRP: {e}")
-                print(f"Error downloading/extracting: {e}")
-                return
+                raise click.ClickException(f"Error downloading/extracting FRP: {e}") from e
 
     else:  # Local File
         local_path = ask_path("Enter path to local FRP archive (tar.gz or zip):")
@@ -171,8 +172,7 @@ def setup_frp(interactive=None, log_level="INFO"):
 
         if not os.path.exists(local_path):
             logger.error(f"Local FRP archive not found: {local_path}")
-            print("File not found.")
-            return
+            raise click.ClickException(f"FRP archive not found: {local_path}")
 
         with tempfile.TemporaryDirectory() as tmpdir:
             try:
@@ -180,8 +180,7 @@ def setup_frp(interactive=None, log_level="INFO"):
                 shutil.copy2(extracted_bin, final_bin_path)
             except Exception as e:
                 logger.error(f"Error extracting FRP from local archive: {e}")
-                print(f"Error extracting: {e}")
-                return
+                raise click.ClickException(f"Error extracting FRP: {e}") from e
 
     logger.info(f"FRP binary installed at: {final_bin_path}")
     print(f"FRP binary installed at: {final_bin_path}")
@@ -255,6 +254,8 @@ auth.token = "{token}"
 """
 
     config_path = work_dir / config_name
+    if config_path.exists() or config_path.is_symlink():
+        raise click.ClickException(f"Refusing to overwrite existing FRP configuration: {config_path}")
     with open(config_path, "w") as f:
         f.write(config_content)
 

{chatup-0.2.22 → chatup-0.2.23}/src/chatup/setup/hermes.py

@@ -16,13 +16,16 @@ from chatenv.source_chain import split_config_sources
 from chatup.const import CHATARCH_ENV_DIR
 from chatup.interaction import abort_if_force_without_tty, resolve_interactive_mode, resolve_value
 from chatup.utils.custom_logger import setup_logger
-from chatup.utils.platforming import chmod_private, is_windows, require_non_windows
+from chatup.utils.platforming import chmod_private, is_windows
 
 logger = setup_logger("setup_hermes")
 
 CHATARCH_HERMES_INSTALLER_URL = (
     "https://raw.githubusercontent.com/ChatArch/hermes-agent/main/scripts/install.sh"
 )
+CHATARCH_HERMES_WINDOWS_INSTALLER_URL = (
+    "https://raw.githubusercontent.com/ChatArch/hermes-agent/main/scripts/install.ps1"
+)
 DEFAULT_MODEL = "gpt-5.6-terra"
 DEFAULT_BASE_URL = "https://api.openai.com/v1"
 DEFAULT_WEBUI_HOST = "127.0.0.1"
@@ -59,19 +62,22 @@ def _sha256(path: Path) -> str:
 
 
 def _cache_installer_path() -> Path:
-    return Path.home() / ".cache" / "chatup" / "hermes" / "install.sh"
+    home = Path(os.environ.get("CHATARCH_HOME", str(Path.home() / ".chatarch"))).expanduser()
+    return home / "cache" / "chatup" / "hermes" / ("install.ps1" if is_windows() else "install.sh")
 
 
 def _packaged_installer_path() -> Path:
-    return Path(__file__).resolve().parent / "assets" / "hermes" / "install.sh"
+    name = "install.ps1" if is_windows() else "install.sh"
+    return Path(__file__).resolve().parent / "assets" / "hermes" / name
 
 
 def _download_installer() -> Path:
     target = _cache_installer_path()
     target.parent.mkdir(parents=True, exist_ok=True)
     tmp = target.with_suffix(".tmp")
+    url = CHATARCH_HERMES_WINDOWS_INSTALLER_URL if is_windows() else CHATARCH_HERMES_INSTALLER_URL
     logger.info("Downloading ChatArch Hermes installer")
-    with urllib.request.urlopen(CHATARCH_HERMES_INSTALLER_URL, timeout=60) as response:
+    with urllib.request.urlopen(url, timeout=60) as response:
         tmp.write_bytes(response.read())
     chmod_private(tmp)
     tmp.replace(target)
@@ -96,6 +102,11 @@ def _resolve_installer(installer: str | None, update_installer: bool) -> Path:
     if packaged.is_file():
         return packaged
 
+    if is_windows():
+        # The fork's PowerShell installer is the native Windows bootstrap;
+        # cache it under CHATARCH_HOME rather than falling back to Bash/WSL.
+        return _download_installer()
+
     raise click.ClickException(
         "Hermes installer is unavailable. Pass --installer PATH or run with --update-installer."
     )
@@ -329,10 +340,36 @@ def _hermes_installed(hermes_home: Path) -> bool:
 
 
 def _run_installer(installer_path: Path, hermes_home: Path) -> None:
-    require_non_windows("Hermes shell installer")
     env = os.environ.copy()
     env["HERMES_HOME"] = str(hermes_home)
-    command = ["bash", str(installer_path)]
+    if is_windows():
+        if installer_path.suffix.lower() != ".ps1":
+            raise click.ClickException("Windows Hermes installer must be a PowerShell .ps1 script.")
+        command = [
+            "powershell", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", str(installer_path),
+            "-NonInteractive", "-HermesHome", str(hermes_home), "-InstallDir", str(hermes_home / "hermes-agent"),
+        ]
+        readback = subprocess.run(command + ["-ShowResolvedPaths"], env=env, text=True, capture_output=True)
+        if readback.returncode != 0:
+            raise click.ClickException(f"Hermes Windows installer path readback failed (exit {readback.returncode}).")
+        try:
+            import json as _json
+            resolved = _json.loads(readback.stdout)
+            home_resolved = resolved.get("hermes_home")
+            install_resolved = resolved.get("install_dir")
+            if not isinstance(home_resolved, str) or not isinstance(install_resolved, str):
+                raise ValueError("missing installer path fields")
+            # Drive-letter case and slash direction may differ on Windows.
+            import ntpath
+            def same_path(a, b):
+                return ntpath.normcase(ntpath.normpath(str(a))) == ntpath.normcase(ntpath.normpath(str(b)))
+            if not same_path(home_resolved, hermes_home) or not same_path(install_resolved, hermes_home / "hermes-agent"):
+                raise ValueError("resolved Hermes paths differ from requested paths")
+        except (ValueError, TypeError):
+            raise click.ClickException("Hermes Windows installer path readback did not match the requested home/install directory.") from None
+        click.echo("Hermes installer resolved paths read back successfully.")
+    else:
+        command = ["bash", str(installer_path)]
     click.echo(f"Running Hermes installer: {_display_command(command)}")
     result = subprocess.run(command, env=env, text=True)
     if result.returncode != 0:

{chatup-0.2.22 → chatup-0.2.23}/src/chatup/setup/lark_cli.py

@@ -25,6 +25,7 @@ from chatup.interaction import (
 from chatup.setup.nodejs import (
     _detect_nodejs_runtime,
     ensure_nodejs_requirement,
+    managed_npm_launcher,
     run_npm_command,
     should_install_global_npm_package,
 )
@@ -229,7 +230,8 @@ def _run_lark_cli_command(
             text=True,
         )
 
-    command = shutil.which("lark-cli") or "lark-cli"
+    launcher = managed_npm_launcher(runtime, "lark-cli")
+    command = str(launcher) if launcher is not None else (shutil.which("lark-cli") or "lark-cli")
     return subprocess.run(
         [command, *args],
         input=input_text,