@borgee/agents-host 0.2.31 → 0.2.32

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import re
 import sys
 from pathlib import Path
 from urllib.error import HTTPError
@@ -17,15 +18,23 @@ 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}")
-    try:
-        return int(value)
-    except ValueError as exc:
-        raise ValueError(f"Invalid integer for {flag}: {value}") from exc
+    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]:
@@ -80,6 +89,8 @@ def parse_args(argv: list[str]) -> dict[str, object]:
             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":
@@ -185,22 +196,42 @@ def ensure_visible_mentions(body: str, participant_ids: list[str]) -> str:
     return next_body
 
 
-def explicit_task_id_provided(options: dict[str, object]) -> bool:
+def explicit_task_id(options: dict[str, object]) -> str | None:
     task_id = options.get("task_id")
-    return isinstance(task_id, str) and bool(task_id.strip())
+    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 = options.get("task_id")
-    if isinstance(task_id, str) and task_id.strip():
-        return task_id.strip()
+    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 ValueError(f"Missing required --task-id <value> for --{action}")
+    raise missing_task_id_error(action)
 
 
 def resolve_gateway_request(
@@ -225,15 +256,10 @@ def resolve_gateway_request(
     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
+        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():
@@ -258,7 +284,7 @@ def resolve_gateway_request(
         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):
+        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":
@@ -274,7 +300,7 @@ def resolve_gateway_request(
             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 not explicit_task_id_provided(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", "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}")
@@ -296,11 +322,11 @@ def read_gateway_auth(auth_path: Path | None, expected_channel_id: object) -> di
 
 
 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"),
     )
-    url, method, request_body, uses_current_thread_fallback = resolve_gateway_request(payload, action, options)
 
     data = None
     headers = {"Authorization": f"Bearer {auth['token']}"}
@@ -341,11 +367,12 @@ def call_gateway(payload: dict[str, object], action: str, options: dict[str, obj
             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:
+        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
-        raise RuntimeError(f"Gateway request failed: {exc}") from exc
-    except Exception as exc:
-        raise RuntimeError(f"Gateway request failed: {exc}") 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]: