@openhands/extensions 0.21.0 → 0.22.1

package/skills/github-pr-reviewer/scripts/agent_conversation.py

@@ -0,0 +1,150 @@
+"""Idempotently deliver automation work to profile-backed conversations."""
+
+import json
+import os
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+from uuid import NAMESPACE_URL, UUID, uuid5
+
+import httpx
+from openhands.sdk import RemoteConversation
+from openhands.sdk.conversation.request import (
+    SendMessageRequest,
+    StartConversationRequest,
+)
+from openhands.sdk.conversation.state import ConversationExecutionStatus
+from openhands.sdk.llm.message import TextContent
+from openhands.sdk.workspace import LocalWorkspace, RemoteWorkspace
+
+_CONVERSATION_KEY_PREFIX = "agent-conversation-"
+
+
+def _register_tools() -> None:
+    """Register tool models needed to deserialize an attached agent."""
+    from openhands.tools import register_default_tools
+
+    register_default_tools()
+
+
+def _kv_request(key: str, method: str, value: dict | None = None) -> dict | None:
+    base_url = os.environ.get("AUTOMATION_API_URL", "").rstrip("/")
+    token = os.environ.get("AUTOMATION_KV_TOKEN", "")
+    if not base_url or not token:
+        raise RuntimeError("Automation KV is required for agent conversation dispatch")
+    request = Request(
+        f"{base_url}/v1/kv/{key}",
+        data=json.dumps(value).encode() if value is not None else None,
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        },
+        method=method,
+    )
+    try:
+        with urlopen(request, timeout=90) as response:
+            body = json.load(response)
+    except HTTPError as exc:
+        if method == "GET" and exc.code == 404:
+            return None
+        raise
+    return body.get("value") if method == "GET" else body
+
+
+class AgentConversationDispatcher:
+    """Deliver one revision at a time to a stable conversation for each subject."""
+
+    def __init__(self) -> None:
+        self.agent_url = os.environ["AGENT_SERVER_URL"]
+        self.api_key = os.environ["SESSION_API_KEY"]
+        self.profile_id = UUID(os.environ["AUTOMATION_AGENT_PROFILE_ID"])
+        payload = json.loads(os.environ["AUTOMATION_EVENT_PAYLOAD"])
+        self.automation_id = str(payload["automation_id"])
+        self._workspace: RemoteWorkspace | None = None
+        self._secrets = {}
+
+    def __enter__(self):
+        _register_tools()
+        self._workspace = RemoteWorkspace(
+            host=self.agent_url,
+            api_key=self.api_key,
+            working_dir=os.environ.get("WORKSPACE_BASE", "/workspace"),
+        )
+        self._workspace.__enter__()
+        self._secrets = self._workspace.get_secrets(
+            agent_profile_id=str(self.profile_id)
+        )
+        return self
+
+    def __exit__(self, *args):
+        assert self._workspace is not None
+        return self._workspace.__exit__(*args)
+
+    def deliver(self, subject: str, delivery: str, prompt: str) -> dict[str, str]:
+        conversation_id = uuid5(NAMESPACE_URL, f"{self.automation_id}:{subject}")
+        state_key = f"{_CONVERSATION_KEY_PREFIX}{conversation_id}"
+        record = _kv_request(state_key, "GET") or {}
+        if self._workspace is None:
+            raise RuntimeError("AgentConversationDispatcher must be used as a context")
+
+        same_delivery = record.get("delivery") == delivery
+
+        try:
+            conversation = RemoteConversation.attach(
+                self._workspace, conversation_id, visualizer=None
+            )
+            disposition = "resumed"
+        except httpx.HTTPStatusError as exc:
+            if exc.response.status_code != 404:
+                raise
+            conversation = RemoteConversation.create(
+                self._workspace,
+                StartConversationRequest(
+                    workspace=LocalWorkspace(working_dir="/workspace"),
+                    conversation_id=conversation_id,
+                    agent_profile_id=self.profile_id,
+                    secrets=self._secrets,
+                    initial_message=SendMessageRequest(
+                        content=[TextContent(text=prompt)], run=True
+                    ),
+                ),
+                visualizer=None,
+            )
+            disposition = "created"
+        try:
+            if disposition == "resumed":
+                if same_delivery:
+                    if conversation.state.execution_status in (
+                        ConversationExecutionStatus.IDLE,
+                        ConversationExecutionStatus.RUNNING,
+                        ConversationExecutionStatus.PAUSED,
+                    ):
+                        conversation.update_secrets(self._secrets)
+                        conversation.run(blocking=False)
+                    else:
+                        disposition = "deduplicated"
+                else:
+                    conversation.update_secrets(self._secrets)
+                    conversation.send_message(prompt)
+                    conversation.run(blocking=False)
+        finally:
+            conversation.close()
+
+        if disposition == "deduplicated":
+            return {
+                "disposition": disposition,
+                "conversation_id": str(conversation_id),
+            }
+
+        _kv_request(
+            state_key,
+            "PUT",
+            {
+                "subject": subject,
+                "conversation_id": str(conversation_id),
+                "delivery": delivery,
+            },
+        )
+        return {
+            "disposition": disposition,
+            "conversation_id": str(conversation_id),
+        }

