@acedatacloud/skills 2026.714.1 → 2026.714.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acedatacloud/skills",
-  "version": "2026.714.1",
+  "version": "2026.714.3",
   "description": "Agent Skills for AceDataCloud AI services — music, image, video generation, LLM chat, web search. Compatible with Claude Code, GitHub Copilot, Gemini CLI, OpenAI Codex, and 30+ AI coding agents.",
   "keywords": [
     "agent-skills",

package/skills/telegram/SKILL.md

@@ -1,19 +1,20 @@
 ---
 name: telegram
-description: Full personal Telegram control over MTProto (Telethon) with the user's own account — list/search chats, read & summarize history, see unread, look up contacts & chat info, download media, and send / reply / forward / edit / delete / react / send files / mark read. Use when the user mentions Telegram, a Telegram chat/group/contact, "我的 Telegram", reading/replying/forwarding/summarizing Telegram messages, their unread Telegram, or sending a file/message on Telegram.
+description: Full personal Telegram control over MTProto (Telethon) with the user's own account — list/search chats, read & summarize history, see unread, look up contacts & chat info, download media, and send / reply / forward / edit / delete / react / send files / mark read / join & leave groups. Use when the user mentions Telegram, a Telegram chat/group/contact, "我的 Telegram", reading/replying/forwarding/summarizing Telegram messages, their unread Telegram, joining or leaving a Telegram group/channel, or sending a file/message on Telegram.
 when_to_use: |
   Trigger for anything on the user's personal Telegram account: list recent
   conversations or just the unread ones, read / summarize a chat or group,
   search one chat or across all chats, look up a contact or a chat's info,
   download a photo/file from a message, or take an action — send, reply,
-  forward, edit, delete, react, send a file, or mark a chat read. This drives
-  the user's OWN account over MTProto (not a bot), so it sees everything they see.
+  forward, edit, delete, react, send a file, mark a chat read, or join / leave
+  a group or channel. This drives the user's OWN account over MTProto (not a
+  bot), so it sees everything they see.
 connections: [telegram]
 allowed_tools: [Bash]
 license: Apache-2.0
 metadata:
   author: acedatacloud
-  version: "1.2"
+  version: "1.3"
 ---
 
 We drive **personal** Telegram over MTProto with [Telethon](https://docs.telethon.dev/) —
@@ -42,7 +43,7 @@ python3 "$TG" whoami
 ```
 
 Every state-changing command (`send`, `reply`, `send-file`, `forward`, `edit`, `delete`,
-`react`, `mark-read`) is **gated**: without a trailing `--confirm` it only DRY-RUNS (prints what
+`react`, `mark-read`, `join`, `leave`) is **gated**: without a trailing `--confirm` it only DRY-RUNS (prints what
 it would do, changes nothing). Read commands run directly. `--confirm` is honored **only as the
 last argument** so a message/caption that merely contains "--confirm" can never silently confirm.
 
@@ -106,8 +107,16 @@ python3 "$TG" edit    <target> <msg_id> "new text" --confirm   # own messages
 python3 "$TG" delete  <target> <msg_id> --confirm              # destructive
 python3 "$TG" react   <target> <msg_id> "👍" --confirm
 python3 "$TG" mark-read <target> --confirm                     # sends read receipts
+python3 "$TG" join    <@username|t.me/link|t.me/+invite> --confirm  # join a public group/channel or a private invite
+python3 "$TG" leave   <target> --confirm                       # leave a group/channel (not private chats)
 ```
 
+`join` accepts a public `@username` / `t.me/<name>` (→ JoinChannelRequest) or a private
+invite link `t.me/+HASH` / `t.me/joinchat/HASH` (→ ImportChatInviteRequest). Joining someone
+else's group is a real membership change on the account — treat it like any other write:
+dry-run, confirm, then `--confirm`. Never auto-join then bulk-message; that gets accounts
+spam-limited.
+
 The dry run returns `{"dry_run": true, "command": ..., "args": [...]}` — present that to the
 user verbatim as the confirmation prompt.
 

package/skills/telegram/scripts/tg.py

@@ -19,10 +19,10 @@ import tempfile
 import urllib.request
 from urllib.parse import urlparse
 
-from telethon import TelegramClient
+from telethon import TelegramClient, errors, utils
 from telethon.sessions import StringSession
 from telethon.tl import functions
-from telethon.tl.types import ReactionEmoji
+from telethon.tl.types import ReactionEmoji, User
 
 API_ID = int(os.environ["TELEGRAM_API_ID"])
 API_HASH = os.environ["TELEGRAM_API_HASH"]
@@ -35,7 +35,7 @@ CONFIRM = bool(_raw) and _raw[-1] == "--confirm"
 a = _raw[:-1] if CONFIRM else list(_raw)
 cmd = a[0] if a else "help"
 args = a[1:]
-GATED = {"send", "reply", "send-file", "forward", "edit", "delete", "react", "mark-read"}
+GATED = {"send", "reply", "send-file", "forward", "edit", "delete", "react", "mark-read", "join", "leave"}
 
 
 def out(o):
@@ -252,6 +252,33 @@ async def run():
             await cl.send_read_acknowledge(ent)
             out({"marked_read": True})
 
+        elif cmd == "join":
+            need(1); target = args[0]
+            # A public @username / t.me/<user> resolves + JoinChannelRequest; a
+            # private invite (t.me/+HASH, joinchat/HASH, tg://join?invite=HASH)
+            # can't be resolved without joining, so import it by hash directly.
+            link_hash, is_invite = utils.parse_username(target)
+            try:
+                if is_invite:
+                    res = await cl(functions.messages.ImportChatInviteRequest(link_hash))
+                    chat = (getattr(res, "chats", None) or [None])[0]
+                    out({"joined": True, "via": "invite",
+                         "id": getattr(chat, "id", None), "title": getattr(chat, "title", None)})
+                else:
+                    ent = await resolve(cl, target)
+                    await cl(functions.channels.JoinChannelRequest(ent))
+                    out({"joined": True, "via": "public", "id": ent.id,
+                         "title": getattr(ent, "title", None), "username": getattr(ent, "username", None)})
+            except errors.UserAlreadyParticipantError:
+                out({"joined": True, "already_member": True, "target": target})
+
+        elif cmd == "leave":
+            need(1); ent = await resolve(cl, args[0])
+            if isinstance(ent, User):
+                out({"error": "leave applies to groups/channels, not private chats"}); return
+            await cl.delete_dialog(ent)
+            out({"left": True, "id": ent.id})
+
         else:
             out({"error": f"unknown command: {cmd}"}); sys.exit(1)
 

package/skills/tgstat/SKILL.md

@@ -12,7 +12,7 @@ allowed_tools: [Bash, web_search, web_fetch]
 license: Apache-2.0
 metadata:
   author: acedatacloud
-  version: "2.2"
+  version: "2.3"
 ---
 
 # TGStat Research
@@ -105,6 +105,12 @@ mean TGStat did not expose them on the public page; do not call that full
 statistics. Use `rankings` when you need reach / citation index for large
 public sources.
 
+Individual channel/chat pages are more aggressively bot-protected than the
+ranking pages, so an `info`/`stat` lookup may occasionally return a
+`render blocked` / `could not render` error. It fails fast (well under the
+Bash timeout) — retry once, or fall back to `rankings` and `search` for
+discovery, which are far more reliable.
+
 For ad selection, rank by relevant reach/activity rather than subscriber count
 alone. High subscribers with weak reach or chat MAU can indicate an inactive or
 inflated audience. Present metrics as evidence, not a guarantee of lead quality.

package/skills/tgstat/scripts/tgstat.py

@@ -316,24 +316,44 @@ def _render_token() -> str:
 # 422 antibot_blocked, and the render service can transiently 429/5xx.
 _RETRYABLE_RENDER_STATUS = frozenset({422, 425, 429, 500, 502, 503, 504})
 _RENDER_ATTEMPTS = 3
+# Total wall-time budget for one lookup. The agent sandbox kills a Bash command
+# at ~60s, so keep every render (incl. anti-bot retries) safely under that: a
+# stubborn page fails fast instead of being killed mid-retry.
+_RENDER_BUDGET_SECONDS = 46
+# Shared deadline across every render in a single command invocation, so a
+# multi-render command (info tries channel + chat + a ranking fallback) can
+# never exceed the sandbox cap by stacking per-render budgets.
+_OPERATION_DEADLINE: Optional[float] = None
+
+
+def _op_deadline() -> float:
+    global _OPERATION_DEADLINE
+    if _OPERATION_DEADLINE is None:
+        _OPERATION_DEADLINE = time.monotonic() + _RENDER_BUDGET_SECONDS + 2
+    return _OPERATION_DEADLINE
 
 
 def _request_with_url(url: str, timeout: int) -> Tuple[str, str]:
     # Public tgstat.com is behind Cloudflare; render it through the platform
     # WebExtrator service (headless Chromium) rather than fetching directly.
-    # Anti-bot blocks are intermittent, so retry with a longer settle and a
-    # cache bypass before giving up.
+    # Anti-bot blocks are intermittent, so retry with a cache bypass — but stay
+    # inside a wall-time budget so the caller never times out mid-retry.
     _validate_request_url(url)
-    render_timeout = max(20, min(timeout, 45))
+    render_timeout = max(15, min(timeout, 30))
     token = _render_token()
-    last_reason = ""
+    deadline = min(time.monotonic() + _RENDER_BUDGET_SECONDS, _op_deadline())
+    last_reason = "render timed out"
     for attempt in range(_RENDER_ATTEMPTS):
+        remaining = deadline - time.monotonic()
+        if remaining < 8:
+            break
+        nav_timeout = max(6, int(min(render_timeout, remaining - 5)))
         payload = json.dumps(
             {
                 "url": url,
                 "wait_until": "domcontentloaded",
-                "delay": RENDER_DELAY_SECONDS + 2 * attempt,
-                "timeout": render_timeout,
+                "delay": RENDER_DELAY_SECONDS + attempt,
+                "timeout": nav_timeout,
                 "block_resources": RENDER_BLOCK_RESOURCES,
                 "bypass_cache": attempt > 0,
             }
@@ -348,18 +368,20 @@ def _request_with_url(url: str, timeout: int) -> Tuple[str, str]:
             },
         )
         try:
