@acedatacloud/skills 2026.926.0 → 2026.926.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acedatacloud/skills",
-  "version": "2026.926.0",
+  "version": "2026.926.1",
   "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/personal-wechat/scripts/personal_wechat.py

@@ -286,7 +286,17 @@ def main() -> None:
     args = build_parser().parse_args()
 
     if args.cmd == "status":
-        _json(request("GET", "/api/status"))
+        status = request("GET", "/api/status")
+        logged_in = status.get("logged_in") is True
+        ready = status.get("status") == "ready" or status.get("ready") is True
+        if not logged_in or not ready:
+            status["scheduled_outcome"] = {
+                "version": 1,
+                "status": "skipped",
+                "code": "WECHAT_NOT_LOGGED_IN",
+                "side_effect_performed": False,
+            }
+        _json(status)
     elif args.cmd == "account":
         _json(request("GET", "/api/account"))
     elif args.cmd == "contacts":

package/skills/personal-wechat/tests/test_personal_wechat.py

@@ -198,3 +198,14 @@ def test_unattended_confirm_allows_a_preauthorized_skill(monkeypatch) -> None:
     calls, _ = run(["send", "Alice", "hi", "--unattended-confirm"], task_result={"sent": True})
 
     assert calls[0]["path"] == "/api/messages/send"
+
+
+def test_status_reports_not_logged_in_as_structured_skip() -> None:
+    _, stdout = run(["status"], responses={"/api/status": {"status": "ready", "logged_in": False}})
+
+    assert stdout[0]["scheduled_outcome"] == {
+        "version": 1,
+        "status": "skipped",
+        "code": "WECHAT_NOT_LOGGED_IN",
+        "side_effect_performed": False,
+    }

package/skills/x/scripts/x.py

@@ -300,10 +300,21 @@ async def cmd_whoami(client, args):
     if expected:
         expected_screen_name = normalize_screen_name(expected)
         if authenticated_screen_name.casefold() != expected_screen_name.casefold():