package/skills/github-pr-reviewer/scripts/github_client.py

@@ -0,0 +1,230 @@
+"""Shared GitHub transport and repository operations for GitHub automations."""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+from functools import cached_property
+from pathlib import Path
+from urllib.error import HTTPError
+from urllib.parse import parse_qsl, urlencode, urlsplit
+from urllib.request import Request, urlopen
+
+
+def _load_secret(name: str) -> str:
+    """Read one named secret from the environment or configured Agent Server."""
+    value = os.environ.get(name)
+    if value:
+        return value
+
+    from openhands.sdk.workspace import RemoteWorkspace
+
+    workspace = RemoteWorkspace(
+        host=os.environ["AGENT_SERVER_URL"],
+        api_key=os.environ["SESSION_API_KEY"],
+        working_dir=os.environ.get("WORKSPACE_BASE", "/workspace"),
+    )
+    try:
+        secret = workspace.get_secrets([name]).get(name)
+        value = secret.get_value() if secret else None
+    finally:
+        workspace.reset_client()
+    if not value:
+        raise ValueError(f"The GitHub credential {name} is unavailable")
+    return value
+
+
+def github_request(
+    token: str,
+    method: str,
+    path: str,
+    params: dict | None = None,
+    body: dict | None = None,
+    accept: str = "application/vnd.github+json",
+) -> tuple:
+    url = f"https://api.github.com{path}"
+    if params:
+        url = f"{url}?{urlencode(params)}"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": accept,
+        "X-GitHub-Api-Version": "2022-11-28",
+        "Content-Type": "application/json",
+    }
+    data = json.dumps(body).encode() if body is not None else None
+    req = Request(url, data=data, headers=headers, method=method)
+    with urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return (json.loads(raw) if raw.strip() else {}), dict(r.headers)
+
+
+def github_paginate(token: str, path: str, params: dict | None = None) -> list:
+    results = []
+    base_params = dict(params or {})
+    base_params.setdefault("per_page", 100)
+    for page in range(1, 101):
+        base_params["page"] = page
+        data, _ = github_request(token, "GET", path, params=base_params)
+        if not isinstance(data, list):
+            raise TypeError("Expected a paginated GitHub list")
+        results.extend(data)
+        if len(data) < int(base_params["per_page"]):
+            return results
+    raise RuntimeError("GitHub pagination exceeded limit")
+
+
+class GitHubRepository:
+    name = "GitHub automation"
+
+    def __init__(
+        self,
+        config_path=Path("config.json"),
+        *,
+        github_token_secret,
+        repository=None,
+        conversation=None,
+        dispatcher=None,
+    ):
+        self.config = json.loads(Path(config_path).read_text())
+        self.repository = repository or self.config["repository"]
+        if not re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", self.repository):
+            raise ValueError("repository must be owner/repo")
+        if not re.fullmatch(r"[A-Z_][A-Z0-9_]*", github_token_secret):
+            raise ValueError(
+                "Expected the environment variable containing the GitHub token"
+            )
+        self.token_name = github_token_secret
+        self.token = _load_secret(github_token_secret)
+        self.conversation = conversation
+        self.conversation_id = str(conversation.id) if conversation else None
+        self.dispatcher = dispatcher
+        self.workspace = Path(os.environ["WORKSPACE_BASE"])
+        self.project = self.workspace
+        self.evidence = self.workspace / "evidence"
+        self.evidence.mkdir(exist_ok=True)
+        self._completed_dependencies = {}
+
+    @cached_property
+    def base_branch(self):
+        return self.config.get("base_branch") or self.gh("GET", "")["default_branch"]
+
+    @property
+    def github_instructions(self):
+        return (
+            f"Use `GH_TOKEN=${self.token_name} gh api` for GitHub requests. "
+            "Never print the credential value. "
+            f"Only {self.repository} is in scope. Work in {self.project}. "
+            "Do not modify the automation bundle or its configuration."
+        )
+
+    def gh(self, method, path, body=None):
+        return github_request(
+            self.token, method, f"/repos/{self.repository}" + path, body=body
+        )[0]
+
+    def shell(self, args, cwd=None, timeout=300):
+        result = subprocess.run(
+            args,
+            cwd=cwd or self.project,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            timeout=timeout,
+            check=False,
+        )
+        if result.returncode:
+            raise RuntimeError(
+                f"{args[0]} failed: {result.stdout[-4000:].replace(self.token, '[REDACTED]')}"
+            )
+        return result.stdout.strip()
+
+    def comment(self, number, text):
+        return self.gh(
+            "POST",
+            f"/issues/{number}/comments",
+            {
+                "body": text
+                + f"\n\nFactory role: `{self.name}`; conversation: `{self.conversation_id}`."
+                + "\n\n_This comment was posted by an AI agent (OpenHands)._"
+            },
+        )
+
+    def open_issues(self):
+        return [
+            i for i in self.gh_pages("/issues?state=open") if "pull_request" not in i
+        ]
+
+    def statuses(self, sha):
+        result = {}
+        for item in self.gh_pages(f"/commits/{sha}/statuses"):
+            result.setdefault(item["context"], item["state"])
+        return result
+
+    def completed_dependency(self, number):
+        if number in self._completed_dependencies:
+            return self._completed_dependencies[number]
+        try:
+            dependency = self.gh("GET", f"/issues/{number}")
+        except HTTPError as exc:
+            if exc.code == 404:
+                return False
+            raise
+        completed = (
+            dependency["state"] == "closed"
+            and dependency.get("state_reason") == "completed"
+        )
+        self._completed_dependencies[number] = completed
+        return completed
+
+    def dependencies_complete(self, issue):
+        """Honor explicit Depends on lines; unknown/incomplete issues remain blocked."""
+        for line in re.findall(
+            "^Depends on:\\s*(.+)$",
+            issue.get("body") or "",
+            re.MULTILINE | re.IGNORECASE,
+        ):
+            for number in re.findall("#(\\d+)", line):
+                if not self.completed_dependency(number):
+                    return False
+        return True
+
+    def gh_pages(self, endpoint):
+        split = urlsplit(endpoint)
+        return github_paginate(
+            self.token,
+            f"/repos/{self.repository}" + split.path,
+            params=dict(parse_qsl(split.query)),
+        )
+
+
+def run_repositories(automation_type, conversation=None, dispatcher=None):
+    parser = argparse.ArgumentParser(description=automation_type.__doc__)
+    parser.add_argument("--github-token-secret")
+    args = parser.parse_args()
+    config = json.loads(Path("config.json").read_text())
+    token_name = args.github_token_secret or config.get(
+        "github_token_secret", "GITHUB_PERSONAL_ACCESS_TOKEN"
+    )
+    repositories = config.get("repos") or [config["repository"]]
+    failures = []
+    for repository in repositories:
+        options = dict(
+            github_token_secret=token_name,
+            repository=repository,
+            conversation=conversation,
+        )
+        if dispatcher is not None:
+            options["dispatcher"] = dispatcher
+        automation = automation_type(**options)
+        try:
+            automation.run()
+        except Exception as exc:  # noqa: BLE001 - one repository must not block others
+            failures.append(repository)
+            print(
+                json.dumps({"repository": repository, "error": type(exc).__name__}),
+                flush=True,
+            )
+    if failures:
+        raise RuntimeError("Automation failed for: " + ", ".join(failures))
+    return str(conversation.id) if conversation else None

