chatup 0.2.0__tar.gz → 0.2.1__tar.gz

{chatup-0.2.0/src/chatup.egg-info → chatup-0.2.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: chatup
-Version: 0.2.0
+Version: 0.2.1
 Summary: ChatArch setup CLI extracted from ChatTool
 Author-email: rexwzh <1073853456@qq.com>
 License-Expression: MIT
 Keywords: chatup,chatarch,setup,cli
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click>=8.0
@@ -25,8 +25,11 @@ ChatUp is the standalone ChatArch setup CLI. It is the first-level replacement f
 ```bash
 chatup --help
 chatup doctor
+chatup uv
 ```
 
+`chatup uv` installs `uv` through the official installer when needed, then creates the ChatArch Python environment with pip. Defaults are `--venv ~/.chatarch/venv` and `--python 3.12`; override them when a different runtime path or Python minor version is required.
+
 ## Development
 
 ```bash

{chatup-0.2.0 → chatup-0.2.1}/README.md

@@ -7,8 +7,11 @@ ChatUp is the standalone ChatArch setup CLI. It is the first-level replacement f
 ```bash
 chatup --help
 chatup doctor
+chatup uv
 ```
 
+`chatup uv` installs `uv` through the official installer when needed, then creates the ChatArch Python environment with pip. Defaults are `--venv ~/.chatarch/venv` and `--python 3.12`; override them when a different runtime path or Python minor version is required.
+
 ## Development
 
 ```bash

{chatup-0.2.0 → chatup-0.2.1}/pyproject.toml

@@ -7,7 +7,7 @@ name = "chatup"
 dynamic = ["version"]
 description = "ChatArch setup CLI extracted from ChatTool"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = "MIT"
 dependencies = [
     "click>=8.0",

{chatup-0.2.0 → chatup-0.2.1}/src/chatup/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{chatup-0.2.0 → chatup-0.2.1}/src/chatup/setup/elements.py

@@ -14,6 +14,7 @@ from chatup.setup.lark_cli import setup_lark_cli
 from chatup.setup.opencode import setup_opencode
 from chatup.setup.zsh import setup_zsh
 from chatup.setup.nodejs import setup_nodejs
+from chatup.setup.uv import DEFAULT_PYTHON_VERSION, DEFAULT_VENV_PATH, setup_uv
 from chatup.setup.workspace import setup_workspace
 
 
@@ -47,6 +48,10 @@ def nodejs_setup(interactive, log_level):
     setup_nodejs(interactive=interactive, log_level=log_level)
 
 
+def uv_setup(venv, python_version, force, log_level):
+    setup_uv(venv=venv, python_version=python_version, force=force, log_level=log_level)
+
+
 def docker_setup(sudo, interactive, log_level):
     setup_docker(interactive=interactive, use_sudo=sudo, log_level=log_level)
 
@@ -379,6 +384,37 @@ SETUP_COMMAND_ELEMENTS = (
             ),
         ),
     ),
