android-agent-harness 0.27.6__py3-none-any.whl

agents/mcp/zoho_sprints/README.md

@@ -0,0 +1,26 @@
+# Zoho Sprints MCP
+
+Stdio MCP server. Same tools and mutate rules as the original engine (`update zoho`, Arabic templates, `In progress` / `Ready To ReTest`). Playbook: `../../workflows/zoho-sprints.md`.
+
+The kit ships **code + empty workflow defaults**, not tokens.
+
+Credentials stay on the developer's machine:
+
+1. Copy `config.example.json` to `~/.android-harness/zoho_sprints.json`
+2. Fill `client_id`, `client_secret`, `refresh_token`, `team_id`, `project_id`
+3. Never put that file in the app repo or in this kit
+
+To get Zoho API credentials:
+
+1. Go to https://api-console.zoho.com/ and create a **Self Client**
+2. Generate a grant token with scope: `ZohoSprints.sprints.ALL,ZohoSprints.items.ALL,ZohoSprints.team.READ`
+3. Exchange the grant token for a refresh token using the Zoho OAuth endpoint
+4. Find your `team_id` and `project_id` from your Zoho Sprints URL: `https://sprints.zoho.com/team/<team_id>/project/<project_id>/...`
+
+`workflow_defaults.json` has assignee / item-prefix / title-strip settings. Empty values are resolved at runtime by the server. Fill them during install (I.16) or configure later.
+
+Setup (`I.16`) wires `.agents/mcp_config.json` (and Cursor `.cursor/mcp.json` when Cursor was selected) to this `server.py` and sets `ZOHO_SPRINTS_CONFIG` to an **existing** user file if one is already on the PC. It does not copy tokens.
+
+If a config already exists at `~/.gemini/antigravity/scratch/zoho_sprints/zoho_config.json`, setup points at that path and leaves the file untouched.
+
+Zoho Desk is not included.

agents/mcp/zoho_sprints/_client.py