-            die(
-                f"connected X account is @{authenticated_screen_name}, not @{expected_screen_name}; "
-                "stopped without performing any write"
+            out(
+                {
+                    "error": (
+                        f"connected X account is @{authenticated_screen_name}, not @{expected_screen_name}; "
+                        "stopped without performing any write"
+                    ),
+                    "scheduled_outcome": {
+                        "version": 1,
+                        "status": "skipped",
+                        "code": "ACCOUNT_MISMATCH_SAFE_STOP",
+                        "side_effect_performed": False,
+                    },
+                }
             )
+            raise SystemExit(1)
     u, client = await retry_flaky_not_found(
         client,
         lambda c: c.get_user_by_screen_name(authenticated_screen_name),

package/skills/youtube/SKILL.md

@@ -64,20 +64,14 @@ YouTube has no "list my videos" call directly — read the channel's
 **uploads playlist**, then page its items.
 
 ```bash
-# 1. Get the uploads playlist id (UU... ) — same as channels call above.
-UPLOADS=$(curl -sS -H "Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN" \
-  "https://www.googleapis.com/youtube/v3/channels?part=contentDetails&mine=true" \
-  | jq -r '.items[0].contentDetails.relatedPlaylists.uploads')
-
-# 2. List recent uploads (50/page; follow .nextPageToken for more).
-curl -sS -H "Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN" \
-  -G "https://www.googleapis.com/youtube/v3/playlistItems" \
-  --data-urlencode "part=snippet,contentDetails" \
-  --data-urlencode "playlistId=$UPLOADS" \
-  --data-urlencode "maxResults=50" \
-  | jq '.items[] | {videoId: .contentDetails.videoId, title: .snippet.title, published: .snippet.publishedAt}'
+python3 skills/youtube/scripts/list_uploads.py --max-pages 20
 ```
 
+The helper follows every `nextPageToken` until the upload history is complete
+(or the explicit safety limit is reached). Its compact JSON keeps `videoId`,
+`title`, and `published` for each item, plus `complete`, `pages_fetched`, and
+`next_page_token`. Do not claim a video is absent when `complete` is false.
+
 Paginate by passing `--data-urlencode "pageToken=$PAGE_TOKEN"` with the
 `.nextPageToken` from the previous response.
 
@@ -175,7 +169,20 @@ RESULT=$(curl -sS -H "Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN" \
   -X PUT --upload-file "$FILE" "$UPLOAD_URL")
 echo "$RESULT" | jq -e .id >/dev/null 2>&1 \
   || { echo "upload failed: $(echo "$RESULT" | jq -r '.error.message' 2>/dev/null || echo "$RESULT")"; exit 1; }
-echo "$RESULT" | jq '{id: .id, url: ("https://www.youtube.com/watch?v=" + .id), privacy: .status.privacyStatus}'
+VIDEO_ID=$(echo "$RESULT" | jq -r '.id')
+VERIFY=$(curl -sS -H "Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN" \
+  -G "https://www.googleapis.com/youtube/v3/videos" \
+  --data-urlencode "part=snippet,status,processingDetails" \
+  --data-urlencode "id=$VIDEO_ID")
+echo "$VERIFY" | jq -e '.items[0].id == "'"$VIDEO_ID"'"' >/dev/null \
+  || { echo "upload readback failed for $VIDEO_ID"; exit 1; }
+echo "$VERIFY" | jq '.items[0] | {
+  video_id: .id,
+  canonical_url: ("https://www.youtube.com/watch?v=" + .id),
+  privacy: .status.privacyStatus,
+  upload_status: .status.uploadStatus,
+  processing_status: .processingDetails.processingStatus
+}'
 ```
 
 Delete a downloaded temp file only **after** you've confirmed an id came back

package/skills/youtube/scripts/list_uploads.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""List uploaded YouTube videos while preserving pagination evidence."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from typing import Any
+from urllib import error, parse, request
+
+API_ROOT = "https://www.googleapis.com/youtube/v3"
+
+
+def api_get(path: str, token: str, params: dict[str, str]) -> dict[str, Any]:
+    url = f"{API_ROOT}/{path}?{parse.urlencode(params)}"
+    req = request.Request(url, headers={"Authorization": f"Bearer {token}"})
+    try:
+        with request.urlopen(req, timeout=30) as response:
+            return json.load(response)
+    except error.HTTPError as exc:
+        body = exc.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"YouTube API HTTP {exc.code}: {body}") from exc
+
+
+def list_uploads(token: str, *, max_pages: int = 20) -> dict[str, Any]:
+    channel = api_get("channels", token, {"part": "contentDetails", "mine": "true"})
+    items = channel.get("items") or []
+    if not items:
+        raise RuntimeError("YouTube channel not found for the connected account")
+    uploads = items[0]["contentDetails"]["relatedPlaylists"]["uploads"]
+
+    videos: list[dict[str, Any]] = []
+    page_token = ""
+    pages = 0
+    while pages < max_pages:
+        params = {
+            "part": "snippet,contentDetails",
+            "playlistId": uploads,
+            "maxResults": "50",
+        }
+        if page_token:
+            params["pageToken"] = page_token
+        payload = api_get("playlistItems", token, params)
+        pages += 1
+        for item in payload.get("items") or []:
+            videos.append(
+                {
+                    "videoId": item.get("contentDetails", {}).get("videoId"),
+                    "title": item.get("snippet", {}).get("title"),
+                    "published": item.get("snippet", {}).get("publishedAt"),
+                }
+            )
+        page_token = str(payload.get("nextPageToken") or "")
+        if not page_token:
+            break
+
+    return {
+        "uploads_playlist": uploads,
+        "pages_fetched": pages,
+        "complete": not page_token,
+        "next_page_token": page_token or None,
+        "items": videos,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--max-pages", type=int, default=20)
+    args = parser.parse_args()
+    token = os.environ.get("GOOGLE_YOUTUBE_TOKEN", "")
+    if not token:
+        print(json.dumps({"error": "GOOGLE_YOUTUBE_TOKEN is not set"}))
+        return 2
+    try:
+        print(json.dumps(list_uploads(token, max_pages=max(1, min(args.max_pages, 100))), ensure_ascii=False))
+    except Exception as exc:
+        print(json.dumps({"error": str(exc)}, ensure_ascii=False))
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())