@borgee/agents-host 0.2.1 → 0.2.26

package/skills/borgee-agent/borgee-agent.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from urllib.error import HTTPError
+from urllib.parse import quote, urlencode
+from urllib.request import Request, urlopen
+
+TASK_THREAD_COLLECTION_COMMAND_ERROR = (
+    "Task assignment threads only support --get-task and --update-task. "
+    "Create/list tasks belong to the parent channel."
+)
+TASK_THREAD_MISSING_TASK_ID_ERROR = (
+    "Task assignment thread could not resolve the current task from persisted context "
+    "or local fallback. Pass --task-id explicitly."
+)
+
+
+def parse_int(flag: str, value: str | None) -> int:
+    if value is None:
+        raise ValueError(f"Missing value after {flag}")
+    try:
+        return int(value)
+    except ValueError as exc:
+        raise ValueError(f"Invalid integer for {flag}: {value}") from exc
+
+
+def parse_args(argv: list[str]) -> dict[str, object]:
+    context_path: Path | None = None
+    auth_path: Path | None = None
+    turn_execution_id: str | None = None
+    action = "print-bootstrap"
+    limit: int | None = None
+    before: int | None = None
+    after: int | None = None
+    body: str | None = None
+    reply_to_id: str | None = None
+    mention_target_id: str | None = None
+    mentions: list[str] = []
+    title: str | None = None
+    description: str | None = None
+    assignee_id: str | None = None
+    task_id: str | None = None
+    status: str | None = None
+    index = 0
+
+    def set_action(next_action: str) -> None:
+        nonlocal action
+        if action != "print-bootstrap":
+            raise ValueError("Only one action flag may be used per invocation")
+        action = next_action
+
+    while index < len(argv):
+        arg = argv[index]
+        if arg == "--context":
+            index += 1
+            if index >= len(argv):
+                raise ValueError("Missing path after --context")
+            context_path = Path(argv[index]).resolve()
+        elif arg == "--auth-path":
+            index += 1
+            if index >= len(argv):
+                raise ValueError("Missing path after --auth-path")
+            auth_path = Path(argv[index]).resolve()
+        elif arg == "--turn-execution-id":
+            index += 1
+            if index >= len(argv):
+                raise ValueError("Missing value after --turn-execution-id")
+            turn_execution_id = argv[index].strip()
+        elif arg == "--print-bootstrap":
+            action = "print-bootstrap"
+        elif arg == "--health":
+            set_action("health")
+        elif arg == "--read-bootstrap":
+            set_action("read-bootstrap")
+        elif arg == "--get-me":
+            set_action("get-me")
+        elif arg == "--read-history":
+            set_action("read-history")
+        elif arg == "--read-draft":
+            set_action("read-draft")
+        elif arg == "--list-users":
+            set_action("list-users")
+        elif arg == "--send-message":
+            set_action("send-message")
+        elif arg == "--send-mention":
+            set_action("send-mention")
+            index += 1
+            if index >= len(argv):
+                raise ValueError("Missing value after --send-mention")
+            mention_target_id = argv[index].strip()
+            if not mention_target_id:
+                raise ValueError("Missing value after --send-mention")
+        elif arg == "--create-task":
+            set_action("create-task")
+        elif arg == "--list-tasks":
+            set_action("list-tasks")
+        elif arg == "--get-task":
+            set_action("get-task")
+        elif arg == "--update-task":
+            set_action("update-task")
+        elif arg == "--limit":
+            index += 1
+            limit = parse_int(arg, argv[index] if index < len(argv) else None)
+        elif arg == "--before":
+            index += 1
+            before = parse_int(arg, argv[index] if index < len(argv) else None)
+        elif arg == "--after":
+            index += 1
+            after = parse_int(arg, argv[index] if index < len(argv) else None)
+        elif arg == "--body":
+            index += 1
+            if index >= len(argv):
+                raise ValueError("Missing value after --body")
+            body = argv[index]
+        elif arg == "--reply-to":
+            index += 1
+            if index >= len(argv):
+                raise ValueError("Missing value after --reply-to")
+            reply_to_id = argv[index]
+        elif arg == "--mention":
+            index += 1
+            if index >= len(argv):
+                raise ValueError("Missing value after --mention")
+            mention = argv[index].strip()
+            if not mention:
+                raise ValueError("Missing value after --mention")
+            mentions.append(mention)
+        elif arg == "--title":
+            index += 1
+            title = argv[index] if index < len(argv) else None
+        elif arg == "--description":
+            index += 1
+            description = argv[index] if index < len(argv) else None
+        elif arg == "--assignee-id":
+            index += 1
+            assignee_id = argv[index] if index < len(argv) else None
+        elif arg == "--task-id":
+            index += 1
+            task_id = argv[index] if index < len(argv) else None
+        elif arg == "--status":
+            index += 1
+            status = argv[index] if index < len(argv) else None
+        else:
+            raise ValueError(f"Unknown argument: {arg}")
+        index += 1
+
+    if context_path is None:
+        raise ValueError("Missing required --context <path> argument")
+    return {
+        "context_path": context_path,
+        "auth_path": auth_path,
+        "turn_execution_id": turn_execution_id,
+        "action": action,
+        "limit": limit,
+        "before": before,
+        "after": after,
+        "body": body,
+        "reply_to_id": reply_to_id,
+        "mention_target_id": mention_target_id,
+        "mentions": mentions,
+        "title": title,
+        "description": description,
+        "assignee_id": assignee_id,
+        "task_id": task_id,
+        "status": status,
+    }
+
+
+def ensure_visible_mention(body: str, participant_id: str) -> str:
+    token = f"<@{participant_id}>"
+    if token in body:
+        return body
+    separator = "" if body.endswith((" ", "\n", "\t")) else " "
+    return f"{body}{separator}{token}"
+
+
+def ensure_visible_mentions(body: str, participant_ids: list[str]) -> str:
+    next_body = body
+    for participant_id in participant_ids:
+        next_body = ensure_visible_mention(next_body, participant_id)
+    return next_body
+
+
+def explicit_task_id_provided(options: dict[str, object]) -> bool:
+    task_id = options.get("task_id")
+    return isinstance(task_id, str) and bool(task_id.strip())
+
+
+def resolve_task_id(payload: dict[str, object], action: str, options: dict[str, object]) -> str | None:
+    task_id = options.get("task_id")
+    if isinstance(task_id, str) and task_id.strip():
+        return task_id.strip()
+    task_assignment_context = payload.get("taskAssignmentContext")
+    if isinstance(task_assignment_context, dict) and task_assignment_context.get("active") is True:
+        current_task_id = task_assignment_context.get("currentTaskId")
+        if isinstance(current_task_id, str) and current_task_id.strip():
+            return current_task_id.strip()
+        return None
+    raise ValueError(f"Missing required --task-id <value> for --{action}")
+
+
+def resolve_gateway_request(
+    payload: dict[str, object],
+    action: str,
+    options: dict[str, object],
+) -> tuple[str, str, object | None, bool]:
+    gateway = payload.get("localhostGateway")
+    if not isinstance(gateway, dict):
+        raise ValueError("Missing localhostGateway bootstrap metadata in the context payload")
+    base_url = gateway.get("baseUrl")
+    if not isinstance(base_url, str):
+        raise ValueError("Missing localhostGateway bootstrap metadata in the context payload")
+    task_assignment_context = payload.get("taskAssignmentContext")
+    if action in ("create-task", "list-tasks") and isinstance(task_assignment_context, dict) and task_assignment_context.get("active") is True:
+        raise ValueError(TASK_THREAD_COLLECTION_COMMAND_ERROR)
+    channel_id = quote(str(payload.get("channelId", "")), safe="")
+    if action == "health":
+        return f"{base_url}/health", "GET", None, False
+    if action == "read-bootstrap":
+        return f"{base_url}/v1/channels/{channel_id}/bootstrap", "GET", None, False
+    if action == "get-me":
+        return f"{base_url}/v1/channels/{channel_id}/me", "GET", None, False
+    if action == "read-history":
+        query: dict[str, str] = {}
+        if options.get("limit") is not None:
+            query["limit"] = str(options["limit"])
+        if options.get("before") is not None:
+            query["before"] = str(options["before"])
+        if options.get("after") is not None:
+            query["after"] = str(options["after"])
+        suffix = f"?{urlencode(query)}" if query else ""
+        return f"{base_url}/v1/channels/{channel_id}/history{suffix}", "GET", None, False
+    if action == "read-draft":
+        turn_execution_id = options.get("turn_execution_id")
+        if not isinstance(turn_execution_id, str) or not turn_execution_id.strip():
+            raise ValueError("Missing required --turn-execution-id value for --read-draft")
+        suffix = urlencode({"turnExecutionId": turn_execution_id.strip()})
+        return f"{base_url}/v1/channels/{channel_id}/draft?{suffix}", "GET", None, False
+    if action == "list-users":
+        return f"{base_url}/v1/channels/{channel_id}/users", "GET", None, False
+    if action in ("send-message", "send-mention"):
+        return f"{base_url}/v1/channels/{channel_id}/messages", "POST", None, False
+    if action == "create-task":
+        title = options.get("title")
+        if not isinstance(title, str) or title == "":
+            raise ValueError("Missing required --title <value> for --create-task")
+        request_body: dict[str, object] = {"title": title}
+        if options.get("description") is not None:
+            request_body["description"] = options["description"]
+        if options.get("assignee_id") is not None:
+            request_body["assigneeId"] = options["assignee_id"]
+        return f"{base_url}/v1/channels/{channel_id}/tasks", "POST", request_body, False
+    if action == "list-tasks":
+        return f"{base_url}/v1/channels/{channel_id}/tasks", "GET", None, False
+    if action == "get-task":
+        task_id = resolve_task_id(payload, action, options)
+        if isinstance(task_assignment_context, dict) and task_assignment_context.get("active") is True and not explicit_task_id_provided(options):
+            return f"{base_url}/v1/channels/{channel_id}/current-task", "GET", None, True
+        return f"{base_url}/v1/tasks/{quote(str(task_id), safe='')}", "GET", None, False
+    if action == "update-task":
+        task_id = resolve_task_id(payload, action, options)
+        request_body: dict[str, object] = {}
+        if options.get("status") is not None:
+            request_body["status"] = options["status"]
+        if options.get("assignee_id") is not None:
+            request_body["assigneeId"] = options["assignee_id"]
+        if options.get("title") is not None:
+            request_body["title"] = options["title"]
+        if not request_body:
+            raise ValueError("At least one of --status, --assignee-id, or --title is required for --update-task")
+        if isinstance(task_assignment_context, dict) and task_assignment_context.get("active") is True and not explicit_task_id_provided(options):
+            return f"{base_url}/v1/channels/{channel_id}/current-task", "PATCH", request_body, True
+        return f"{base_url}/v1/tasks/{quote(str(task_id), safe='')}", "PATCH", request_body, False
+    raise ValueError(f"Unsupported gateway action: {action}")
+
+
+def read_gateway_auth(auth_path: Path | None, expected_channel_id: object) -> dict[str, str | None]:
+    if auth_path is None:
+        raise ValueError("Missing required --auth-path <path> argument for gateway access")
+    auth_payload = json.loads(auth_path.read_text(encoding="utf-8"))
+    token = None
+    localhost_gateway = auth_payload.get("localhostGateway")
+    if isinstance(localhost_gateway, dict):
+        raw_token = localhost_gateway.get("token")
+        if isinstance(raw_token, str):
+            token = raw_token
+    if auth_payload.get("channelId") != expected_channel_id or not token:
+        raise ValueError("Missing localhost gateway auth payload for this channel")
+    return {"token": token}
+
+
+def call_gateway(payload: dict[str, object], action: str, options: dict[str, object]) -> object:
+    auth = read_gateway_auth(
+        options.get("auth_path") if isinstance(options.get("auth_path"), Path) else None,
+        payload.get("channelId"),
+    )
+    url, method, request_body, uses_current_thread_fallback = resolve_gateway_request(payload, action, options)
+
+    data = None
+    headers = {"Authorization": f"Bearer {auth['token']}"}
+    if action in ("send-message", "send-mention"):
+        body = options.get("body")
+        if not isinstance(body, str) or not body.strip():
+            raise ValueError(f"Missing required --body value for --{action}")
+        turn_execution_id = options.get("turn_execution_id")
+        if not isinstance(turn_execution_id, str) or not turn_execution_id.strip():
+            raise ValueError(f"Missing required --turn-execution-id value for --{action}")
+        request_mentions = options.get("mentions")
+        if action == "send-mention":
+            mention_target_id = options.get("mention_target_id")
+            if not isinstance(mention_target_id, str) or not mention_target_id.strip():
+                raise ValueError("Missing required target user id after --send-mention")
+            extra_mentions = options.get("mentions")
+            if isinstance(extra_mentions, list) and len(extra_mentions) > 0:
+                raise ValueError("Do not combine --send-mention with additional --mention flags")
+            request_mentions = [mention_target_id.strip()]
+        if isinstance(request_mentions, list) and len(request_mentions) > 0:
+            body = ensure_visible_mentions(body, request_mentions)
+        headers["Content-Type"] = "application/json; charset=utf-8"
+        request_body = {
+            "body": body,
+            "turnExecutionId": turn_execution_id,
+        }
+        reply_to_id = options.get("reply_to_id")
+        if isinstance(reply_to_id, str) and reply_to_id:
+            request_body["replyToId"] = reply_to_id
+        data = json.dumps(request_body).encode("utf-8")
+    elif request_body is not None:
+        headers["Content-Type"] = "application/json; charset=utf-8"
+        data = json.dumps(request_body).encode("utf-8")
+
+    request = Request(url, headers=headers, method=method, data=data)
+    try:
+        with urlopen(request) as response:
+            response_body = response.read().decode("utf-8")
+            return json.loads(response_body) if response_body else None
+    except HTTPError as exc:
+        if uses_current_thread_fallback and exc.code == 404:
+            raise RuntimeError(TASK_THREAD_MISSING_TASK_ID_ERROR) from exc
+        raise RuntimeError(f"Gateway request failed: {exc}") from exc
+    except Exception as exc:
+        raise RuntimeError(f"Gateway request failed: {exc}") from exc
+
+
+def redact_bootstrap(payload: dict[str, object], context_path: Path) -> dict[str, object]:
+    localhost_gateway = payload.get("localhostGateway")
+    base_url = None
+    collaboration = None
+    if isinstance(localhost_gateway, dict):
+        raw_base_url = localhost_gateway.get("baseUrl")
+        if isinstance(raw_base_url, str):
+            base_url = raw_base_url
+        raw_collaboration = localhost_gateway.get("collaboration")
+        if isinstance(raw_collaboration, dict):
+            collaboration = raw_collaboration
+    return {
+        "kind": "borgee-agent-skill-bootstrap",
+        "contextPath": str(context_path),
+        "channelId": payload.get("channelId"),
+        "skillRuntime": payload.get("skillRuntime"),
+        "taskAssignmentContext": payload.get("taskAssignmentContext"),
+        "localhostGateway": (
+            {
+                "baseUrl": base_url,
+                **({"collaboration": collaboration} if collaboration is not None else {}),
+            }
+            if base_url
+            else None
+        ),
+    }
+
+
+parsed = parse_args(sys.argv[1:])
+context_path = parsed["context_path"]
+payload = json.loads(context_path.read_text(encoding="utf-8"))
+
+if parsed["action"] == "print-bootstrap":
+    print(json.dumps(redact_bootstrap(payload, context_path), indent=2))
+else:
+    print(
+        json.dumps(
+            call_gateway(
+                payload,
+                str(parsed["action"]),
+                {
+                    "context_path": context_path,
+                    "auth_path": parsed["auth_path"],
+                    "turn_execution_id": parsed["turn_execution_id"],
+                    "limit": parsed["limit"],
+                    "before": parsed["before"],
+                    "after": parsed["after"],
+                    "body": parsed["body"],
+                    "reply_to_id": parsed["reply_to_id"],
+                    "mention_target_id": parsed["mention_target_id"],
+                    "mentions": parsed["mentions"],
+                    "title": parsed["title"],
+                    "description": parsed["description"],
+                    "assignee_id": parsed["assignee_id"],
+                    "task_id": parsed["task_id"],
+                    "status": parsed["status"],
+                },
+            ),
+            indent=2,
+        )
+    )