@@ -0,0 +1,304 @@
+"""Zoho Sprints API client, OAuth authentication, caching and endpoints."""
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+from _formatter import format_zoho_html
+
+HERE = Path(__file__).resolve().parent
+
+WORKFLOW_KEYS = (
+    "team_id",
+    "project_id",
+    "default_user_id",
+    "item_prefix",
+    "title_strip_suffixes",
+    "fallback_item_type_id",
+    "fallback_priority_id",
+    "fallback_sprint_id",
+)
+
+
+def _workflow_defaults() -> dict:
+    path = HERE / "workflow_defaults.json"
+    if not path.is_file():
+        return {}
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return data if isinstance(data, dict) else {}
+
+
+class ZohoSprintsAPI:
+    METADATA_CACHE_TTL = 300
+
+    def __init__(self, config_path: str):
+        self.config_path = config_path
+        self._meta_cache: dict[str, tuple[float, dict]] = {}
+        self.base_url = "https://sprintsapi.zoho.com/zsapi"
+        self.load_config()
+
+    def load_config(self) -> None:
+        with open(self.config_path, encoding="utf-8") as f:
+            user = json.load(f)
+        if not isinstance(user, dict):
+            raise RuntimeError("Zoho Sprints config must be a JSON object.")
+        defaults = _workflow_defaults()
+        self.config = dict(user)
+        for key in WORKFLOW_KEYS:
+            if key not in user or user.get(key) in (None, "", []):
+                if key in defaults:
+                    self.config[key] = defaults[key]
+        self.access_token = user.get("access_token")
+        self.refresh_token = user.get("refresh_token")
+        self.client_id = user.get("client_id")
+        self.client_secret = user.get("client_secret")
+        self.auth_domain = user.get("auth_domain") or "https://accounts.zoho.com"
+        self.team_id = str(self.config.get("team_id") or "").strip()
+        self.project_id = str(self.config.get("project_id") or "").strip()
+        self.default_user_id = str(self.config.get("default_user_id") or "").strip()
+        self.item_prefix = str(self.config.get("item_prefix") or "").strip()
+        self.fallback_item_type_id = str(self.config.get("fallback_item_type_id") or "").strip()
+        self.fallback_priority_id = str(self.config.get("fallback_priority_id") or "").strip()
+        self.fallback_sprint_id = str(self.config.get("fallback_sprint_id") or "").strip()
+        suffixes = self.config.get("title_strip_suffixes") or []
+        self.title_strip_suffixes = [str(s) for s in suffixes if str(s).strip()]
+        if not self.team_id or not self.project_id:
+            raise RuntimeError("Zoho Sprints config needs team_id and project_id.")
+
+    def save_config(self) -> None:
+        path = Path(self.config_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            if hasattr(os, "O_CREAT") and os.name != "nt":
+                fd = os.open(str(path), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+                with open(fd, "w", encoding="utf-8") as f:
+                    json.dump(self.config, f, indent=2)
+            else:
+                with open(self.config_path, "w", encoding="utf-8") as f:
+                    json.dump(self.config, f, indent=2)
+        except Exception:
+            with open(self.config_path, "w", encoding="utf-8") as f:
+                json.dump(self.config, f, indent=2)
+
+    def sanitize_task_name(self, name: str) -> str:
+        cleaned = name.strip()
+        for suffix in self.title_strip_suffixes:
+            cleaned = re.sub(
+                r"\s*[-–—]\s*" + re.escape(suffix) + r"\s*$",
+                "",
+                cleaned,
+                flags=re.IGNORECASE,
+            ).strip()
+        return cleaned
+
+    def refresh_token_if_needed(self) -> None:
+        url = f"{self.auth_domain}/oauth/v2/token"
+        params = {
+            "refresh_token": self.refresh_token,
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "grant_type": "refresh_token",
+        }
+        encoded = urllib.parse.urlencode(params).encode("utf-8")
+        req = urllib.request.Request(url, data=encoded, method="POST")
+        try:
+            with urllib.request.urlopen(req, timeout=30.0) as resp:
+                res = json.loads(resp.read().decode("utf-8"))
+        except Exception as e:
+            raise RuntimeError(f"Zoho OAuth token refresh network error: {e}") from e
+        if "access_token" in res:
+            self.access_token = res["access_token"]
+            self.config["access_token"] = self.access_token
+            self.save_config()
+        else:
+            err = res.get("error", "unknown_oauth_error")
+            raise RuntimeError(f"Zoho OAuth token refresh failed: {err}. Re-authenticate in config.")
+
+    def _request(self, path: str, method: str = "GET", params: dict | None = None, data: dict | None = None) -> Any:
+        url = f"{self.base_url}{path}"
+        if params:
+            url += "?" + urllib.parse.urlencode(params)
+        headers = {"Authorization": f"Zoho-oauthtoken {self.access_token}"}
+        encoded_data = None
+        if data is not None:
+            encoded_data = urllib.parse.urlencode(data).encode("utf-8")
+            headers["Content-Type"] = "application/x-www-form-urlencoded"
+
+        max_retries = 3
+        for attempt in range(max_retries):
+            req = urllib.request.Request(url, data=encoded_data, headers=headers, method=method)
+            try:
+                with urllib.request.urlopen(req, timeout=30.0) as resp:
+                    return json.loads(resp.read().decode("utf-8"))
+            except urllib.error.HTTPError as exc:
+                err_msg = exc.read().decode("utf-8", errors="replace")
+                if exc.code in (429, 502, 503, 504) and attempt < max_retries - 1:
+                    time.sleep(1.0 * (attempt + 1))
+                    continue
+                if exc.code == 401 or "Invalid oauthToken" in err_msg or "invalid_token" in err_msg:
+                    self.refresh_token_if_needed()
+                    headers["Authorization"] = f"Zoho-oauthtoken {self.access_token}"
+                    req2 = urllib.request.Request(url, data=encoded_data, headers=headers, method=method)
+                    try:
+                        with urllib.request.urlopen(req2, timeout=30.0) as resp2:
+                            return json.loads(resp2.read().decode("utf-8"))
+                    except Exception as retry_exc:
+                        raise RuntimeError(f"Zoho request failed after token refresh: {retry_exc}") from retry_exc
+                raise RuntimeError(f"HTTP Error {exc.code}: {err_msg}") from exc
+            except Exception as exc:
+                if attempt < max_retries - 1 and isinstance(exc, (urllib.error.URLError, TimeoutError)):
+                    time.sleep(1.0 * (attempt + 1))
+                    continue
+                raise RuntimeError(f"Zoho request failed ({method} {path}): {exc}") from exc
+
+    def get_sprints(self) -> dict:
+        return self._request(
+            f"/team/{self.team_id}/projects/{self.project_id}/sprints/",
+            params={"action": "data", "type": "[1,2,3,4]"},
+        )
+
+    def get_active_sprint_id(self) -> str:
+        ids = self.get_sprints().get("sprintIds") or []
+        if ids:
+            return ids[0]
+        if self.fallback_sprint_id:
+            return self.fallback_sprint_id
+        raise RuntimeError("No sprints found for this Zoho project.")
+
+    def _cached_request(self, cache_key: str, path: str, params: dict | None = None) -> dict:
+        cached = self._meta_cache.get(cache_key)
+        if cached:
+            ts, data = cached
+            if time.time() - ts < self.METADATA_CACHE_TTL:
+                return data
+        result = self._request(path, params=params)
+        self._meta_cache[cache_key] = (time.time(), result)
+        return result
+
+    def get_item_types(self) -> dict:
+        return self._cached_request(
+            "item_types",
+            f"/team/{self.team_id}/projects/{self.project_id}/itemtype/",
+            params={"action": "data"},
+        )
+
+    def get_statuses(self) -> dict:
+        return self._cached_request(
+            "statuses",
+            f"/team/{self.team_id}/projects/{self.project_id}/itemstatus/",
+            params={"action": "data"},
+        )
+
+    def get_priorities(self) -> dict:
+        return self._cached_request(
+            "priorities",
+            f"/team/{self.team_id}/projects/{self.project_id}/priority/",
+            params={"action": "data"},
+        )
+
+    def list_items(self, sprint_id: str) -> dict:
+        return self._request(
+            f"/team/{self.team_id}/projects/{self.project_id}/sprints/{sprint_id}/item/",
+            params={"action": "sprintitems", "subitem": "true"},
+        )
+
+    def resolve_item(self, item_input: str, sprint_id: str | None = None) -> tuple[str, str]:
+        raw_input = str(item_input).strip()
+        match = re.search(r"(\d+)", raw_input)
+        target_num = match.group(1) if match else raw_input
+        sprint_ids = self.get_sprints().get("sprintIds") or []
+        if len(raw_input) >= 15 and raw_input.isdigit():
+            if sprint_id:
+                return sprint_id, raw_input
+            for sid in sprint_ids:
+                try:
+                    res = self.get_item_details(sid, raw_input)
+                    if res.get("status") == "success":
+                        return sid, raw_input
+                except Exception:
+                    continue
+        search_sprints = [sprint_id] if sprint_id else sprint_ids
+        prefix = self.item_prefix
+        for sid in search_sprints:
+            items_data = self.list_items(sid)
+            item_prop = items_data.get("item_prop") or {}
+            item_no_idx = item_prop.get("itemNo")
+            item_jobj = items_data.get("itemJObj") or {}
+            for iid, row in item_jobj.items():
+                if iid == raw_input:
+                    return sid, iid
+                if item_no_idx is not None and len(row) > item_no_idx:
+                    item_no = str(row[item_no_idx])
+                    labels = {item_no, f"I{item_no}", target_num}
+                    if prefix:
+                        labels.add(f"{prefix}{item_no}")
+                    if raw_input in labels or item_no == target_num:
+                        return sid, iid
+        raise RuntimeError(
+            f"Item '{raw_input}' not found in {len(search_sprints)} sprint(s). "
+            "Verify the task id or pass sprint_id."
+        )
+
+    def get_item_details(self, sprint_id: str | None = None, item_id: str | None = None) -> dict:
+        if not sprint_id or (item_id and (not str(item_id).isdigit() or len(str(item_id)) < 15)):
+            sprint_id, item_id = self.resolve_item(item_id or sprint_id or "", sprint_id)
+        return self._request(
+            f"/team/{self.team_id}/projects/{self.project_id}/sprints/{sprint_id}/item/{item_id}/",
+            params={"action": "details"},
+        )
+
+    def create_item(
+        self,
+        sprint_id: str,
+        name: str,
+        item_type_id: str,
+        priority_id: str,
+        description: str = "",
+        points: str = "0",
+        parent_item_id: str | None = None,
+        users: list | None = None,
+    ) -> dict:
+        data: dict[str, str] = {
+            "name": self.sanitize_task_name(name),
+            "projitemtypeid": item_type_id,
+            "projpriorityid": priority_id,
+            "description": format_zoho_html(description),
+        }
+        assigned = users if users is not None else ([self.default_user_id] if self.default_user_id else None)
+        if assigned:
+            data["users"] = json.dumps(assigned)
+        if points and points != "0":
+            data["points"] = points
+        if parent_item_id:
+            path = f"/team/{self.team_id}/projects/{self.project_id}/sprints/{sprint_id}/item/{parent_item_id}/subitem/"
+        else:
+            path = f"/team/{self.team_id}/projects/{self.project_id}/sprints/{sprint_id}/item/"
+        return self._request(path, method="POST", data=data)
+
+    def update_item_status(self, sprint_id: str, item_id: str, status_id: str) -> dict:
+        return self._request(
+            f"/team/{self.team_id}/projects/{self.project_id}/sprints/{sprint_id}/item/{item_id}/",
+            method="POST",
+            data={"statusid": status_id},
+        )
+
+    def update_item_description(self, sprint_id: str, item_id: str, description: str) -> dict:
+        return self._request(
+            f"/team/{self.team_id}/projects/{self.project_id}/sprints/{sprint_id}/item/{item_id}/",
+            method="POST",
+            data={"description": format_zoho_html(description)},
+        )
+
+    def add_comment(self, sprint_id: str, item_id: str, content: str) -> dict:
+        return self._request(
+            f"/team/{self.team_id}/projects/{self.project_id}/sprints/{sprint_id}/item/{item_id}/notes/",
+            method="POST",
+            data={"name": format_zoho_html(content)},
+        )

agents/mcp/zoho_sprints/_config.py

@@ -0,0 +1,105 @@
+"""Locate the user-level Zoho Sprints config. Never copy or print secrets."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+SECRET_KEYS = frozenset(
+    {
+        "access_token",
+        "refresh_token",
+        "client_secret",
+        "client_id",
+        "api_key",
+        "token",
+        "password",
+    }
+)
+
+ENV_CONFIG = "ZOHO_SPRINTS_CONFIG"
+SERVER_NAME = "zoho-sprints"
+
+
+def home_config_path() -> Path:
+    return Path.home() / ".android-harness" / "zoho_sprints.json"
+
+
+def example_config_path() -> Path:
+    return Path.home() / ".android-harness" / "zoho_sprints.example.json"
+
+
+def scratch_config_path() -> Path:
+    return (
+        Path.home()
+        / ".gemini"
+        / "antigravity"
+        / "scratch"
+        / "zoho_sprints"
+        / "zoho_config.json"
+    )
+
+
+def candidate_config_paths() -> list[Path]:
+    paths: list[Path] = []
+    env = (os.environ.get(ENV_CONFIG) or "").strip()
+    if env:
+        paths.append(Path(env).expanduser())
+    paths.append(home_config_path())
+    paths.append(scratch_config_path())
+    seen: set[Path] = set()
+    out: list[Path] = []
+    for path in paths:
+        try:
+            resolved = path.resolve()
+        except OSError:
+            continue
+        if resolved in seen:
+            continue
+        seen.add(resolved)
+        out.append(path)
+    return out
+
+
+def resolve_config_path() -> Path | None:
+    for path in candidate_config_paths():
+        if path.is_file() and path.stat().st_size > 0:
+            return path
+    return None
+
+
+def kit_server_path(agents_root: Path) -> Path:
+    return agents_root / "mcp" / "zoho_sprints" / "server.py"
+
+
+def json_contains_secret_keys(value: object) -> bool:
+    if isinstance(value, dict):
+        for key, child in value.items():
+            if str(key).lower() in SECRET_KEYS:
+                return True
+            if json_contains_secret_keys(child):
+                return True
+        return False
+    if isinstance(value, list):
+        return any(json_contains_secret_keys(item) for item in value)
+    return False
+
+
+def text_contains_secret_values(text: str, secret_file: Path) -> bool:
+    """True if any nonempty string value from secret_file appears in text."""
+    import json
+
+    try:
+        data = json.loads(secret_file.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return False
+    if not isinstance(data, dict):
+        return False
+    for key, raw in data.items():
+        if str(key).lower() not in SECRET_KEYS:
+            continue
+        if not isinstance(raw, str):
+            continue
+        token = raw.strip()
+        if len(token) >= 8 and token in text:
+            return True
+    return False

agents/mcp/zoho_sprints/_dns.py

@@ -0,0 +1,92 @@
+"""DNS fallback queries using direct UDP packets to public resolvers."""
+from __future__ import annotations
+
+import secrets
+import socket
+import struct
+from typing import Optional
+
+
+def _dns_query_fallback(
+    hostname: str,
+    dns_servers: tuple[str, ...] = ("8.8.8.8", "1.1.1.1"),
+) -> Optional[str]:
+    tx_id = secrets.randbelow(65535) + 1
+    packet = struct.pack(">HHHHHH", tx_id, 0x0100, 1, 0, 0, 0)
+    for part in hostname.split("."):
+        packet += struct.pack("B", len(part)) + part.encode("ascii")
+    packet += b"\x00\x00\x01\x00\x01"
+    for dns_ip in dns_servers:
+        sock = None
+        data = b""
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            sock.settimeout(2.0)
+            sock.sendto(packet, (dns_ip, 53))
+            data, _ = sock.recvfrom(1024)
+        except Exception:
+            continue
+        finally:
+            if sock:
+                try:
+                    sock.close()
+                except Exception:
+                    pass
+        if len(data) < 12:
+            continue
+
+        resp_tx_id = struct.unpack(">H", data[0:2])[0]
+        if resp_tx_id != tx_id:
+            continue
+        idx = 12
+        while idx < len(data) and data[idx] != 0:
+            if (data[idx] & 0xC0) == 0xC0:
+                idx += 2
+                break
+            idx += 1 + data[idx]
+        else:
+            idx += 5
+        if idx > len(data):
+            continue
+        ancount = struct.unpack(">H", data[6:8])[0]
+        for _ in range(ancount):
+            if idx >= len(data):
+                break
+            if (data[idx] & 0xC0) == 0xC0:
+                idx += 2
+            else:
+                while idx < len(data) and data[idx] != 0:
+                    idx += 1 + data[idx]
+                idx += 1
+            if idx + 10 > len(data):
+                break
+            rtype, _rclass, _ttl, rdlength = struct.unpack(">HHIH", data[idx : idx + 10])
+            idx += 10
+            if rtype == 1 and rdlength == 4 and idx + 4 <= len(data):
+                return socket.inet_ntoa(data[idx : idx + 4])
+            idx += rdlength
+    return None
+
+
+def apply_dns_fallback() -> None:
+    orig = socket.getaddrinfo
+    cache: dict[str, str] = {}
+
+    def custom(host, port, family=0, type=0, proto=0, flags=0):
+        if isinstance(host, str) and "zoho" in host.lower():
+            if host not in cache:
+                resolved = _dns_query_fallback(host)
+                if resolved:
+                    cache[host] = resolved
+            if host in cache:
+                return orig(cache[host], port, family, type, proto, flags)
+        try:
+            return orig(host, port, family, type, proto, flags)
+        except Exception:
+            resolved = _dns_query_fallback(host) if isinstance(host, str) else None
+            if resolved:
+                cache[host] = resolved
+                return orig(resolved, port, family, type, proto, flags)
+            raise
+
+    socket.getaddrinfo = custom  # type: ignore[method-assign]

agents/mcp/zoho_sprints/_formatter.py

@@ -0,0 +1,132 @@
+"""HTML and text formatters for Zoho Sprints rich-text descriptions."""
+from __future__ import annotations
+
+import re
+
+_EMOJI_RE = re.compile(
+    "["
+    "\U0001F600-\U0001F64F"
+    "\U0001F300-\U0001F5FF"
+    "\U0001F680-\U0001F6FF"
+    "\U0001F1E0-\U0001F1FF"
+    "\U00002702-\U000027B0"
+    "\U0000FE00-\U0000FE0F"
+    "\U0001F900-\U0001F9FF"
+    "\U0001FA00-\U0001FA6F"
+    "\U0001FA70-\U0001FAFF"
+    "\U00002600-\U000026FF"
+    "\U0000200D"
+    "\U00002B50\U00002B05-\U00002B07\U00002934-\U00002935"
+    "\U000023CF\U000023E9-\U000023F3\U000023F8-\U000023FA"
+    "]+",
+    flags=re.UNICODE,
+)
+
+
+def _strip_emoji(text: str) -> str:
+    return _EMOJI_RE.sub("", text).strip()
+
+
+def format_zoho_html(text: str) -> str:
+    if not text:
+        return text
+    text = _strip_emoji(text)
+    if not text:
+        return text
+    if text.strip().startswith("<div dir="):
+        return text
+    has_arabic = bool(re.search(r"[\u0600-\u06FF]", text))
+    code_blocks: list[str] = []
+
+    def _save_code_block(match: re.Match[str]) -> str:
+        code_blocks.append(match.group(1))
+        return f"___CODE_BLOCK_{len(code_blocks) - 1}___"
+
+    text = re.sub(r"```(?:\w+)?\n?(.*?)```", _save_code_block, text, flags=re.DOTALL)
+    html_parts: list[str] = []
+    in_list = False
+    list_type = "ul"
+
+    def _format_inline(s: str) -> str:
+        s = re.sub(
+            r"`([^`]+)`",
+            r'<code style="color: #ffffff; font-family: Consolas, Monaco, monospace; font-size: 0.95em; direction: ltr; display: inline-block; font-weight: bold;">\1</code>',
+            s,
+        )
+        return re.sub(r"\*\*(.+?)\*\*", r'<strong style="color: #ffffff; font-weight: 700;">\1</strong>', s)
+
+    for line in text.strip().splitlines():
+        stripped = line.strip()
+        if not stripped:
+            if in_list:
+                html_parts.append(f"</{list_type}>")
+                in_list = False
+            continue
+        cb_match = re.match(r"^___CODE_BLOCK_(\d+)___$", stripped)
+        if cb_match:
+            if in_list:
+                html_parts.append(f"</{list_type}>")
+                in_list = False
+            code_content = code_blocks[int(cb_match.group(1))].strip()
+            code_content = code_content.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            html_parts.append(
+                f'<pre style="color: #ffffff; font-family: Consolas, Monaco, monospace; font-size: 13px; direction: ltr; text-align: left; margin: 8px 0; overflow-x: auto;"><code>{code_content}</code></pre>'
+            )
+            continue
+        if stripped in ("---", "***", "___"):
+            if in_list:
+                html_parts.append(f"</{list_type}>")
+                in_list = False
+            html_parts.append('<hr style="border: 0; border-top: 1px solid rgba(255, 255, 255, 0.2); margin: 14px 0;">')
+            continue
+        heading = None
+        if stripped.startswith("# "):
+            heading = (stripped[2:], "1.25em", "12px 0 10px 0")
+        elif stripped.startswith("## "):
+            heading = (stripped[3:], "1.1em", "12px 0 6px 0")
+        elif stripped.startswith("### "):
+            heading = (stripped[4:], "1.05em", "10px 0 4px 0")
+        if heading:
+            if in_list:
+                html_parts.append(f"</{list_type}>")
+                in_list = False
+            title, size, margin = heading
+            html_parts.append(
+                f'<div style="font-size: {size}; font-weight: 700; color: #ffffff; margin: {margin};">{_format_inline(title)}</div>'
+            )
+            continue
+        if re.match(r"^\d+\.\s+", stripped):
+            if not in_list or list_type != "ol":
+                if in_list:
+                    html_parts.append(f"</{list_type}>")
+                html_parts.append("<ol style='margin-right: 22px; padding-right: 0; margin-bottom: 10px; color: #ffffff;'>")
+                in_list = True
+                list_type = "ol"
+            item_text = _format_inline(re.sub(r"^\d+\.\s+", "", stripped))
+            html_parts.append(f"<li style='margin-bottom: 6px; color: #ffffff; font-size: 14px;'>{item_text}</li>")
+            continue
+        if stripped.startswith("- ") or stripped.startswith("* "):
+            if not in_list or list_type != "ul":
+                if in_list:
+                    html_parts.append(f"</{list_type}>")
+                html_parts.append("<ul style='margin-right: 22px; padding-right: 0; margin-bottom: 10px; color: #ffffff;'>")
+                in_list = True
+                list_type = "ul"
+            html_parts.append(
+                f"<li style='margin-bottom: 6px; color: #ffffff; font-size: 14px;'>{_format_inline(stripped[2:])}</li>"
+            )
+            continue
+        if in_list:
+            html_parts.append(f"</{list_type}>")
+            in_list = False
+        html_parts.append(f"<p style='margin: 6px 0; color: #ffffff; font-size: 14px;'>{_format_inline(stripped)}</p>")
+    if in_list:
+        html_parts.append(f"</{list_type}>")
+    inner = "\n".join(html_parts)
+    if has_arabic:
+        return (
+            '<div dir="rtl" style="text-align: right; direction: rtl; line-height: 1.85; '
+            "font-family: -apple-system, BlinkMacSystemFont, Segoe UI, Tahoma, Arial, sans-serif; "
+            f'color: #ffffff; font-size: 14px;">\n{inner}\n</div>'
+        )
+    return inner