copaw-worker 0.1.0__tar.gz

copaw_worker-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: copaw-worker
+Version: 0.1.0
+Summary: Lightweight HiClaw Worker runtime based on CoPaw
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/higress-group/hiclaw
+Project-URL: Repository, https://github.com/higress-group/hiclaw
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: copaw>=0.0.5
+Requires-Dist: matrix-nio>=0.24.0
+
+# copaw-worker
+
+Lightweight [HiClaw](https://github.com/higress-group/hiclaw) Worker runtime based on [CoPaw](https://github.com/agentscope-ai/CoPaw).
+
+## Install
+
+```bash
+pip install copaw-worker
+```
+
+## Usage
+
+```bash
+copaw-worker --name <worker-name> --fs <minio-endpoint> --fs-key <access-key> --fs-secret <secret-key>
+```
+
+See [HiClaw worker guide](https://github.com/higress-group/hiclaw/blob/main/docs/worker-guide.md) for full setup instructions.

copaw_worker-0.1.0/README.md

@@ -0,0 +1,17 @@
+# copaw-worker
+
+Lightweight [HiClaw](https://github.com/higress-group/hiclaw) Worker runtime based on [CoPaw](https://github.com/agentscope-ai/CoPaw).
+
+## Install
+
+```bash
+pip install copaw-worker
+```
+
+## Usage
+
+```bash
+copaw-worker --name <worker-name> --fs <minio-endpoint> --fs-key <access-key> --fs-secret <secret-key>
+```
+
+See [HiClaw worker guide](https://github.com/higress-group/hiclaw/blob/main/docs/worker-guide.md) for full setup instructions.

copaw_worker-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "copaw-worker"
+version = "0.1.0"
+description = "Lightweight HiClaw Worker runtime based on CoPaw"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+requires-python = ">=3.10"
+dependencies = [
+    "copaw>=0.0.5",
+    "matrix-nio>=0.24.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/higress-group/hiclaw"
+Repository = "https://github.com/higress-group/hiclaw"
+
+[project.scripts]
+copaw-worker = "copaw_worker.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

copaw_worker-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

copaw_worker-0.1.0/src/copaw_worker/__init__.py

@@ -0,0 +1 @@
+# copaw-worker: HiClaw Worker runtime based on CoPaw

copaw_worker-0.1.0/src/copaw_worker/bridge.py

@@ -0,0 +1,226 @@
+"""
+Bridge: translate openclaw.json (HiClaw Worker config) into CoPaw's
+config.json + providers.json, then set COPAW_WORKING_DIR so CoPaw
+picks up the right workspace.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+
+def _port_remap(url: str, is_container: bool) -> str:
+    """Remap container-internal :8080 to host-exposed :18080 when needed."""
+    if not is_container and url and ":8080" in url:
+        return url.replace(":8080", ":18080")
+    return url
+
+
+def _is_in_container() -> bool:
+    return Path("/.dockerenv").exists()
+
+
+def _secret_dir(working_dir: Path) -> Path:
+    """Return the secret dir path that copaw uses alongside working_dir."""
+    return Path(str(working_dir) + ".secret")
+
+
+def _patch_copaw_paths(working_dir: Path) -> None:
+    """Patch copaw's module-level path constants to point at working_dir.
+
+    copaw.constant captures WORKING_DIR / SECRET_DIR at import time from
+    env vars, so setting COPAW_WORKING_DIR after import has no effect.
+    We must update the live module objects directly.
+    """
+    secret_dir = _secret_dir(working_dir)
+    secret_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        import copaw.constant as _const
+        _const.WORKING_DIR = working_dir
+        _const.SECRET_DIR = secret_dir
+        _const.ACTIVE_SKILLS_DIR = working_dir / "active_skills"
+        _const.CUSTOMIZED_SKILLS_DIR = working_dir / "customized_skills"
+        _const.MEMORY_DIR = working_dir / "memory"
+        _const.CUSTOM_CHANNELS_DIR = working_dir / "custom_channels"
+        _const.MODELS_DIR = working_dir / "models"
+    except ImportError:
+        pass
+
+    try:
+        import copaw.providers.store as _store
+        _store._PROVIDERS_JSON = secret_dir / "providers.json"
+        _store._LEGACY_PROVIDERS_JSON_CANDIDATES = (
+            Path(__file__).resolve().parent / "providers.json",
+            working_dir / "providers.json",
+        )
+    except ImportError:
+        pass
+
+    try:
+        import copaw.envs.store as _envs
+        _envs._BOOTSTRAP_WORKING_DIR = working_dir
+        _envs._BOOTSTRAP_SECRET_DIR = secret_dir
+        _envs._ENVS_JSON = secret_dir / "envs.json"
+        _envs._LEGACY_ENVS_JSON_CANDIDATES = (working_dir / "envs.json",)
+    except (ImportError, AttributeError):
+        pass
+
+
+def bridge_openclaw_to_copaw(
+    openclaw_cfg: dict[str, Any],
+    working_dir: Path,
+) -> None:
+    """
+    Read openclaw_cfg (parsed openclaw.json) and write:
+      - <working_dir>/config.json          (channels + agents)
+      - <working_dir>/providers.json       (LLM credentials, for reference)
+      - <working_dir>.secret/providers.json (where copaw actually reads from)
+
+    Also sets COPAW_WORKING_DIR env var and patches copaw's module-level
+    path constants so the running process uses the correct directory.
+    """
+    working_dir.mkdir(parents=True, exist_ok=True)
+    in_container = _is_in_container()
+
+    _write_config_json(openclaw_cfg, working_dir, in_container)
+    _write_providers_json(openclaw_cfg, working_dir, in_container)
+
+    os.environ["COPAW_WORKING_DIR"] = str(working_dir)
+
+    # Patch module-level constants (import-time values won't reflect env change)
+    _patch_copaw_paths(working_dir)
+
+    # Copy providers.json into secret_dir — that's where copaw actually reads it
+    secret_dir = _secret_dir(working_dir)
+    providers_src = working_dir / "providers.json"
+    if providers_src.exists():
+        shutil.copy2(providers_src, secret_dir / "providers.json")
+
+
+# ---------------------------------------------------------------------------
+# config.json
+# ---------------------------------------------------------------------------
+
+def _write_config_json(
+    cfg: dict[str, Any],
+    working_dir: Path,
+    in_container: bool,
+) -> None:
+    matrix_raw = cfg.get("channels", {}).get("matrix", {})
+    homeserver = _port_remap(
+        matrix_raw.get("homeserver", ""), in_container
+    )
+    access_token = matrix_raw.get("accessToken", "")
+
+    # DM allowlist
+    dm_cfg = matrix_raw.get("dm", {})
+    dm_policy = dm_cfg.get("policy", "allowlist")
+    dm_allow_from: list[str] = dm_cfg.get("allowFrom", [])
+
+    # Group allowlist
+    group_policy = matrix_raw.get("groupPolicy", "allowlist")
+    group_allow_from: list[str] = matrix_raw.get("groupAllowFrom", [])
+
+    # Per-room/group config (pass through as-is for MatrixChannel to use)
+    groups = matrix_raw.get("groups", {})
+
+    matrix_channel_cfg = {
+        "enabled": matrix_raw.get("enabled", True),
+        "homeserver": homeserver,
+        "access_token": access_token,
+        "dm_policy": dm_policy,
+        "allow_from": dm_allow_from,
+        "group_policy": group_policy,
+        "group_allow_from": group_allow_from,
+        "groups": groups,
+    }
+
+    config_path = working_dir / "config.json"
+    # Merge with existing config to avoid clobbering other settings
+    existing: dict[str, Any] = {}
+    if config_path.exists():
+        with open(config_path) as f:
+            existing = json.load(f)
+
+    existing.setdefault("channels", {})["matrix"] = matrix_channel_cfg
+    # Disable console channel (we use Matrix)
+    existing["channels"].setdefault("console", {})["enabled"] = False
+
+    with open(config_path, "w") as f:
+        json.dump(existing, f, indent=2, ensure_ascii=False)
+
+
+# ---------------------------------------------------------------------------
+# providers.json
+# ---------------------------------------------------------------------------
+
+def _write_providers_json(
+    cfg: dict[str, Any],
+    working_dir: Path,
+    in_container: bool,
+) -> None:
+    providers_raw = cfg.get("models", {}).get("providers", {})
+
+    custom_providers: dict[str, Any] = {}
+    active_provider_id = ""
+    active_model = ""
+
+    for provider_id, provider_cfg in providers_raw.items():
+        base_url = _port_remap(
+            provider_cfg.get("baseUrl", ""), in_container
+        )
+        api_key = provider_cfg.get("apiKey", "")
+
+        models_raw = provider_cfg.get("models", [])
+        models = [
+            {"id": m["id"], "name": m.get("name", m["id"])}
+            for m in models_raw
+            if m.get("id")
+        ]
+
+        custom_providers[provider_id] = {
+            "id": provider_id,
+            "name": provider_id,
+            "default_base_url": base_url,
+            "api_key_prefix": "",
+            "models": models,
+            "base_url": base_url,
+            "api_key": api_key,
+            "chat_model": "OpenAIChatModel",
+        }
+
+        # Use first provider + first model as active LLM
+        if not active_provider_id and models:
+            active_provider_id = provider_id
+            active_model = models[0]["id"]
+
+    # Resolve active model from agents.defaults.model.primary
+    # Format: "provider_id/model_id"
+    primary = (
+        cfg.get("agents", {})
+        .get("defaults", {})
+        .get("model", {})
+        .get("primary", "")
+    )
+    if primary and "/" in primary:
+        pid, mid = primary.split("/", 1)
+        if pid in custom_providers:
+            active_provider_id = pid
+            active_model = mid
+
+    providers_data: dict[str, Any] = {
+        "providers": {},
+        "custom_providers": custom_providers,
+        "active_llm": {
+            "provider_id": active_provider_id,
+            "model": active_model,
+        },
+    }
+
+    providers_path = working_dir / "providers.json"
+    with open(providers_path, "w") as f:
+        json.dump(providers_data, f, indent=2, ensure_ascii=False)

copaw_worker-0.1.0/src/copaw_worker/cli.py

@@ -0,0 +1,63 @@
+"""CLI entry point: copaw-worker"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import signal
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from copaw_worker.config import WorkerConfig
+from copaw_worker.worker import Worker
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+
+
+def main() -> None:
+    """Entry point registered in pyproject.toml."""
+
+    def _run(
+        name: str = typer.Option(..., "--name", help="Worker name"),
+        fs: str = typer.Option(..., "--fs", help="MinIO endpoint"),
+        fs_key: str = typer.Option(..., "--fs-key", help="MinIO access key"),
+        fs_secret: str = typer.Option(..., "--fs-secret", help="MinIO secret key"),
+        fs_bucket: str = typer.Option("hiclaw-storage", "--fs-bucket", help="MinIO bucket"),
+        sync_interval: int = typer.Option(300, "--sync-interval", help="Sync interval (seconds)"),
+        install_dir: Optional[str] = typer.Option(None, "--install-dir", help="Base install dir"),
+        console_port: Optional[int] = typer.Option(None, "--console-port", help="Enable web console on this port (e.g. 8088, costs ~500MB extra RAM)"),
+    ) -> None:
+        """Start the CoPaw Worker and connect to Matrix."""
+        config = WorkerConfig(
+            worker_name=name,
+            minio_endpoint=fs,
+            minio_access_key=fs_key,
+            minio_secret_key=fs_secret,
+            minio_bucket=fs_bucket,
+            sync_interval=sync_interval,
+            install_dir=Path(install_dir) if install_dir else None,
+            console_port=console_port,
+        )
+        worker = Worker(config)
+
+        async def _async_run() -> None:
+            loop = asyncio.get_running_loop()
+
+            def _shutdown() -> None:
+                asyncio.create_task(worker.stop())
+
+            for sig in (signal.SIGINT, signal.SIGTERM):
+                loop.add_signal_handler(sig, _shutdown)
+
+            await worker.run()
+
+        try:
+            asyncio.run(_async_run())
+        except KeyboardInterrupt:
+            pass
+
+    typer.run(_run)

copaw_worker-0.1.0/src/copaw_worker/config.py

@@ -0,0 +1,28 @@
+"""WorkerConfig: parsed from CLI args / env vars."""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+class WorkerConfig:
+    def __init__(
+        self,
+        worker_name: str,
+        minio_endpoint: str,
+        minio_access_key: str,
+        minio_secret_key: str,
+        minio_bucket: str = "hiclaw-storage",
+        minio_secure: bool = False,
+        sync_interval: int = 300,
+        install_dir: Path | None = None,
+        console_port: int | None = None,
+    ) -> None:
+        self.worker_name = worker_name
+        self.minio_endpoint = minio_endpoint
+        self.minio_access_key = minio_access_key
+        self.minio_secret_key = minio_secret_key
+        self.minio_bucket = minio_bucket
+        self.minio_secure = minio_secure
+        self.sync_interval = sync_interval
+        self.install_dir = install_dir or Path.home() / ".copaw-worker"
+        self.console_port = console_port