chatup 0.2.9__tar.gz → 0.2.11__tar.gz

{chatup-0.2.9/src/chatup.egg-info → chatup-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatup
-Version: 0.2.9
+Version: 0.2.11
 Summary: ChatArch setup CLI extracted from ChatTool
 Author-email: rexwzh <1073853456@qq.com>
 License-Expression: MIT

{chatup-0.2.9 → chatup-0.2.11}/src/chatup/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.9"
+__version__ = "0.2.11"

{chatup-0.2.9 → chatup-0.2.11}/src/chatup/setup/elements.py

@@ -54,6 +54,14 @@ from chatup.setup.nginx import (
 )
 from chatup.setup.opencode import setup_opencode
 from chatup.setup.nodejs import setup_nodejs
+from chatup.setup.twikoo import (
+    DEFAULT_TWIKOO_BIND_ADDRESS,
+    DEFAULT_TWIKOO_INSTANCE,
+    DEFAULT_TWIKOO_PORT,
+    DEFAULT_TWIKOO_REPO,
+    DEFAULT_TWIKOO_VERSION,
+    setup_twikoo,
+)
 from chatup.setup.uv import DEFAULT_PYTHON_VERSION, DEFAULT_VENV_PATH, setup_uv
 from chatup.setup.workspace import setup_workspace
 from chatup.setup.zsh import setup_zsh
@@ -304,6 +312,41 @@ def mysql_setup(
     )
 
 
+def twikoo_setup(
+    version,
+    repo,
+    home,
+    name,
+    port,
+    bind_address,
+    install,
+    init,
+    service,
+    start,
+    smoke,
+    force,
+    log_level,
+):
+    result = setup_twikoo(
+        name=name,
+        version=version,
+        repo=repo,
+        home=home,
+        port=port,
+        bind_address=bind_address,
+        install=install,
+        init=init,
+        service=service,
+        start=start,
+        smoke=smoke,
+        force=force,
+        log_level=log_level,
+    )
+    service_info = result.get("service") if isinstance(result, dict) else None
+    if isinstance(service_info, dict) and service_info.get("unit"):
+        click.echo(service_info["unit"])
+
+
 def nginx_setup(
     template,
     output_file,
@@ -870,6 +913,66 @@ SETUP_COMMAND_ELEMENTS = (
             ),
         ),
     ),
