@borgee/agents-host 0.2.33 → 0.2.44

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

@@ -1,438 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import annotations
-
-import json
-import re
-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."
-)
-# Python ints are arbitrary precision, so nothing can be rounded on the way into the query
-# string; the bound is here only so both packaged CLIs accept and reject exactly the same
-# inputs. It is the Node CLI that needs it: there an out-of-range magnitude re-stringifies as
-# `1e+21`, which the gateway's `Number.parseInt(value, 10)` reads back as `1`.
-INTEGER_ARGUMENT_PATTERN = re.compile(r"[+-]?[0-9]+")
-MAX_SAFE_INTEGER = 2**53 - 1
-
-
-def parse_int(flag: str, value: str | None) -> int:
-    if value is None:
-        raise ValueError(f"Missing value after {flag}")
-    if not INTEGER_ARGUMENT_PATTERN.fullmatch(value):
-        raise ValueError(f"Invalid integer for {flag}: {value}")
-    parsed = int(value)
-    if abs(parsed) > MAX_SAFE_INTEGER:
-        raise ValueError(f"Integer out of range for {flag}: {value}")
-    return parsed
-
-
-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-task-history":
-            set_action("read-task-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(options: dict[str, object]) -> str | None:
-    task_id = options.get("task_id")
-    trimmed = task_id.strip() if isinstance(task_id, str) else ""
-    return trimmed if trimmed else None
-
-
-def missing_task_id_error(action: str) -> ValueError:
-    return ValueError(f"Missing required --task-id <value> for --{action}")
-
-
-def require_explicit_task_id(action: str, options: dict[str, object]) -> str:
-    task_id = explicit_task_id(options)
-    if task_id is None:
-        raise missing_task_id_error(action)
-    return task_id
-
-
-def history_query_suffix(options: dict[str, object]) -> str:
-    query: dict[str, str] = {}
-    for key in ("limit", "before", "after"):
-        if options.get(key) is not None:
-            query[key] = str(options[key])
-    return f"?{urlencode(query)}" if query else ""
-
-
-def resolve_task_id(payload: dict[str, object], action: str, options: dict[str, object]) -> str | None:
-    task_id = explicit_task_id(options)
-    if task_id is not None:
-        return task_id
-    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 missing_task_id_error(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":
-        return f"{base_url}/v1/channels/{channel_id}/history{history_query_suffix(options)}", "GET", None, False
-    if action == "read-task-history":
-        task_id = quote(require_explicit_task_id(action, options), safe="")
-        return f"{base_url}/v1/tasks/{task_id}/history{history_query_suffix(options)}", "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 explicit_task_id(options) is None:
-            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 options.get("description") is not None:
-            request_body["description"] = options["description"]
-        if not request_body:
-            raise ValueError("At least one of --status, --assignee-id, --title, or --description is required for --update-task")
-        if isinstance(task_assignment_context, dict) and task_assignment_context.get("active") is True and explicit_task_id(options) is None:
-            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:
-    url, method, request_body, uses_current_thread_fallback = resolve_gateway_request(payload, action, options)
-    auth = read_gateway_auth(
-        options.get("auth_path") if isinstance(options.get("auth_path"), Path) else None,
-        payload.get("channelId"),
-    )
-
-    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:
-        error_body = exc.read().decode("utf-8")
-        error_payload = json.loads(error_body) if error_body else None
-        if uses_current_thread_fallback and isinstance(error_payload, dict) and error_payload.get("error") == "not_found":
-            raise RuntimeError(TASK_THREAD_MISSING_TASK_ID_ERROR) from exc
-        reported_body = json.dumps(error_payload, separators=(",", ":"), ensure_ascii=False)
-        raise RuntimeError(f"Gateway request failed with {exc.code}: {reported_body}") 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,
-        )
-    )