researchloop 0.1.0__py3-none-any.whl

researchloop/comms/slack.py

@@ -0,0 +1,188 @@
+"""Slack integration -- Events API webhook handler and notifier."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import logging
+import time
+from typing import Any
+
+import httpx
+
+from researchloop.comms.base import BaseNotifier
+
+logger = logging.getLogger(__name__)
+
+_SLACK_API = "https://slack.com/api"
+
+
+class SlackNotifier(BaseNotifier):
+    """Sends notifications to Slack channels/threads."""
+
+    def __init__(
+        self,
+        bot_token: str,
+        channel_id: str | None = None,
+        dashboard_url: str | None = None,
+        conversation_manager: Any = None,
+    ) -> None:
+        self.bot_token = bot_token
+        self.channel_id = channel_id
+        self.dashboard_url = dashboard_url
+        self._cm = conversation_manager
+
+    async def _post_message(
+        self,
+        text: str,
+        channel: str | None = None,
+        thread_ts: str | None = None,
+    ) -> dict[str, Any]:
+        ch = channel or self.channel_id
+        if not ch:
+            logger.warning("No Slack channel configured")
+            return {}
+        payload: dict[str, Any] = {
+            "channel": ch,
+            "text": text,
+        }
+        if thread_ts:
+            payload["thread_ts"] = thread_ts
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                f"{_SLACK_API}/chat.postMessage",
+                headers={
+                    "Authorization": f"Bearer {self.bot_token}",
+                    "Content-Type": "application/json",
+                },
+                json=payload,
+                timeout=10.0,
+            )
+            data = resp.json()
+            if not data.get("ok"):
+                logger.error("Slack API error: %s", data.get("error"))
+            return data
+
+    async def _upload_file(
+        self,
+        filepath: str,
+        filename: str,
+        channel: str | None = None,
+        initial_comment: str = "",
+    ) -> dict[str, Any]:
+        """Upload a file to a Slack channel."""
+        ch = channel or self.channel_id
+        if not ch:
+            return {}
+        try:
+            with open(filepath, "rb") as f:
+                async with httpx.AsyncClient() as client:
+                    resp = await client.post(
+                        f"{_SLACK_API}/files.upload",
+                        headers={
+                            "Authorization": (f"Bearer {self.bot_token}"),
+                        },
+                        data={
+                            "channels": ch,
+                            "filename": filename,
+                            "initial_comment": initial_comment,
+                        },
+                        files={"file": (filename, f)},
+                        timeout=30.0,
+                    )
+                    data = resp.json()
+                    if not data.get("ok"):
+                        logger.error(
+                            "Slack file upload error: %s",
+                            data.get("error"),
+                        )
+                    return data
+        except Exception:
+            logger.exception("Failed to upload file to Slack")
+            return {}
+
+    def _link(self, sprint_id: str) -> str:
+        if self.dashboard_url:
+            url = self.dashboard_url.rstrip("/")
+            return f"<{url}/dashboard/sprints/{sprint_id}|{sprint_id}>"
+        return sprint_id
+
+    async def notify_sprint_started(
+        self,
+        sprint_id: str,
+        study_name: str,
+        idea: str,
+    ) -> None:
+        link = self._link(sprint_id)
+        idea_trunc = idea[:300] + "…" if len(idea) > 300 else idea
+        msg = (
+            f":rocket: Sprint *{link}* started\n"
+            f"*Study:* {study_name}\n"
+            f"*Idea:* {idea_trunc}"
+        )
+        resp = await self._post_message(msg)
+        ts = resp.get("ts", "")
+        if ts and self._cm:
+            await self._cm.store_bot_message(ts, msg)
+
+    async def notify_sprint_completed(
+        self,
+        sprint_id: str,
+        study_name: str,
+        summary: str,
+        pdf_path: str | None = None,
+    ) -> None:
+        link = self._link(sprint_id)
+        summary_trunc = summary[:500] + "…" if len(summary) > 500 else summary
+        msg = (
+            f":white_check_mark: Sprint *{link}* completed\n"
+            f"*Study:* {study_name}\n"
+            f"*Summary:* {summary_trunc}"
+        )
+        resp = await self._post_message(msg)
+        # Store the notification for thread context.
+        ts = resp.get("ts", "")
+        if ts and self._cm:
+            await self._cm.store_bot_message(ts, msg)
+        if pdf_path:
+            await self._upload_file(
+                pdf_path,
+                f"{sprint_id}-report.pdf",
+                initial_comment=f"Report for sprint {sprint_id}",
+            )
+
+    async def notify_sprint_failed(
+        self,
+        sprint_id: str,
+        study_name: str,
+        error: str,
+    ) -> None:
+        link = self._link(sprint_id)
+        msg = (
+            f":x: Sprint *{link}* failed\n*Study:* {study_name}\n*Error:* {error[:500]}"
+        )
+        resp = await self._post_message(msg)
+        ts = resp.get("ts", "")
+        if ts and self._cm:
+            await self._cm.store_bot_message(ts, msg)
+
+
+def verify_slack_signature(
+    signing_secret: str,
+    timestamp: str,
+    body: bytes,
+    signature: str,
+) -> bool:
+    """Verify a Slack request signature."""
+    if abs(time.time() - int(timestamp)) > 60 * 5:
+        return False
+    basestring = f"v0:{timestamp}:{body.decode('utf-8')}"
+    computed = (
+        "v0="
+        + hmac.new(
+            signing_secret.encode(),
+            basestring.encode(),
+            hashlib.sha256,
+        ).hexdigest()
+    )
+    return hmac.compare_digest(computed, signature)

researchloop/core/auth.py

@@ -0,0 +1,78 @@
+"""Claude CLI authentication helpers."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import shutil
+import subprocess
+
+
+def check_claude_auth() -> tuple[bool, str]:
+    """Check whether the Claude CLI is authenticated.
+
+    Uses ``claude auth status`` which returns instant JSON.
+
+    Returns ``(ok, detail)`` where *ok* is True if authenticated
+    and *detail* is a human-readable status string.
+    """
+    claude = shutil.which("claude")
+    if claude is None:
+        return False, "Claude CLI not found in PATH"
+
+    try:
+        result = subprocess.run(
+            [claude, "auth", "status"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            try:
+                data = json.loads(result.stdout)
+                if data.get("loggedIn"):
+                    email = data.get("email", "")
+                    sub = data.get("subscriptionType", "")
+                    detail = f"{email} ({sub})" if email else "OK"
+                    return True, detail
+                return False, "Not logged in"
+            except json.JSONDecodeError:
+                return True, "Authenticated"
+        return False, "Not logged in — run: researchloop login"
+    except subprocess.TimeoutExpired:
+        return False, "Claude CLI timed out"
+    except Exception as exc:
+        return False, f"Error checking auth: {exc}"
+
+
+async def check_claude_auth_async() -> tuple[bool, str]:
+    """Async version of :func:`check_claude_auth`."""
+    claude = shutil.which("claude")
+    if claude is None:
+        return False, "Claude CLI not found in PATH"
+
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            claude,
+            "auth",
+            "status",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _stderr = await asyncio.wait_for(proc.communicate(), timeout=10)
+        if proc.returncode == 0:
+            try:
+                data = json.loads(stdout.decode("utf-8"))
+                if data.get("loggedIn"):
+                    email = data.get("email", "")
+                    sub = data.get("subscriptionType", "")
+                    detail = f"{email} ({sub})" if email else "OK"
+                    return True, detail
+                return False, "Not logged in"
+            except json.JSONDecodeError:
+                return True, "Authenticated"
+        return False, "Not logged in"
+    except asyncio.TimeoutError:
+        return False, "Claude CLI timed out"
+    except Exception as exc:
+        return False, f"Error checking auth: {exc}"

researchloop/core/config.py

@@ -0,0 +1,328 @@
+"""Configuration loading for researchloop."""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise ImportError(
+            "tomli is required for Python < 3.11: pip install tomli"
+        ) from exc
+
+CONFIG_FILENAMES = ["researchloop.toml"]
+CONFIG_SEARCH_PATHS = [
+    Path.cwd(),
+    Path.home() / ".config" / "researchloop",
+]
+
+
+@dataclass
+class ClusterConfig:
+    """Configuration for a compute cluster."""
+
+    name: str
+    host: str
+    port: int = 22
+    user: str = ""
+    key_path: str = ""
+    scheduler_type: str = "slurm"  # "slurm", "sge", "local"
+    working_dir: str = ""
+    max_concurrent_jobs: int = 4
+    environment: dict[str, str] = field(default_factory=dict)
+    job_options: dict[str, str] = field(default_factory=dict)
+    claude_command: str = "claude --dangerously-skip-permissions"
+    context: str = ""
+    context_paths: list[str] = field(default_factory=list)
+
+
+@dataclass
+class StudyConfig:
+    """Configuration for a research study."""
+
+    name: str
+    cluster: str
+    claude_md_path: str = ""
+    context: str = ""
+    sprints_dir: str = ""
+    claude_command: str = ""
+    job_options: dict[str, str] = field(default_factory=dict)
+    max_sprint_duration_hours: int = 8
+    red_team_max_rounds: int = 3
+    description: str = ""
+    allow_loop: bool = True
+
+
+@dataclass
+class SlackConfig:
+    """Slack notification settings."""
+
+    bot_token: str = ""
+    signing_secret: str = ""
+    channel_id: str | None = None
+    allowed_user_ids: list[str] = field(default_factory=list)
+    restrict_to_channel: bool = False
+
+
+@dataclass
+class NtfyConfig:
+    """Ntfy notification settings."""
+
+    url: str = "https://ntfy.sh"
+    topic: str = ""
+
+
+@dataclass
+class DashboardConfig:
+    """Dashboard web UI settings."""
+
+    enabled: bool = True
+    host: str = "0.0.0.0"
+    port: int = 8080
+    password_hash: str | None = None
+
+
+@dataclass
+class Config:
+    """Top-level researchloop configuration."""
+
+    studies: list[StudyConfig] = field(default_factory=list)
+    clusters: list[ClusterConfig] = field(default_factory=list)
+    slack: SlackConfig | None = None
+    ntfy: NtfyConfig | None = None
+    dashboard: DashboardConfig = field(default_factory=DashboardConfig)
+    claude_command: str = ""
+    context: str = ""
+    context_paths: list[str] = field(default_factory=list)
+    db_path: str = "researchloop.db"
+    artifact_dir: str = "artifacts"
+    shared_secret: str | None = None
+    orchestrator_url: str | None = None
+
+
+def _parse_cluster(data: dict) -> ClusterConfig:
+    ctx = data.get("context_paths", [])
+    if isinstance(ctx, str):
+        ctx = [ctx]
+    return ClusterConfig(
+        name=data["name"],
+        host=data.get("host", ""),
+        port=data.get("port", 22),
+        user=data.get("user", ""),
+        key_path=data.get("key_path", ""),
+        scheduler_type=data.get("scheduler_type", "slurm"),
+        working_dir=data.get("working_dir", ""),
+        max_concurrent_jobs=data.get("max_concurrent_jobs", 4),
+        environment=data.get("environment", {}),
+        job_options=data.get("job_options", {}),
+        claude_command=data.get(
+            "claude_command",
+            "claude --dangerously-skip-permissions",
+        ),
+        context=data.get("context", ""),
+        context_paths=ctx,
+    )
+
+
+def _parse_study(data: dict) -> StudyConfig:
+    return StudyConfig(
+        name=data["name"],
+        cluster=data.get("cluster", ""),
+        claude_md_path=data.get("claude_md_path", ""),
+        context=data.get("context", ""),
+        sprints_dir=data.get("sprints_dir", ""),
+        max_sprint_duration_hours=data.get("max_sprint_duration_hours", 8),
+        red_team_max_rounds=data.get("red_team_max_rounds", 3),
+        claude_command=data.get("claude_command", ""),
+        job_options=data.get("job_options", {}),
+        description=data.get("description", ""),
+        allow_loop=data.get("allow_loop", True),
+    )
+
+
+def _parse_config(data: dict) -> Config:
+    clusters = [_parse_cluster(c) for c in data.get("cluster", [])]
+    studies = [_parse_study(s) for s in data.get("study", [])]
+
+    slack = None
+    if "slack" in data:
+        s = data["slack"]
+        allowed = s.get("allowed_user_ids", [])
+        if isinstance(allowed, str):
+            allowed = [allowed]
+        slack = SlackConfig(
+            bot_token=s.get("bot_token", ""),
+            signing_secret=s.get("signing_secret", ""),
+            channel_id=s.get("channel_id"),
+            allowed_user_ids=allowed,
+            restrict_to_channel=s.get("restrict_to_channel", False),
+        )
+
+    ntfy = None
+    if "ntfy" in data:
+        n = data["ntfy"]
+        ntfy = NtfyConfig(
+            url=n.get("url", "https://ntfy.sh"),
+            topic=n.get("topic", ""),
+        )
+
+    dashboard_data = data.get("dashboard", {})
+    dashboard = DashboardConfig(
+        enabled=dashboard_data.get("enabled", True),
+        host=dashboard_data.get("host", "0.0.0.0"),
+        port=dashboard_data.get("port", 8080),
+        password_hash=dashboard_data.get("password_hash"),
+    )
+
+    global_ctx = data.get("context_paths", [])
+    if isinstance(global_ctx, str):
+        global_ctx = [global_ctx]
+
+    return Config(
+        studies=studies,
+        clusters=clusters,
+        slack=slack,
+        ntfy=ntfy,
+        dashboard=dashboard,
+        claude_command=data.get("claude_command", ""),
+        context=data.get("context", ""),
+        context_paths=global_ctx,
+        db_path=data.get("db_path", "researchloop.db"),
+        artifact_dir=data.get("artifact_dir", "artifacts"),
+        shared_secret=data.get("shared_secret"),
+        orchestrator_url=data.get("orchestrator_url"),
+    )
+
+
+def load_config(path: str | None = None) -> Config:
+    """Load configuration from a researchloop.toml file.
+
+    Search order:
+      1. Explicit ``path`` argument.
+      2. ``researchloop.toml`` in the current working directory.
+      3. ``~/.config/researchloop/researchloop.toml``.
+
+    Returns a ``Config`` instance.  Raises ``FileNotFoundError`` if no
+    configuration file can be located.
+    """
+    if path is not None:
+        config_path = Path(path)
+        if not config_path.exists():
+            raise FileNotFoundError(f"Config file not found: {path}")
+    else:
+        config_path = None
+        for search_dir in CONFIG_SEARCH_PATHS:
+            for filename in CONFIG_FILENAMES:
+                candidate = search_dir / filename
+                if candidate.exists():
+                    config_path = candidate
+                    break
+            if config_path is not None:
+                break
+
+        if config_path is None:
+            raise FileNotFoundError(
+                "No researchloop.toml found. Searched: "
+                + ", ".join(str(p) for p in CONFIG_SEARCH_PATHS)
+            )
+
+    with open(config_path, "rb") as f:
+        data = tomllib.load(f)
+
+    config = _parse_config(data)
+    _apply_env_overrides(config)
+    return config
+
+
+# ------------------------------------------------------------------
+# Environment variable overrides
+# ------------------------------------------------------------------
+
+_ENV_PREFIX = "RESEARCHLOOP_"
+
+
+def _env(name: str) -> str | None:
+    """Read an env var with the RESEARCHLOOP_ prefix."""
+    return os.environ.get(f"{_ENV_PREFIX}{name}")
+
+
+def _apply_env_overrides(config: Config) -> None:
+    """Override config values from environment variables.
+
+    Env vars take precedence over TOML values.  Supported vars::
+
+        RESEARCHLOOP_SHARED_SECRET
+        RESEARCHLOOP_ORCHESTRATOR_URL
+        RESEARCHLOOP_DB_PATH
+        RESEARCHLOOP_ARTIFACT_DIR
+        RESEARCHLOOP_SLACK_BOT_TOKEN
+        RESEARCHLOOP_SLACK_SIGNING_SECRET
+        RESEARCHLOOP_SLACK_CHANNEL_ID
+        RESEARCHLOOP_SLACK_ALLOWED_USER_IDS
+        RESEARCHLOOP_NTFY_URL
+        RESEARCHLOOP_NTFY_TOPIC
+        RESEARCHLOOP_DASHBOARD_PASSWORD
+        RESEARCHLOOP_DASHBOARD_PASSWORD_HASH
+        RESEARCHLOOP_DASHBOARD_PORT
+        RESEARCHLOOP_DASHBOARD_HOST
+    """
+    # Top-level secrets / settings
+    if v := _env("SHARED_SECRET"):
+        config.shared_secret = v
+    if v := _env("ORCHESTRATOR_URL"):
+        config.orchestrator_url = v
+    if v := _env("DB_PATH"):
+        config.db_path = v
+    if v := _env("ARTIFACT_DIR"):
+        config.artifact_dir = v
+
+    # Slack
+    if _env("SLACK_BOT_TOKEN"):
+        if config.slack is None:
+            config.slack = SlackConfig()
+        config.slack.bot_token = _env("SLACK_BOT_TOKEN") or ""
+    if _env("SLACK_SIGNING_SECRET"):
+        if config.slack is None:
+            config.slack = SlackConfig()
+        config.slack.signing_secret = _env("SLACK_SIGNING_SECRET") or ""
+    if v := _env("SLACK_CHANNEL_ID"):
+        if config.slack is None:
+            config.slack = SlackConfig()
+        config.slack.channel_id = v
+    if v := _env("SLACK_ALLOWED_USER_IDS"):
+        if config.slack is None:
+            config.slack = SlackConfig()
+        config.slack.allowed_user_ids = [
+            uid.strip() for uid in v.split(",") if uid.strip()
+        ]
+
+    # ntfy
+    if _env("NTFY_TOPIC"):
+        if config.ntfy is None:
+            config.ntfy = NtfyConfig()
+        config.ntfy.topic = _env("NTFY_TOPIC") or ""
+    if v := _env("NTFY_URL"):
+        if config.ntfy is None:
+            config.ntfy = NtfyConfig()
+        config.ntfy.url = v
+
+    # Dashboard
+    if v := _env("DASHBOARD_PASSWORD"):
+        import bcrypt
+
+        config.dashboard.password_hash = bcrypt.hashpw(
+            v.encode("utf-8"), bcrypt.gensalt()
+        ).decode("utf-8")
+    if v := _env("DASHBOARD_PASSWORD_HASH"):
+        config.dashboard.password_hash = v
+    if v := _env("DASHBOARD_PORT"):
+        config.dashboard.port = int(v)
+    if v := _env("DASHBOARD_HOST"):
+        config.dashboard.host = v

researchloop/core/credentials.py

@@ -0,0 +1,38 @@
+"""Local CLI credentials for connecting to a remote orchestrator."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+_CREDENTIALS_PATH = Path.home() / ".config" / "researchloop" / "credentials.json"
+
+
+def save_credentials(url: str, token: str) -> Path:
+    """Save orchestrator URL and API token to disk."""
+    _CREDENTIALS_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _CREDENTIALS_PATH.write_text(
+        json.dumps({"url": url, "token": token}, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    _CREDENTIALS_PATH.chmod(0o600)
+    return _CREDENTIALS_PATH
+
+
+def load_credentials() -> dict[str, str] | None:
+    """Load saved credentials, or None if not configured."""
+    if not _CREDENTIALS_PATH.exists():
+        return None
+    try:
+        data = json.loads(_CREDENTIALS_PATH.read_text(encoding="utf-8"))
+        if data.get("url") and data.get("token"):
+            return data
+        return None
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def clear_credentials() -> None:
+    """Remove saved credentials."""
+    if _CREDENTIALS_PATH.exists():
+        _CREDENTIALS_PATH.unlink()