+    SetupCommandElement(
+        name="twikoo",
+        help="Install and prepare a multi-instance Twikoo comment service runtime.",
+        callback=twikoo_setup,
+        options=(
+            LOG_LEVEL_OPTION,
+            SetupOptionElement(
+                param_decls=("--version",),
+                kwargs={"default": DEFAULT_TWIKOO_VERSION, "show_default": True},
+            ),
+            SetupOptionElement(
+                param_decls=("--repo",),
+                kwargs={"default": DEFAULT_TWIKOO_REPO, "show_default": True},
+            ),
+            SetupOptionElement(
+                param_decls=("--home",),
+                kwargs={
+                    "default": None,
+                    "type": click.Path(path_type=Path),
+                    "help": "Twikoo home. Defaults to ~/.chatarch/twikoo.",
+                },
+            ),
+            SetupOptionElement(
+                param_decls=("--name",),
+                kwargs={"default": DEFAULT_TWIKOO_INSTANCE, "show_default": True},
+            ),
+            SetupOptionElement(
+                param_decls=("--port",),
+                kwargs={"default": DEFAULT_TWIKOO_PORT, "show_default": True, "type": int},
+            ),
+            SetupOptionElement(
+                param_decls=("--bind-address",),
+                kwargs={"default": DEFAULT_TWIKOO_BIND_ADDRESS, "show_default": True},
+            ),
+            SetupOptionElement(
+                param_decls=("--install/--no-install",),
+                kwargs={"default": True, "show_default": True, "help": "Download the Twikoo release binary."},
+            ),
+            SetupOptionElement(
+                param_decls=("--init/--no-init",),
+                kwargs={"default": True, "show_default": True, "help": "Create instance directories, env file, and instance-local binary link."},
+            ),
+            SetupOptionElement(
+                param_decls=("--service/--no-service",),
+                kwargs={"default": True, "show_default": True, "help": "Install a user-level systemd service."},
+            ),
+            SetupOptionElement(
+                param_decls=("--start/--no-start",),
+                kwargs={"default": False, "show_default": True, "help": "Start the user-level Twikoo service."},
+            ),
+            SetupOptionElement(
+                param_decls=("--smoke/--no-smoke",),
+                kwargs={"default": False, "show_default": True, "help": "Run a local HTTP smoke test after starting."},
+            ),
+            SetupOptionElement(
+                param_decls=("--force", "-f"),
+                kwargs={"is_flag": True, "help": "Replace existing runtime/config/service where supported."},
+            ),
+        ),
+    ),
     SetupCommandElement(
         name="nginx",
         help="Prepare user-level NGINX under ChatArch home and render config templates.",

chatup-0.2.11/src/chatup/setup/twikoo.py

@@ -0,0 +1,403 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import platform
+import shutil
+import subprocess
+import tempfile
+import urllib.request
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import click
+from chatenv import get_paths
+
+from chatup.utils.custom_logger import setup_logger
+
+logger = setup_logger("setup_twikoo")
+
+DEFAULT_TWIKOO_REPO = "twikoojs/twikoo"
+DEFAULT_TWIKOO_VERSION = "1.7.15"
+DEFAULT_TWIKOO_PORT = 8892
+DEFAULT_TWIKOO_BIND_ADDRESS = "127.0.0.1"
+DEFAULT_TWIKOO_INSTANCE = "chatblog"
+TWIKOO_RUNTIME_SUPPORT_FILES = ("ip2region.db", "xhr-sync-worker.js")
+
+
+@dataclass(frozen=True)
+class TwikooService:
+    name: str
+    path: Path
+
+
+@dataclass(frozen=True)
+class TwikooLayout:
+    home: Path
+    downloads: Path
+    runtime: Path
+    runtime_binary: Path
+    instance: Path
+    instance_bin: Path
+    instance_env_link: Path
+    binary: Path
+    env: Path
+    data: Path
+    logs: Path
+    run: Path
+    tmp: Path
+    service: TwikooService
+
+
+def _configure_logger(log_level="INFO"):
+    global logger
+    logger = setup_logger("setup_twikoo", log_level=str(log_level).upper())
+    return logger
+
+
+def validate_safe_name(value: str, *, field: str) -> str:
+    if not value or any(ch in value for ch in ("/", "\\", "\x00")) or value in {".", ".."}:
+        raise click.ClickException(
+            f"Invalid {field}: {value!r}. Use an instance-safe name without path separators."
+        )
+    allowed = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.-")
+    if any(ch not in allowed for ch in value):
+        raise click.ClickException(
+            f"Invalid {field}: {value!r}. Use letters, numbers, dot, underscore, or dash."
+        )
+    return value
+
+
+def default_twikoo_home() -> Path:
+    return get_paths().home_dir / "twikoo"
+
+
+def service_name(name: str = DEFAULT_TWIKOO_INSTANCE) -> str:
+    validate_safe_name(name, field="instance name")
+    return f"chatarch-twikoo-{name}.service"
+
+
+def service_file_path(name: str = DEFAULT_TWIKOO_INSTANCE) -> Path:
+    return Path("~/.config/systemd/user").expanduser() / service_name(name)
+
+
+def twikoo_layout(
+    name: str = DEFAULT_TWIKOO_INSTANCE,
+    version: str = DEFAULT_TWIKOO_VERSION,
+    home: Path | None = None,
+) -> TwikooLayout:
+    validate_safe_name(name, field="instance name")
+    validate_safe_name(version, field="version")
+    root = (home or default_twikoo_home()).expanduser()
+    runtime = root / "runtimes" / version
+    instance = root / "instances" / name
+    instance_bin = instance / "bin" / "twikoo"
+    return TwikooLayout(
+        home=root,
+        downloads=root / "downloads",
+        runtime=runtime,
+        runtime_binary=runtime / "twikoo",
+        instance=instance,
+        instance_bin=instance_bin,
+        instance_env_link=instance / "bin" / ".env",
+        binary=instance_bin,
+        env=instance / "env" / "twikoo.env",
+        data=instance / "data",
+        logs=instance / "logs",
+        run=instance / "run",
+        tmp=instance / "tmp",
+        service=TwikooService(name=service_name(name), path=service_file_path(name)),
+    )
+
+
+def _machine_arch() -> str:
+    machine = platform.machine().lower()
+    if machine in {"x86_64", "amd64"}:
+        return "x64"
+    if machine in {"aarch64", "arm64"}:
+        return "arm64"
+    raise click.ClickException(f"Unsupported Twikoo release architecture: {machine}")
+
+
+def select_twikoo_asset_name() -> str:
+    system = platform.system().lower()
+    arch = _machine_arch()
+    if system == "linux" and arch == "x64":
+        return "twikoo-linux-x64"
+    if system == "darwin" and arch in {"x64", "arm64"}:
+        return f"twikoo-darwin-{arch}"
+    if system == "windows" and arch == "x64":
+        return "twikoo-win-x64.exe"
+    raise click.ClickException(f"Unsupported Twikoo release platform: {platform.system()} {platform.machine()}")
+
+
+def twikoo_release_asset_url(repo: str, version: str, asset_name: str) -> str:
+    version = version.removeprefix("v")
+    return f"https://github.com/{repo}/releases/download/{version}/{asset_name}"
+
+
+def _download_url(url: str, target: Path) -> None:
+    target.parent.mkdir(parents=True, exist_ok=True)
+    logger.info("Downloading %s", url)
+    with urllib.request.urlopen(url, timeout=180) as response, target.open("wb") as handle:
+        if response.status != 200:
+            raise click.ClickException(f"Failed to download Twikoo release asset: HTTP {response.status}")
+        shutil.copyfileobj(response, handle)
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def install_twikoo_binary(
+    *,
+    repo: str = DEFAULT_TWIKOO_REPO,
+    version: str = DEFAULT_TWIKOO_VERSION,
+    home: Path | None = None,
+    force: bool = False,
+    asset_name: str | None = None,
+) -> dict[str, Any]:
+    layout = twikoo_layout(version=version, home=home)
+    if layout.runtime_binary.exists() and not force:
+        return {
+            "version": version,
+            "binary": str(layout.runtime_binary),
+            "sha256": _sha256(layout.runtime_binary),
+            "reused": True,
+        }
+
+    selected_asset = asset_name or select_twikoo_asset_name()
+    url = twikoo_release_asset_url(repo, version, selected_asset)
+    layout.runtime.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix=".chatup-twikoo-", dir=layout.runtime) as tmp:
+        tmp_path = Path(tmp) / selected_asset
+        _download_url(url, tmp_path)
+        tmp_path.chmod(0o755)
+        tmp_path.replace(layout.runtime_binary)
+    layout.runtime_binary.chmod(0o755)
+    return {
+        "version": version,
+        "binary": str(layout.runtime_binary),
+        "asset": selected_asset,
+        "sha256": _sha256(layout.runtime_binary),
+        "reused": False,
+    }
+
+
+def render_env(
+    layout: TwikooLayout,
+    *,
+    port: int = DEFAULT_TWIKOO_PORT,
+    bind_address: str = DEFAULT_TWIKOO_BIND_ADDRESS,
+) -> str:
+    return f"""# Managed by ChatUp. Do not store secrets in this generated default env file.
+TWIKOO_HOST={bind_address}
+TWIKOO_PORT={port}
+TWIKOO_DATA={layout.data}
+TWIKOO_THROTTLE=250
+TWIKOO_LOG_LEVEL=info
+TWIKOO_LOCALHOST_ONLY=true
+TWIKOO_SHUTDOWN_TIMEOUT=5000
+"""
+
+
+def render_service(layout: TwikooLayout, *, name: str = DEFAULT_TWIKOO_INSTANCE) -> str:
+    return f"""[Unit]
+Description=ChatUp Twikoo comment service ({name})
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+WorkingDirectory={layout.instance}
+EnvironmentFile={layout.env}
+ExecStart={layout.binary}
+Restart=always
+RestartSec=5
+StandardOutput=append:{layout.logs}/twikoo.stdout.log
+StandardError=append:{layout.logs}/twikoo.stderr.log
+
+[Install]
+WantedBy=default.target
+"""
+
+
+def _link_or_copy_binary(source: Path, target: Path, *, force: bool = False) -> None:
+    target.parent.mkdir(parents=True, exist_ok=True)
+    if target.exists() or target.is_symlink():
+        if not force:
+            return
+        target.unlink()
+    try:
+        os.link(source, target)
+    except OSError:
+        shutil.copy2(source, target)
+    target.chmod(0o755)
+
+
+def ensure_runtime_binary(layout: TwikooLayout) -> Path:
+    """Return the canonical runtime binary, migrating an existing asset-named file if present."""
+
+    if layout.runtime_binary.exists():
+        return layout.runtime_binary
+    try:
+        asset_name = select_twikoo_asset_name()
+    except click.ClickException:
+        asset_name = ""
+    if asset_name:
+        candidate = layout.runtime / asset_name
+        if candidate.exists():
+            _link_or_copy_binary(candidate, layout.runtime_binary, force=False)
+            return layout.runtime_binary
+    raise click.ClickException(
+        f"Twikoo runtime binary is missing at {layout.runtime_binary}; run without --no-install first."
+    )
+
+
+def _copy_support_files(runtime: Path, target_dir: Path, *, force: bool = False) -> list[str]:
+    copied: list[str] = []
+    target_dir.mkdir(parents=True, exist_ok=True)
+    for filename in TWIKOO_RUNTIME_SUPPORT_FILES:
+        source = runtime / filename
+        if not source.exists():
+            continue
+        target = target_dir / filename
+        if target.exists() and not force:
+            copied.append(filename)
+            continue
+        shutil.copy2(source, target)
+        copied.append(filename)
+    return copied
+
+
+def init_instance(
+    *,
+    name: str = DEFAULT_TWIKOO_INSTANCE,
+    version: str = DEFAULT_TWIKOO_VERSION,
+    home: Path | None = None,
+    port: int = DEFAULT_TWIKOO_PORT,
+    bind_address: str = DEFAULT_TWIKOO_BIND_ADDRESS,
+    force: bool = False,
+) -> dict[str, Any]:
+    layout = twikoo_layout(name=name, version=version, home=home)
+    for directory in [layout.data, layout.logs, layout.run, layout.tmp, layout.env.parent, layout.instance_bin.parent]:
+        directory.mkdir(parents=True, exist_ok=True)
+    runtime_binary = ensure_runtime_binary(layout)
+    _link_or_copy_binary(runtime_binary, layout.instance_bin, force=force)
+    support_files = _copy_support_files(layout.runtime, layout.instance_bin.parent, force=force)
+    if not layout.env.exists() or force:
+        layout.env.write_text(render_env(layout, port=port, bind_address=bind_address), encoding="utf-8")
+        layout.env.chmod(0o600)
+    if layout.instance_env_link.exists() or layout.instance_env_link.is_symlink():
+        if force:
+            layout.instance_env_link.unlink()
+    if not layout.instance_env_link.exists() and not layout.instance_env_link.is_symlink():
+        os.symlink(Path("../env/twikoo.env"), layout.instance_env_link)
+    return {
+        "instance": str(layout.instance),
+        "binary": str(layout.instance_bin),
+        "env": str(layout.env),
+        "data": str(layout.data),
+        "support_files": support_files,
+    }
+
+
+def install_service(
+    *,
+    name: str = DEFAULT_TWIKOO_INSTANCE,
+    version: str = DEFAULT_TWIKOO_VERSION,
+    home: Path | None = None,
+    force: bool = False,
+) -> dict[str, Any]:
+    layout = twikoo_layout(name=name, version=version, home=home)
+    layout.service.path.parent.mkdir(parents=True, exist_ok=True)
+    if not layout.service.path.exists() or force:
+        layout.service.path.write_text(render_service(layout, name=name), encoding="utf-8")
+    return {"unit": layout.service.name, "path": str(layout.service.path)}
+
+
+def export_layout(
+    *,
+    name: str = DEFAULT_TWIKOO_INSTANCE,
+    version: str = DEFAULT_TWIKOO_VERSION,
+    home: Path | None = None,
+) -> dict[str, Any]:
+    layout = twikoo_layout(name=name, version=version, home=home)
+    data = asdict(layout)
+    data["service"] = {"name": layout.service.name, "path": str(layout.service.path)}
+    for key, value in list(data.items()):
+        if isinstance(value, Path):
+            data[key] = str(value)
+    return data
+
+
+def _systemctl_user(*args: str) -> None:
+    subprocess.run(["systemctl", "--user", *args], check=True)
+
+
+def start_service(name: str = DEFAULT_TWIKOO_INSTANCE) -> None:
+    unit = service_name(name)
+    _systemctl_user("daemon-reload")
+    _systemctl_user("enable", "--now", unit)
+
+
+def smoke_twikoo(*, port: int = DEFAULT_TWIKOO_PORT, bind_address: str = DEFAULT_TWIKOO_BIND_ADDRESS) -> str:
+    import json
+
+    url = f"http://{bind_address}:{port}/"
+    with urllib.request.urlopen(url, timeout=15) as response:
+        body = response.read().decode("utf-8")
+    try:
+        payload = json.loads(body)
+    except json.JSONDecodeError as exc:
+        raise click.ClickException(f"Twikoo smoke did not return JSON: {body[:200]}") from exc
+    if payload.get("code") != 100:
+        raise click.ClickException(f"Twikoo smoke failed: {payload}")
+    return body
+
+
+def setup_twikoo(
+    *,
+    name: str = DEFAULT_TWIKOO_INSTANCE,
+    version: str = DEFAULT_TWIKOO_VERSION,
+    repo: str = DEFAULT_TWIKOO_REPO,
+    home: Path | None = None,
+    port: int = DEFAULT_TWIKOO_PORT,
+    bind_address: str = DEFAULT_TWIKOO_BIND_ADDRESS,
+    install: bool = True,
+    init: bool = True,
+    service: bool = True,
+    start: bool = False,
+    smoke: bool = False,
+    force: bool = False,
+    log_level: str = "INFO",
+) -> dict[str, Any]:
+    _configure_logger(log_level)
+    validate_safe_name(name, field="instance name")
+    if smoke and not start:
+        raise click.ClickException("--smoke requires --start")
+    result: dict[str, Any] = {"layout": export_layout(name=name, version=version, home=home)}
+    if install:
+        result["install"] = install_twikoo_binary(repo=repo, version=version, home=home, force=force)
+    if init:
+        result["init"] = init_instance(
+            name=name,
+            version=version,
+            home=home,
+            port=port,
+            bind_address=bind_address,
+            force=force,
+        )
+    if service:
+        result["service"] = install_service(name=name, version=version, home=home, force=force)
+    if start:
+        start_service(name)
+        result["started"] = service_name(name)
+    if smoke:
+        result["smoke"] = smoke_twikoo(port=port, bind_address=bind_address)
+    return result