+    SetupCommandElement(
+        name="uv",
+        help="Install uv and create the ChatArch Python 3.12 environment with pip.",
+        callback=uv_setup,
+        options=(
+            LOG_LEVEL_OPTION,
+            SetupOptionElement(
+                param_decls=("--venv", "--venv-path"),
+                kwargs={
+                    "default": str(DEFAULT_VENV_PATH),
+                    "show_default": True,
+                    "help": "Target ChatArch Python virtual environment path.",
+                },
+            ),
+            SetupOptionElement(
+                param_decls=("--python", "--python-version", "python_version"),
+                kwargs={
+                    "default": DEFAULT_PYTHON_VERSION,
+                    "show_default": True,
+                    "help": "Python version to install through uv and use for the venv.",
+                },
+            ),
+            SetupOptionElement(
+                param_decls=("--force", "-f"),
+                kwargs={
+                    "is_flag": True,
+                    "help": "Clear and recreate the target environment if it already exists.",
+                },
+            ),
+        ),
+    ),
     SetupCommandElement(
         name="codex",
         help="Configure Codex CLI and config files.",

chatup-0.2.1/src/chatup/setup/uv.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import os
+import shlex
+import shutil
+import subprocess
+from pathlib import Path
+
+import click
+
+from chatup.utils.custom_logger import setup_logger
+
+DEFAULT_PYTHON_VERSION = "3.12"
+DEFAULT_VENV_PATH = Path("~/.chatarch/venv")
+UV_INSTALLER_URL = "https://astral.sh/uv/install.sh"
+
+logger = setup_logger("setup_uv")
+
+
+def _configure_logger(log_level: str = "INFO"):
+    global logger
+    logger = setup_logger("setup_uv", log_level=str(log_level).upper())
+    return logger
+
+
+def _display_command(command: list[str] | tuple[str, ...]) -> str:
+    return " ".join(shlex.quote(str(part)) for part in command)
+
+
+def _run_command(command: list[str], **kwargs) -> subprocess.CompletedProcess[str]:
+    click.echo(f"Running: {_display_command(command)}")
+    return subprocess.run(command, capture_output=True, text=True, **kwargs)
+
+
+def _candidate_uv_paths() -> tuple[Path, ...]:
+    return (
+        Path.home() / ".local" / "bin" / "uv",
+        Path.home() / ".cargo" / "bin" / "uv",
+    )
+
+
+def find_uv() -> str | None:
+    uv = shutil.which("uv")
+    if uv:
+        return uv
+    for candidate in _candidate_uv_paths():
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return str(candidate)
+    return None
+
+
+def install_uv_with_official_script() -> str:
+    command = ["sh", "-c", f"curl -LsSf {shlex.quote(UV_INSTALLER_URL)} | sh"]
+    result = _run_command(command)
+    if result.returncode != 0:
+        message = (result.stderr or result.stdout or "uv installer failed").strip()
+        raise click.ClickException(f"Failed to install uv: {message}")
+
+    uv = find_uv()
+    if not uv:
+        raise click.ClickException(
+            "uv installer finished, but `uv` was not found on PATH or in ~/.local/bin. "
+            "Open a new shell or add the installer bin directory to PATH."
+        )
+    return uv
+
+
+def ensure_uv_installed() -> str:
+    uv = find_uv()
+    if uv:
+        click.echo(f"uv found: {uv}")
+        return uv
+
+    click.echo("uv not found; installing via the official uv installer script.")
+    uv = install_uv_with_official_script()
+    click.echo(f"uv installed: {uv}")
+    return uv
+
+
+def _venv_python_path(venv_path: Path) -> Path:
+    if os.name == "nt":
+        return venv_path / "Scripts" / "python.exe"
+    return venv_path / "bin" / "python"
+
+
+def _python_minor_version(python_bin: Path) -> str | None:
+    if not python_bin.exists():
+        return None
+    result = subprocess.run(
+        [str(python_bin), "-c", "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def _venv_has_pip(python_bin: Path) -> bool:
+    if not python_bin.exists():
+        return False
+    result = subprocess.run(
+        [str(python_bin), "-m", "pip", "--version"], capture_output=True, text=True
+    )
+    return result.returncode == 0
+
+
+def is_chatarch_python_ready(venv_path: Path, python_version: str) -> bool:
+    python_bin = _venv_python_path(venv_path)
+    current_version = _python_minor_version(python_bin)
+    return current_version == python_version and _venv_has_pip(python_bin)
+
+
+def create_chatarch_python_env(
+    uv_bin: str, venv_path: Path, python_version: str, *, force: bool = False
+) -> None:
+    install_result = _run_command([uv_bin, "python", "install", python_version])
+    if install_result.returncode != 0:
+        message = (install_result.stderr or install_result.stdout).strip()
+        raise click.ClickException(f"Failed to install Python {python_version} via uv: {message}")
+
+    command = [uv_bin, "venv", "--python", python_version, "--seed"]
+    if force:
+        command.extend(("--clear", "--force"))
+    elif venv_path.exists():
+        command.append("--allow-existing")
+    command.append(str(venv_path))
+    venv_result = _run_command(command)
+    if venv_result.returncode != 0:
+        message = (venv_result.stderr or venv_result.stdout).strip()
+        raise click.ClickException(f"Failed to create ChatArch Python env at {venv_path}: {message}")
+
+
+def setup_uv(
+    venv: str | None = None,
+    python_version: str = DEFAULT_PYTHON_VERSION,
+    force: bool = False,
+    log_level: str = "INFO",
+) -> dict[str, str]:
+    _configure_logger(log_level)
+    target = Path(venv or str(DEFAULT_VENV_PATH)).expanduser()
+    python_version = str(python_version).strip() or DEFAULT_PYTHON_VERSION
+
+    uv_bin = ensure_uv_installed()
+    click.echo(f"ChatArch Python env: {target}")
+    click.echo(f"Requested Python: {python_version}")
+
+    if is_chatarch_python_ready(target, python_version) and not force:
+        click.echo("ChatArch Python environment already ready.")
+        return {
+            "uv": uv_bin,
+            "venv": str(target),
+            "python": str(_venv_python_path(target)),
+            "python_version": python_version,
+            "status": "ready",
+        }
+
+    python_bin = _venv_python_path(target)
+    current_version = _python_minor_version(python_bin)
+    if target.exists() and not force:
+        if current_version is None:
+            raise click.ClickException(
+                f"Target path exists but is not a Python virtual environment: {target}. "
+                "Pass --force to clear it or choose another --venv path."
+            )
+        if current_version != python_version:
+            raise click.ClickException(
+                f"Existing ChatArch Python env at {target} uses Python {current_version}, "
+                f"but Python {python_version} was requested. Pass --force to recreate it "
+                "or choose another --venv path."
+            )
+        click.echo("ChatArch Python environment exists but pip is missing; seeding pip with uv.")
+    elif target.exists() and force:
+        click.echo("Recreating existing ChatArch Python environment with uv.")
+    else:
+        click.echo("ChatArch Python environment not found; creating it with uv.")
+
+    create_chatarch_python_env(uv_bin, target, python_version, force=force)
+
+    if not is_chatarch_python_ready(target, python_version):
+        raise click.ClickException(
+            f"ChatArch Python env was created at {target}, but Python {python_version} with pip was not verified."
+        )
+
+    python_bin = _venv_python_path(target)
+    click.echo(f"ChatArch Python environment ready: {target}")
+    click.echo(f"Activate with: source {shlex.quote(str(target / 'bin' / 'activate'))}")
+    click.echo(f"Verified pip: {python_bin} -m pip --version")
+    return {
+        "uv": uv_bin,
+        "venv": str(target),
+        "python": str(python_bin),
+        "python_version": python_version,
+        "status": "created",
+    }

{chatup-0.2.0 → chatup-0.2.1/src/chatup.egg-info}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: chatup
-Version: 0.2.0
+Version: 0.2.1
 Summary: ChatArch setup CLI extracted from ChatTool
 Author-email: rexwzh <1073853456@qq.com>
 License-Expression: MIT
 Keywords: chatup,chatarch,setup,cli
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click>=8.0
@@ -25,8 +25,11 @@ ChatUp is the standalone ChatArch setup CLI. It is the first-level replacement f
 ```bash
 chatup --help
 chatup doctor
+chatup uv
 ```
 
+`chatup uv` installs `uv` through the official installer when needed, then creates the ChatArch Python environment with pip. Defaults are `--venv ~/.chatarch/venv` and `--python 3.12`; override them when a different runtime path or Python minor version is required.
+
 ## Development
 
 ```bash

{chatup-0.2.0 → chatup-0.2.1}/src/chatup.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ src/chatup/setup/mode_prompt.py
 src/chatup/setup/nodejs.py
 src/chatup/setup/opencode.py
 src/chatup/setup/shell_rc.py
+src/chatup/setup/uv.py
 src/chatup/setup/workspace.py
 src/chatup/setup/zsh.py
 src/chatup/setup/assets/nvm.sh

{chatup-0.2.0 → chatup-0.2.1}/tests/test_pyproject_metadata.py

@@ -18,6 +18,7 @@ def _pyproject() -> dict:
 def test_chatup_depends_on_chatenv_without_registering_config_provider():
     data = _pyproject()
 
+    assert data["project"]["requires-python"] == ">=3.10"
     assert "chatstyle>=0.1.0,<0.2.0" in data["project"]["dependencies"]
     assert "chatenv>=0.2.0,<0.3.0" in data["project"]["dependencies"]
     assert "entry-points" not in data["project"] or "chatenv.configs" not in data["project"]["entry-points"]

chatup-0.2.1/tests/test_setup_cli.py

@@ -0,0 +1,218 @@
+from click.testing import CliRunner
+
+from chatup.cli import main
+
+
+def test_chatup_root_help_lists_setup_commands_without_setup_group_or_alias():
+    result = CliRunner().invoke(main, ["--help"])
+
+    assert result.exit_code == 0
+    for command in [
+        "workspace",
+        "nodejs",
+        "uv",
+        "codex",
+        "claude",
+        "opencode",
+        "hermes",
+        "lark-cli",
+        "docker",
+        "zsh",
+    ]:
+        assert command in result.output
+    assert "setup" not in result.output
+    assert "\n  alias " not in result.output
+
+
+def test_chatup_workspace_help_keeps_interactive_flags():
+    result = CliRunner().invoke(main, ["workspace", "--help"])
+
+    assert result.exit_code == 0
+    assert "--with-chattool" in result.output
+    assert "--with-chatblog" in result.output
+    assert "--with-memory" in result.output
+    assert "-i, --interactive" in result.output
+    assert "-I, --no-interactive" in result.output
+
+
+def test_top_level_setup_commands_expose_help():
+    commands = [
+        "cc-connect",
+        "chrome",
+        "claude",
+        "codex",
+        "docker",
+        "frp",
+        "hermes",
+        "lark-cli",
+        "nodejs",
+        "opencode",
+        "uv",
+        "workspace",
+        "zsh",
+    ]
+
+    for command in commands:
+        result = CliRunner().invoke(main, [command, "--help"])
+        assert result.exit_code == 0, command
+        assert "--help" in result.output
+        assert "Usage: chatup setup" not in result.output
+
+
+def test_setup_group_and_alias_command_are_not_registered():
+    setup_result = CliRunner().invoke(main, ["setup", "--help"])
+    alias_result = CliRunner().invoke(main, ["alias", "--help"])
+
+    assert setup_result.exit_code != 0
+    assert "No such command" in setup_result.output
+    assert alias_result.exit_code != 0
+    assert "No such command" in alias_result.output
+
+
+def test_opencode_no_longer_exposes_legacy_chatloop_preset():
+    result = CliRunner().invoke(main, ["opencode", "--help"])
+
+    assert result.exit_code == 0
+    assert "auto-loop" in result.output
+    assert "chatloop" not in result.output.lower()
+
+
+def test_cc_connect_installs_chatarch_package(monkeypatch):
+    import chatup.setup.cc_connect as cc_connect
+
+    commands = []
+    monkeypatch.setattr(cc_connect, "ensure_nodejs_requirement", lambda **kwargs: None)
+    monkeypatch.setattr(
+        cc_connect,
+        "should_install_global_npm_package",
+        lambda package_name, display_name, **kwargs: (
+            package_name == "@chatarch/cc-connect" and display_name == "cc-connect"
+        ),
+    )
+
+    class Result:
+        returncode = 0
+        stderr = ""
+
+    def fake_run_npm_command(args):
+        commands.append(args)
+        return Result()
+
+    monkeypatch.setattr(cc_connect, "run_npm_command", fake_run_npm_command)
+
+    result = CliRunner().invoke(main, ["cc-connect", "-I"])
+
+    assert result.exit_code == 0, result.output
+    assert commands == [["install", "-g", "@chatarch/cc-connect"]]
+
+
+def test_uv_help_exposes_defaults():
+    result = CliRunner().invoke(main, ["uv", "--help"])
+
+    assert result.exit_code == 0
+    assert "--venv" in result.output
+    assert "--python" in result.output
+    assert "~/.chatarch/venv" in result.output or "/.chatarch/venv" in result.output
+    assert "3.12" in result.output
+    assert "--force" in result.output
+
+
+def test_uv_setup_creates_default_chatarch_python_env(monkeypatch, tmp_path):
+    import chatup.setup.uv as uv_setup
+
+    created = []
+    readiness = iter([False, True])
+    monkeypatch.setattr(uv_setup, "DEFAULT_VENV_PATH", tmp_path / "default-venv")
+    monkeypatch.setattr(uv_setup, "ensure_uv_installed", lambda: "/usr/local/bin/uv")
+    monkeypatch.setattr(uv_setup, "is_chatarch_python_ready", lambda path, version: next(readiness))
+    monkeypatch.setattr(
+        uv_setup,
+        "create_chatarch_python_env",
+        lambda uv_bin, path, version, *, force=False: created.append((uv_bin, path, version, force)),
+    )
+
+    result = uv_setup.setup_uv()
+
+    assert result["status"] == "created"
+    assert result["venv"] == str(tmp_path / "default-venv")
+    assert result["python_version"] == "3.12"
+    assert created == [("/usr/local/bin/uv", tmp_path / "default-venv", "3.12", False)]
+
+
+def test_uv_setup_accepts_custom_path_python_and_force(monkeypatch, tmp_path):
+    import chatup.setup.uv as uv_setup
+
+    target = tmp_path / "custom-venv"
+    created = []
+    readiness = iter([False, True])
+    monkeypatch.setattr(uv_setup, "ensure_uv_installed", lambda: "/opt/bin/uv")
+    monkeypatch.setattr(uv_setup, "is_chatarch_python_ready", lambda path, version: next(readiness))
+    monkeypatch.setattr(
+        uv_setup,
+        "create_chatarch_python_env",
+        lambda uv_bin, path, version, *, force=False: created.append((uv_bin, path, version, force)),
+    )
+
+    result = CliRunner().invoke(main, ["uv", "--venv", str(target), "--python", "3.11", "--force"])
+
+    assert result.exit_code == 0, result.output
+    assert created == [("/opt/bin/uv", target, "3.11", True)]
+
+
+def test_ensure_uv_installed_uses_official_installer_when_missing(monkeypatch):
+    import chatup.setup.uv as uv_setup
+
+    monkeypatch.setattr(uv_setup, "find_uv", lambda: None)
+    monkeypatch.setattr(uv_setup, "install_uv_with_official_script", lambda: "/home/me/.local/bin/uv")
+
+    assert uv_setup.ensure_uv_installed() == "/home/me/.local/bin/uv"
+
+
+def test_create_chatarch_python_env_seeds_pip_and_force_clears(monkeypatch, tmp_path):
+    import chatup.setup.uv as uv_setup
+
+    commands = []
+
+    class Result:
+        returncode = 0
+        stdout = ""
+        stderr = ""
+
+    def fake_run_command(command, **kwargs):
+        commands.append(command)
+        return Result()
+
+    monkeypatch.setattr(uv_setup, "_run_command", fake_run_command)
+
+    uv_setup.create_chatarch_python_env("uv", tmp_path / "venv", "3.12", force=True)
+
+    assert commands == [
+        ["uv", "python", "install", "3.12"],
+        ["uv", "venv", "--python", "3.12", "--seed", "--clear", "--force", str(tmp_path / "venv")],
+    ]
+
+
+def test_create_chatarch_python_env_allows_existing_same_version_venv(monkeypatch, tmp_path):
+    import chatup.setup.uv as uv_setup
+
+    target = tmp_path / "venv"
+    target.mkdir()
+    commands = []
+
+    class Result:
+        returncode = 0
+        stdout = ""
+        stderr = ""
+
+    def fake_run_command(command, **kwargs):
+        commands.append(command)
+        return Result()
+
+    monkeypatch.setattr(uv_setup, "_run_command", fake_run_command)
+
+    uv_setup.create_chatarch_python_env("uv", target, "3.12", force=False)
+
+    assert commands == [
+        ["uv", "python", "install", "3.12"],
+        ["uv", "venv", "--python", "3.12", "--seed", "--allow-existing", str(target)],
+    ]

{chatup-0.2.0 → chatup-0.2.1}/tests/test_version.py

@@ -5,7 +5,7 @@ from chatup.cli import main
 
 
 def test_version_present():
-    assert __version__ == "0.2.0"
+    assert __version__ == "0.2.1"
 
 
 def test_cli_help():
@@ -20,4 +20,4 @@ def test_cli_doctor():
     result = CliRunner().invoke(main, ["doctor"])
 
     assert result.exit_code == 0
-    assert "chatup 0.2.0 ok" in result.output
+    assert "chatup 0.2.1 ok" in result.output

chatup-0.2.0/tests/test_setup_cli.py

@@ -1,104 +0,0 @@
-from click.testing import CliRunner
-
-from chatup.cli import main
-
-
-def test_chatup_root_help_lists_setup_commands_without_setup_group_or_alias():
-    result = CliRunner().invoke(main, ["--help"])
-
-    assert result.exit_code == 0
-    for command in [
-        "workspace",
-        "nodejs",
-        "codex",
-        "claude",
-        "opencode",
-        "hermes",
-        "lark-cli",
-        "docker",
-        "zsh",
-    ]:
-        assert command in result.output
-    assert "setup" not in result.output
-    assert "\n  alias " not in result.output
-
-
-def test_chatup_workspace_help_keeps_interactive_flags():
-    result = CliRunner().invoke(main, ["workspace", "--help"])
-
-    assert result.exit_code == 0
-    assert "--with-chattool" in result.output
-    assert "--with-chatblog" in result.output
-    assert "--with-memory" in result.output
-    assert "-i, --interactive" in result.output
-    assert "-I, --no-interactive" in result.output
-
-
-def test_top_level_setup_commands_expose_help():
-    commands = [
-        "cc-connect",
-        "chrome",
-        "claude",
-        "codex",
-        "docker",
-        "frp",
-        "hermes",
-        "lark-cli",
-        "nodejs",
-        "opencode",
-        "workspace",
-        "zsh",
-    ]
-
-    for command in commands:
-        result = CliRunner().invoke(main, [command, "--help"])
-        assert result.exit_code == 0, command
-        assert "--help" in result.output
-        assert "Usage: chatup setup" not in result.output
-
-
-def test_setup_group_and_alias_command_are_not_registered():
-    setup_result = CliRunner().invoke(main, ["setup", "--help"])
-    alias_result = CliRunner().invoke(main, ["alias", "--help"])
-
-    assert setup_result.exit_code != 0
-    assert "No such command" in setup_result.output
-    assert alias_result.exit_code != 0
-    assert "No such command" in alias_result.output
-
-
-def test_opencode_no_longer_exposes_legacy_chatloop_preset():
-    result = CliRunner().invoke(main, ["opencode", "--help"])
-
-    assert result.exit_code == 0
-    assert "auto-loop" in result.output
-    assert "chatloop" not in result.output.lower()
-
-
-def test_cc_connect_installs_chatarch_package(monkeypatch):
-    import chatup.setup.cc_connect as cc_connect
-
-    commands = []
-    monkeypatch.setattr(cc_connect, "ensure_nodejs_requirement", lambda **kwargs: None)
-    monkeypatch.setattr(
-        cc_connect,
-        "should_install_global_npm_package",
-        lambda package_name, display_name, **kwargs: (
-            package_name == "@chatarch/cc-connect" and display_name == "cc-connect"
-        ),
-    )
-
-    class Result:
-        returncode = 0
-        stderr = ""
-
-    def fake_run_npm_command(args):
-        commands.append(args)
-        return Result()
-
-    monkeypatch.setattr(cc_connect, "run_npm_command", fake_run_npm_command)
-
-    result = CliRunner().invoke(main, ["cc-connect", "-I"])
-
-    assert result.exit_code == 0, result.output
-    assert commands == [["install", "-g", "@chatarch/cc-connect"]]