package/skills/github-pr-reviewer/scripts/main.py

@@ -8,10 +8,10 @@ GitHub `labeled` event has not already been processed by this automation.
 Each repository is polled independently and keeps its own state document, so
 pull-request numbers never collide across repositories.
 
-The script owns the repository checkout: it downloads the pull request's head
-commit as a tarball, hands the agent that directory as its workspace, and
-removes it once the review has finished. The agent never clones, checks out, or
-deletes anything.
+This standalone script owns the repository checkout: it downloads the pull
+request's head commit as a tarball, hands the agent that directory as its
+workspace, and removes it once the review has finished. Catalog workers may
+instead reuse its prompt builder with their own workspace instructions.
 """
 
 import io
@@ -732,7 +732,16 @@ def _load_repo_review_guide(workspace_dir: Path) -> str | None:
     return None
 
 
-def _build_review_prompt(repo: str, pr: dict, head_sha: str, label_event: dict, repo_review_guide: str | None = None) -> str:
+def _build_review_prompt(
+    repo: str,
+    pr: dict,
+    head_sha: str,
+    label_event: dict,
+    repo_review_guide: str | None = None,
+    *,
+    workspace_instructions: str | None = None,
+    github_token_secret: str = "GITHUB_PERSONAL_ACCESS_TOKEN",
+) -> str:
     number = pr.get("number", "?")
     title = pr.get("title", "(no title)")
     body = (pr.get("body") or "").strip() or "(no description)"
@@ -752,6 +761,10 @@ def _build_review_prompt(repo: str, pr: dict, head_sha: str, label_event: dict,
         f"\n\nRepo-specific review guide (from {REPO_REVIEW_GUIDE_PATH}):\n---\n{repo_review_guide}\n---\n"
         if repo_review_guide else ""
     )
+    workspace = workspace_instructions or (
+        "The workspace is already the repository root at the exact Head SHA above. "
+        "Do not clone, fetch, check out, or delete the repository."
+    )
 
     return (
         "You are an AI code reviewer. Review the GitHub pull request below and publish "
@@ -768,8 +781,7 @@ def _build_review_prompt(repo: str, pr: dict, head_sha: str, label_event: dict,
         f"URL        : {html_url}\n"
         f"\nPR Description:\n---\n{body}\n---\n\n"
         "Required workflow:\n"
-        "1. The workspace is already the repository root at the exact Head SHA above. "
-        "Do not clone, fetch, check out, or delete the repository.\n"
+        f"1. {workspace}\n"
         "2. Before reviewing, you MUST read the repository's own guidance to understand the repo first.\n"
         "   Read `AGENTS.md` at the repository root (and any nested `AGENTS.md` covering the "
         "changed files), plus other relevant docs when present - e.g. `CONTRIBUTING.md`, "
@@ -777,7 +789,7 @@ def _build_review_prompt(repo: str, pr: dict, head_sha: str, label_event: dict,
         "guidance to your review.\n"
         "   Then inspect the PR discussion, existing review comments, changed files, and the diff, "
         "together with the surrounding code in the workspace.\n"
-        "   Use `gh` or GitHub REST API calls with `GITHUB_PERSONAL_ACCESS_TOKEN`; never print secret values.\n"
+        f"   Use `gh` or GitHub REST API calls with `{github_token_secret}`; never print secret values.\n"
         "3. Ground every finding in the workspace code. Before using an inline location, verify that "
         "the path and line are part of this pull request's diff.\n"
         f"4. Publish one review with `POST /repos/{repo}/pulls/{number}/reviews`, using "

package/skills/github-pr-reviewer/scripts/worker.py

@@ -0,0 +1,94 @@
+"""Select labeled PR heads and delegate each review to a sandboxed agent."""
+
+import json
+
+import main as workflow
+from agent_conversation import AgentConversationDispatcher
+from github_client import GitHubRepository, run_repositories
+
+
+class PullRequestReviewer(GitHubRepository):
+    name = "github-pr-reviewer"
+
+    def _prompt(self, pr, label_event):
+        number = pr["number"]
+        sha = pr["head"]["sha"]
+        label = self.config.get("trigger_label", workflow.TRIGGER_LABEL)
+        token = self.token_name
+        workspace = (
+            "The workspace contains an empty Git repository. Before fetching, run "
+            f"`GH_TOKEN=${{{token}}} gh auth setup-git` so Git uses the "
+            "profile-scoped credential without storing it in the remote URL. Set "
+            f"the plain HTTPS origin to `https://github.com/{self.repository}.git`, "
+            f"fetch PR #{number}, and check out exact head `{sha}` in detached-HEAD "
+            "mode. Set `GIT_TERMINAL_PROMPT=0` on Git network commands so a missing "
+            "permission fails immediately instead of waiting for input."
+        )
+        prompt = workflow._build_review_prompt(
+            self.repository,
+            pr,
+            sha,
+            label_event,
+            workspace_instructions=workspace,
+            github_token_secret=token,
+        )
+        return (
+            prompt + "\n\nAcceptance reporting:\n"
+            "- Inspect the current GitHub Actions results for the exact head and run "
+            "the repository's appropriate focused tests in the workspace. Do not "
+            "modify tracked files.\n"
+            f"- Re-read {self.repository} PR #{number} immediately before reporting. "
+            f"If its head is no longer `{sha}`, publish no status and leave `{label}` "
+            "in place so the new head is reviewed.\n"
+            "- After the readable native review is accepted by GitHub, set commit "
+            "status `software-factory/review` to success only for an `✅ APPROVED` "
+            "verdict, otherwise failure. Set `software-factory/tests` to success only "
+            "when the relevant checks and tests pass, otherwise failure. Use the exact "
+            f"head `{sha}` for both statuses.\n"
+            f"- After both statuses are visible on that head, remove the `{label}` "
+            "label. Never paste JSON artifacts or full command logs into comments."
+        )
+
+    def run(self):
+        repository_id = self.gh("GET", "")["id"]
+        label = self.config.get("trigger_label", workflow.TRIGGER_LABEL)
+        prs = self.gh_pages("/pulls?state=open&sort=updated&direction=asc")
+        for candidate in prs:
+            if label not in {item["name"] for item in candidate.get("labels", [])}:
+                continue
+            try:
+                pr = self.gh("GET", f"/pulls/{candidate['number']}")
+                event = workflow._latest_trigger_label_event(
+                    self.token, self.repository, pr["number"]
+                )
+                if event is None:
+                    continue
+                sha = pr["head"]["sha"]
+                result = self.dispatcher.deliver(
+                    subject=f"{repository_id}:pr:{pr['number']}",
+                    delivery=f"{event['id']}:{sha}",
+                    prompt=self._prompt(pr, event),
+                )
+                print(
+                    json.dumps(
+                        {
+                            "repository": self.repository,
+                            "pr": pr["number"],
+                            "head_sha": sha,
+                            "disposition": result["disposition"],
+                            "conversation_id": result["conversation_id"],
+                        }
+                    ),
+                    flush=True,
+                )
+            except Exception as exc:  # noqa: BLE001 - one PR must not block the scan
+                print(
+                    f"Failed to submit {self.repository} PR "
+                    f"#{candidate.get('number', '?')}: {exc}",
+                    flush=True,
+                )
+
+
+if __name__ == "__main__":
+    with AgentConversationDispatcher() as dispatcher:
+        run_repositories(PullRequestReviewer, dispatcher=dispatcher)

package/skills/github-repo-monitor/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "github-repo-monitor",
+  "version": "1.0.0",
+  "description": "Create a cron automation that polls a GitHub repository for issue and PR comments containing a configurable trigger phrase (@OpenHands by default). Starts an OpenHands conversation with full issue/PR context, posts acknowledgement comments with a conversation link, and summarises results back to the issue/PR when the agent finishes.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": [
+    "github",
+    "monitor",
+    "issues",
+    "pull-requests",
+    "trigger",
+    "cron",
+    "automation",
+    "integration"
+  ]
+}

package/skills/github-repo-monitor/.codex-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "github-repo-monitor",
+  "version": "1.0.0",
+  "description": "Create a cron automation that polls a GitHub repository for issue and PR comments containing a configurable trigger phrase (@OpenHands by default). Starts an OpenHands conversation with full issue/PR context, posts acknowledgement comments with a conversation link, and summarises results back to the issue/PR when the agent finishes.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": [
+    "github",
+    "monitor",
+    "issues",
+    "pull-requests",
+    "trigger",
+    "cron",
+    "automation",
+    "integration"
+  ]
+}