{chatup-0.2.9 → chatup-0.2.11/src/chatup.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatup
-Version: 0.2.9
+Version: 0.2.11
 Summary: ChatArch setup CLI extracted from ChatTool
 Author-email: rexwzh <1073853456@qq.com>
 License-Expression: MIT

{chatup-0.2.9 → chatup-0.2.11}/src/chatup.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ src/chatup/setup/nodejs.py
 src/chatup/setup/opencode.py
 src/chatup/setup/service_credentials.py
 src/chatup/setup/shell_rc.py
+src/chatup/setup/twikoo.py
 src/chatup/setup/uv.py
 src/chatup/setup/workspace.py
 src/chatup/setup/zsh.py
@@ -80,5 +81,6 @@ tests/test_publish_workflow.py
 tests/test_pyproject_metadata.py
 tests/test_service_installers.py
 tests/test_setup_cli.py
+tests/test_twikoo_setup.py
 tests/test_version.py
 tests/test_workspace_setup.py

{chatup-0.2.9 → chatup-0.2.11}/tests/test_cli_tree_docs.py

@@ -33,6 +33,15 @@ def test_bilingual_cli_tree_matches_registered_click_commands():
     assert _documented_reference_commands(ROOT / "docs" / "commands.en.md") == actual
 
 
+def test_mkdocs_material_theme_has_material_icon_renderer():
+    mkdocs = (ROOT / "mkdocs.yml").read_text(encoding="utf-8")
+
+    assert "name: material" in mkdocs
+    assert "pymdownx.emoji" in mkdocs
+    assert "material.extensions.emoji.twemoji" in mkdocs
+    assert "material.extensions.emoji.to_svg" in mkdocs
+
+
 def test_cli_tree_is_in_mkdocs_nav_and_backend_contracts_are_complete():
     mkdocs = (ROOT / "mkdocs.yml").read_text(encoding="utf-8")
     assert "CLI 树: cli-tree.md" in mkdocs

{chatup-0.2.9 → chatup-0.2.11}/tests/test_publish_workflow.py

@@ -11,6 +11,9 @@ def test_publish_workflow_matches_active_any_environment_publisher():
     assert "id-token: write" in workflow
     assert "pypa/gh-action-pypi-publish@release/v1" in workflow
     assert "environment: pypi" not in workflow
+    assert "Release workflow must run from a tag ref" in workflow
+    assert "GITHUB_REF_TYPE" in workflow
+    assert "GITHUB_REF_NAME" in workflow
     for secret_name in (
         "PYPI_API_TOKEN",
         "PYPI_TOKEN",

chatup-0.2.11/tests/test_twikoo_setup.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from click.testing import CliRunner
+
+from chatup.cli import main
+
+
+def test_twikoo_layout_uses_chatarch_home_and_instance_scoped_paths(tmp_path):
+    from chatup.setup.twikoo import twikoo_layout
+
+    layout = twikoo_layout(name="chatblog", version="1.7.15", home=tmp_path / "twikoo")
+
+    assert layout.home == tmp_path / "twikoo"
+    assert layout.runtime == tmp_path / "twikoo" / "runtimes" / "1.7.15"
+    assert layout.runtime_binary == tmp_path / "twikoo" / "runtimes" / "1.7.15" / "twikoo"
+    assert layout.instance == tmp_path / "twikoo" / "instances" / "chatblog"
+    assert layout.instance_bin == tmp_path / "twikoo" / "instances" / "chatblog" / "bin" / "twikoo"
+    assert layout.instance_env_link == tmp_path / "twikoo" / "instances" / "chatblog" / "bin" / ".env"
+    assert layout.binary == layout.instance_bin
+    assert layout.env == tmp_path / "twikoo" / "instances" / "chatblog" / "env" / "twikoo.env"
+    assert layout.data == tmp_path / "twikoo" / "instances" / "chatblog" / "data"
+    assert layout.logs == tmp_path / "twikoo" / "instances" / "chatblog" / "logs"
+    assert layout.service.name == "chatarch-twikoo-chatblog.service"
+
+
+def test_twikoo_render_env_and_service_are_instance_scoped(tmp_path):
+    from chatup.setup.twikoo import render_env, render_service, service_name, twikoo_layout
+
+    layout = twikoo_layout(name="chatblog", version="1.7.15", home=tmp_path / "twikoo")
+
+    env_text = render_env(layout, port=8892, bind_address="127.0.0.1")
+    assert "TWIKOO_HOST=127.0.0.1" in env_text
+    assert "TWIKOO_PORT=8892" in env_text
+    assert f"TWIKOO_DATA={layout.data}" in env_text
+    assert "MONGODB" not in env_text
+
+    service_text = render_service(layout, name="chatblog")
+    assert service_name("chatblog") == "chatarch-twikoo-chatblog.service"
+    assert f"WorkingDirectory={layout.instance}" in service_text
+    assert f"EnvironmentFile={layout.env}" in service_text
+    assert f"ExecStart={layout.binary}" in service_text
+    assert "WantedBy=default.target" in service_text
+
+
+def test_twikoo_help_exposes_multi_instance_binary_installer_options():
+    result = CliRunner().invoke(main, ["twikoo", "--help"])
+
+    assert result.exit_code == 0, result.output
+    assert "--version" in result.output
+    assert "1.7.15" in result.output
+    assert "--repo" in result.output
+    assert "twikoojs/twikoo" in result.output
+    assert "--home" in result.output
+    assert "--name" in result.output
+    assert "--port" in result.output
+    assert "--bind-address" in result.output
+    assert "--start / --no-start" in result.output
+    assert "--smoke / --no-smoke" in result.output
+
+
+def test_twikoo_cli_prepares_named_instance_without_starting(monkeypatch, tmp_path):
+    import chatup.setup.twikoo as twikoo_setup
+
+    calls = []
+    monkeypatch.setattr(
+        twikoo_setup,
+        "export_layout",
+        lambda **kwargs: {
+            "instance": str(tmp_path / "twikoo" / "instances" / kwargs["name"]),
+            "service": str(tmp_path / f"chatarch-twikoo-{kwargs['name']}.service"),
+        },
+    )
+    monkeypatch.setattr(
+        twikoo_setup,
+        "install_twikoo_binary",
+        lambda **kwargs: calls.append(("install", kwargs))
+        or {"binary": str(tmp_path / "twikoo" / "runtimes" / kwargs["version"] / "twikoo"), "reused": False},
+    )
+    monkeypatch.setattr(
+        twikoo_setup,
+        "init_instance",
+        lambda **kwargs: calls.append(("init", kwargs))
+        or {"env": str(tmp_path / "twikoo" / "instances" / kwargs["name"] / "env" / "twikoo.env")},
+    )
+    monkeypatch.setattr(
+        twikoo_setup,
+        "install_service",
+        lambda **kwargs: calls.append(("service", kwargs))
+        or {"unit": f"chatarch-twikoo-{kwargs['name']}.service"},
+    )
+
+    result = CliRunner().invoke(
+        main,
+        [
+            "twikoo",
+            "--home",
+            str(tmp_path / "twikoo"),
+            "--name",
+            "chatblog",
+            "--port",
+            "8892",
+            "--no-start",
+            "--no-smoke",
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert [name for name, _ in calls] == ["install", "init", "service"]
+    assert calls[0][1]["repo"] == "twikoojs/twikoo"
+    assert calls[1][1]["name"] == "chatblog"
+    assert calls[1][1]["port"] == 8892
+    assert calls[1][1]["bind_address"] == "127.0.0.1"
+    assert "chatarch-twikoo-chatblog.service" in result.output
+
+
+def test_twikoo_smoke_requires_start():
+    result = CliRunner().invoke(main, ["twikoo", "--no-install", "--no-init", "--no-service", "--smoke"])
+
+    assert result.exit_code != 0
+    assert "--smoke requires --start" in result.output
+
+
+def test_twikoo_no_install_can_adopt_asset_named_runtime(monkeypatch, tmp_path):
+    from chatup.setup.twikoo import ensure_runtime_binary, twikoo_layout
+
+    monkeypatch.setattr("chatup.setup.twikoo.select_twikoo_asset_name", lambda: "twikoo-linux-x64")
+    layout = twikoo_layout(name="chatblog", version="1.7.15", home=tmp_path / "twikoo")
+    layout.runtime.mkdir(parents=True)
+    asset = layout.runtime / "twikoo-linux-x64"
+    asset.write_bytes(b"fake")
+    asset.chmod(0o755)
+
+    adopted = ensure_runtime_binary(layout)
+
+    assert adopted == layout.runtime_binary
+    assert layout.runtime_binary.read_bytes() == b"fake"

{chatup-0.2.9 → chatup-0.2.11}/tests/test_version.py

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