-            with urllib.request.urlopen(request, timeout=render_timeout + 75) as response:
+            # `remaining` bounds the socket op; the render service returns one
+            # JSON body, so this single read is what the wall budget relies on.
+            with urllib.request.urlopen(request, timeout=remaining) as response:
                 envelope = json.loads(response.read().decode("utf-8", "replace"))
         except urllib.error.HTTPError as exc:
             body = exc.read().decode("utf-8", "replace")
             if exc.code in _RETRYABLE_RENDER_STATUS or "antibot" in body.lower():
                 last_reason = f"render blocked (HTTP {exc.code}): {_safe_error_body(body)}"
-                _render_backoff(attempt)
+                _render_backoff(attempt, deadline)
                 continue
             raise TGStatError(f"render service HTTP {exc.code}: {_safe_error_body(body)}") from exc
         except urllib.error.URLError as exc:
             last_reason = f"render service unreachable: {_safe_error_body(str(exc.reason))}"
-            _render_backoff(attempt)
+            _render_backoff(attempt, deadline)
             continue
         except json.JSONDecodeError as exc:
             raise TGStatError(f"render service returned invalid JSON: {_safe_error_body(str(exc))}") from exc
@@ -375,14 +397,18 @@ def _request_with_url(url: str, timeout: int) -> Tuple[str, str]:
             last_reason = f"empty or interstitial render (upstream status {render.get('status')})"
         else:
             last_reason = "render service returned no page data"
-        _render_backoff(attempt)
+        _render_backoff(attempt, deadline)
     raise TGStatError(f"could not render {_safe_url(url)}: {last_reason}")
 
 
-def _render_backoff(attempt: int) -> None:
-    # Skip the wait after the final attempt; give Cloudflare a moment otherwise.
-    if attempt < _RENDER_ATTEMPTS - 1:
-        time.sleep(min(2 + 2 * attempt, 6))
+def _render_backoff(attempt: int, deadline: float) -> None:
+    # Short settle between attempts, but never sleep past the wall-time budget.
+    if attempt >= _RENDER_ATTEMPTS - 1:
+        return
+    remaining = deadline - time.monotonic()
+    if remaining <= 8:
+        return
+    time.sleep(min(1.5 + attempt, 3.0, remaining - 8))
 
 
 def _request(url: str, timeout: int) -> str:
@@ -588,7 +614,7 @@ def command_stat(args: argparse.Namespace) -> None:
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--host", default=os.environ.get("TGSTAT_PUBLIC_HOST", DEFAULT_PUBLIC_BASE))
-    parser.add_argument("--timeout", type=int, default=45)
+    parser.add_argument("--timeout", type=int, default=30)
     sub = parser.add_subparsers(dest="command", required=True)
 
     sub.add_parser("profile").set_defaults(func=command_profile)
@@ -616,6 +642,8 @@ def build_parser() -> argparse.ArgumentParser:
 
 
 def main() -> None:
+    global _OPERATION_DEADLINE
+    _OPERATION_DEADLINE = None  # fresh render budget per command invocation
     args = build_parser().parse_args()
     try:
         args.func(args)