@acedatacloud/skills 2026.606.1 → 2026.613.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acedatacloud/skills",
-  "version": "2026.606.1",
+  "version": "2026.613.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/blogger/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: blogger
+description: Publish posts to your Blogger blog and read your blogs / posts via the Blogger API v3. Use when the user mentions Blogger, blogspot, publishing a post to their blog, listing their blogs, or updating an existing Blogger post.
+when_to_use: |
+  Trigger when the user wants to publish a post to their Blogger blog,
+  list their blogs, list / read posts on a blog, or update an existing
+  post. The connector grants the Blogger scope (read + write); confirm
+  before publishing publicly (you can insert as a draft first).
+connections: [google/blogger]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+Call the **Blogger API v3** with `curl + jq`. The user's OAuth bearer token is
+in `$GOOGLE_BLOGGER_TOKEN`; every call needs
+`Authorization: Bearer $GOOGLE_BLOGGER_TOKEN`. Base URL:
+`https://www.googleapis.com/blogger/v3`.
+
+Errors are `{"error": {"code": ..., "message": ...}}` — show them verbatim.
+`401` → token expired, re-connect the Blogger connector.
+
+**Always start by listing the user's blogs** to get a `blogId`:
+
+```bash
+curl -sS -H "Authorization: Bearer $GOOGLE_BLOGGER_TOKEN" \
+  "https://www.googleapis.com/blogger/v3/users/self/blogs" \
+  | jq '.items[] | {id, name, url}'
+```
+
+## Publish a post
+
+**Confirm before publishing publicly.** Use `?isDraft=true` to stage a draft.
+
+```bash
+BLOG_ID="1234567890"
+jq -n --arg t "My title" --arg c "<p>HTML content of the post…</p>" \
+  '{kind:"blogger#post", title:$t, content:$c, labels:["ai","video"]}' \
+| curl -sS -X POST \
+    "https://www.googleapis.com/blogger/v3/blogs/$BLOG_ID/posts/?isDraft=false" \
+    -H "Authorization: Bearer $GOOGLE_BLOGGER_TOKEN" \
+    -H "Content-Type: application/json" \
+    -d @- \
+| jq '{id, url, status}'
+```
+
+`content` is **HTML** (not Markdown) — convert Markdown to HTML first
+(e.g. with `pandoc -f markdown -t html` or a simple converter).
+
+- Publish a staged draft: `POST /blogs/{blogId}/posts/{postId}/publish`.
+- Update a post: `PUT /blogs/{blogId}/posts/{postId}` with the same shape.
+
+## List / read posts
+
+```bash
+curl -sS -H "Authorization: Bearer $GOOGLE_BLOGGER_TOKEN" \
+  "https://www.googleapis.com/blogger/v3/blogs/$BLOG_ID/posts?maxResults=20&status=live" \
+  | jq '.items[] | {id, title, url, published}'
+```
+
+## Gotchas
+
+- **Enable the Blogger API** on the Google Cloud project backing the OAuth
+  client, or calls 403 with `accessNotConfigured`.
+- `content` must be HTML; passing raw Markdown will render literally.
+- Paginate with `&pageToken=$PAGE_TOKEN` from the previous `.nextPageToken`.

package/skills/devto/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: devto
+description: Publish, update and read articles on DEV (dev.to) via the Forem API v1. Use when the user mentions dev.to / DEV Community, publishing a blog post to dev.to, cross-posting an article, updating a published post, or listing their dev.to articles and stats.
+when_to_use: |
+  Trigger when the user wants to publish a Markdown article to their
+  dev.to account, update a previously published article, or list /
+  inspect their own dev.to articles (views, reactions, comments). The
+  connector stores a DEV API Key with full account access — confirm
+  before publishing publicly (you can publish as a draft with
+  published=false first).
+connections: [devto]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+Call the **Forem API v1** (dev.to) with `curl + jq`. The user's API key is in
+`$DEVTO_API_KEY`; every call needs the headers `api-key: $DEVTO_API_KEY` and
+`Accept: application/vnd.forem.api-v1+json`. Base URL: `https://dev.to/api`.
+
+Errors come back as JSON with an `error` / `status` field — show them verbatim.
+`401` means the API key is invalid → the user must re-connect the DEV connector.
+
+**Always start by confirming the key** and learning the account:
+
+```bash
+curl -sS -H "api-key: $DEVTO_API_KEY" -H "Accept: application/vnd.forem.api-v1+json" \
+  "https://dev.to/api/users/me" | jq '{username, name}'
+```
+
+## Publish an article
+
+**Confirm with the user before publishing publicly.** Default to a draft
+(`published:false`) unless they explicitly say publish/now.
+
+```bash
+TITLE="My title"
+BODY_MD="$(cat article.md)"   # full Markdown body
+jq -n --arg t "$TITLE" --arg b "$BODY_MD" \
+  '{article:{title:$t, body_markdown:$b, published:false, tags:["ai","webdev"]}}' \
+| curl -sS -X POST "https://dev.to/api/articles" \
+    -H "api-key: $DEVTO_API_KEY" \
+    -H "Accept: application/vnd.forem.api-v1+json" \
+    -H "Content-Type: application/json" \
+    -d @- \
+| jq '{id, url, published}'
+```
+
+To publish a draft later (or edit), `PUT /api/articles/{id}` with the same
+shape (set `published:true`). Front-matter inside `body_markdown` (a `---`
+block) can also carry `title`, `tags`, `series`, `canonical_url`, `cover_image`.
+
+- **Canonical URL:** when cross-posting, set
+  `"canonical_url":"https://your-blog/original"` so DEV points SEO back to the
+  source — important for the article→video / cross-publishing flow.
+
+## List / inspect my articles
+
+```bash
+# My published + draft articles (paginated; per_page max 1000).
+curl -sS -H "api-key: $DEVTO_API_KEY" -H "Accept: application/vnd.forem.api-v1+json" \
+  "https://dev.to/api/articles/me/all?per_page=30" \
+  | jq '.[] | {id, title, published, page_views_count, public_reactions_count, comments_count}'
+
+# A single article's full content + stats.
+curl -sS -H "api-key: $DEVTO_API_KEY" -H "Accept: application/vnd.forem.api-v1+json" \
+  "https://dev.to/api/articles/ARTICLE_ID" | jq '{title, url, reactions: .public_reactions_count, views: .page_views_count}'
+```
+
+## Gotchas
+
+- **Tags:** max 4, lowercase, no spaces (e.g. `webdev`, `machinelearning`).
+- **Rate limit:** article create/update is throttled (a few per 30s); space out
+  bulk publishes or you'll get `429`.
+- `body_markdown` is the source of truth — if you put a `---` front-matter block
+  at the top, its fields override the JSON `article` fields.

package/skills/linkedin/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: linkedin
+description: Publish text / link posts to your LinkedIn personal feed via the LinkedIn Posts API. Use when the user mentions LinkedIn, sharing or posting an update to LinkedIn, or cross-posting an article / link to their LinkedIn feed.
+when_to_use: |
+  Trigger when the user wants to publish a text or link share to their
+  own LinkedIn feed. Posting is public on their profile — confirm the
+  text (and link, if any) before publishing. Requires the
+  w_member_social scope (granted by the connector at install).
+connections: [linkedin]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+Call the **LinkedIn API** with `curl + jq`. The user's bearer token is in
+`$LINKEDIN_TOKEN`; every call needs `Authorization: Bearer $LINKEDIN_TOKEN`.
+
+LinkedIn posts must be authored by the member's URN. Get the member id from the
+OpenID userinfo endpoint, then build `urn:li:person:{sub}`.
+
+```bash
+SUB=$(curl -sS -H "Authorization: Bearer $LINKEDIN_TOKEN" \
+  "https://api.linkedin.com/v2/userinfo" | jq -r .sub)
+AUTHOR="urn:li:person:$SUB"
+echo "$AUTHOR"
+```
+
+Errors are JSON with `message` / `serviceErrorCode` — show them verbatim.
+`401` → token expired (tokens last ~60 days), re-connect the LinkedIn connector.
+
+## Publish a post (Posts API)
+
+**Confirm the text with the user first.** Use the versioned Posts API; set the
+`LinkedIn-Version` header to a recent `YYYYMM` (LinkedIn requires a valid recent
+version — if you get `426`/version errors, bump to the current month).
+
+```bash
+jq -n --arg a "$AUTHOR" --arg t "My update text. Check out https://studio.acedata.cloud" \
+  '{author:$a, commentary:$t, visibility:"PUBLIC",
+    distribution:{feedDistribution:"MAIN_FEED", targetEntities:[], thirdPartyDistributionChannels:[]},
+    lifecycleState:"PUBLISHED", isReshareDisabledByAuthor:false}' \
+| curl -sS -X POST "https://api.linkedin.com/rest/posts" \
+    -H "Authorization: Bearer $LINKEDIN_TOKEN" \
+    -H "Content-Type: application/json" \
+    -H "LinkedIn-Version: 202401" \
+    -H "X-Restli-Protocol-Version: 2.0.0" \
+    -d @- -D - -o /dev/null | tr -d '\r' | awk '/^[Xx]-[Rr]estli-[Ii]d:|^[Ll]ocation:/{print}'
+```
+
+A successful create returns `201` with the post URN in the `x-restli-id`
+(or `Location`) response header — report that URN / the resulting post URL.
+
+> Link posts: put the URL inline in `commentary` (LinkedIn auto-unfurls it).
+> Rich article attachments need the assets/images API — out of scope for a
+> simple text/link share; keep links inline.
+
+## Fallback: legacy ugcPosts
+
+If the versioned endpoint is unavailable for the app, the older
+`POST https://api.linkedin.com/v2/ugcPosts` with a
+`specificContent."com.linkedin.ugc.ShareContent"` body also works with
+`w_member_social`. Prefer `/rest/posts` above.
+
+## Gotchas
+
+- **Author URN** must match the token's member (`urn:li:person:{sub}`) — you
+  can't post as someone else.
+- `w_member_social` only allows posting to the **member's own feed**; company
+  Page posts need `w_organization_social` + an admin role (not in this connector).
+- The `LinkedIn-Version` header is mandatory for `/rest/*`; a stale value
+  returns a version error — bump to the current `YYYYMM`.

package/skills/reddit/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: reddit
+description: Submit posts (link or text) to subreddits and read your Reddit identity / content via the Reddit API. Use when the user mentions Reddit, posting to a subreddit, submitting a link or self-post, or checking their Reddit profile / submissions.
+when_to_use: |
+  Trigger when the user wants to submit a post to a subreddit (link or
+  self/text post), or read their own Reddit identity and submissions.
+  Posting to a subreddit is public and subject to that subreddit's rules
+  / karma requirements — confirm the target subreddit, title and body
+  before submitting.
+connections: [reddit]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+Call the **Reddit API** (OAuth endpoints) with `curl + jq`. The user's bearer
+token is in `$REDDIT_TOKEN`. **Every call MUST send a `User-Agent` header** or
+Reddit returns `429`. Use the OAuth host `https://oauth.reddit.com`.
+
+```bash
+UA="web:cloud.acedata.connectors:v1.0 (by /u/acedatacloud)"
+```
+
+Errors are JSON; a submit returns `{"json":{"errors":[...], "data":{...}}}` —
+if `errors` is non-empty, show them verbatim. `401` → token expired, re-connect.
+
+**Always start by confirming identity:**
+
+```bash
+curl -sS -H "Authorization: Bearer $REDDIT_TOKEN" -H "User-Agent: $UA" \
+  "https://oauth.reddit.com/api/v1/me" | jq '{name, total_karma, link_karma}'
+```
+
+## Submit a post
+
+**Confirm the subreddit + title + body with the user first.** `sr` is the
+subreddit name WITHOUT the `r/` prefix.
+
+```bash
+# Self (text) post: kind=self + text. Link post: kind=link + url.
+curl -sS -X POST "https://oauth.reddit.com/api/submit" \
+  -H "Authorization: Bearer $REDDIT_TOKEN" -H "User-Agent: $UA" \
+  --data-urlencode "sr=test" \
+  --data-urlencode "kind=self" \
+  --data-urlencode "title=My title" \
+  --data-urlencode "text=My self-post body in markdown" \
+  --data-urlencode "api_type=json" \
+  | jq '.json | {errors, url: .data.url, id: .data.id}'
+```
+
+For a link post:
+
+```bash
+curl -sS -X POST "https://oauth.reddit.com/api/submit" \
+  -H "Authorization: Bearer $REDDIT_TOKEN" -H "User-Agent: $UA" \
+  --data-urlencode "sr=test" --data-urlencode "kind=link" \
+  --data-urlencode "title=My title" --data-urlencode "url=https://example.com" \
+  --data-urlencode "api_type=json" | jq '.json'
+```
+
+## Read my submissions
+
+```bash
+curl -sS -H "Authorization: Bearer $REDDIT_TOKEN" -H "User-Agent: $UA" \
+  "https://oauth.reddit.com/user/USERNAME/submitted?limit=10" \
+  | jq '.data.children[] | .data | {title, subreddit, ups, num_comments, permalink}'
+```
+
+## Gotchas
+
+- **User-Agent is mandatory** on every request — omitting it → `429`.
+- Many subreddits gate posting on **account age / karma / flair**; a submit can
+  return `errors` like `[["SUBREDDIT_NOTALLOWED", ...]]` — surface it and try
+  `r/test` to validate the flow.
+- Respect rate limits: read the `X-Ratelimit-Remaining` response header; space
+  out bulk submits.
+- Use `r/test` as a safe target when validating that the connection works.

package/skills/youtube/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: youtube
+description: Search YouTube, read your own channel and uploaded videos (stats, comments), and upload new videos via the YouTube Data API v3. Use when the user mentions YouTube, "my channel", "my videos", searching YouTube, video views / likes / stats, uploading a video to YouTube, or checking how a published video is doing.
+when_to_use: |
+  Trigger when the user wants to search YouTube, inspect their own
+  channel / uploaded videos (views, likes, comments), look up a
+  video's stats, or upload a new video to their channel. The
+  installed connector always grants `youtube.readonly` (search + read
+  your channel and videos); the user opts in to `youtube.upload` at
+  install time to publish videos — confirm before uploading and
+  re-prompt to re-install if the upload scope is missing.
+connections: [google/youtube]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+Call the **YouTube Data API v3** with `curl + jq`. The user's OAuth bearer
+token is in `$GOOGLE_YOUTUBE_TOKEN`; every call needs it as
+`Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN`. Base URL:
+`https://www.googleapis.com/youtube/v3`.
+
+The token always carries `youtube.readonly` plus identity scopes
+(`openid email profile`); if the user opted in at install it also
+carries `youtube.upload` (publish videos).
+
+Responses are standard JSON; failures surface as
+`{"error": {"code": 401|403|..., "message": "..."}}` — show that error
+verbatim. `401` → token expired, the user must re-connect the YouTube
+connector. `403 insufficientPermissions` on an upload → the user did
+not grant `youtube.upload`; ask them to re-connect with the upload box
+checked.
+
+**Always start with the channel check** to confirm the connection works
+and learn which channel you're operating against.
+
+```bash
+curl -sS -H "Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN" \
+  "https://www.googleapis.com/youtube/v3/channels?part=snippet,statistics,contentDetails&mine=true" \
+  | jq '.items[0] | {title: .snippet.title, subs: .statistics.subscriberCount, views: .statistics.viewCount, uploads: .contentDetails.relatedPlaylists.uploads}'
+```
+
+## Search YouTube
+
+```bash
+# Public search (any video). type can be video|channel|playlist.
+curl -sS -H "Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN" \
+  --data-urlencode "q=ai video automation" \
+  --data-urlencode "part=snippet" \
+  --data-urlencode "type=video" \
+  --data-urlencode "maxResults=10" \
+  -G "https://www.googleapis.com/youtube/v3/search" \
+  | jq '.items[] | {videoId: .id.videoId, title: .snippet.title, channel: .snippet.channelTitle, published: .snippet.publishedAt}'
+```
+
+Add `--data-urlencode "order=date|viewCount|rating|relevance"` to sort,
+or `--data-urlencode "publishedAfter=2026-01-01T00:00:00Z"` to window.
+
+## See my uploaded videos
+
+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}'
+```
+
+Paginate by passing `--data-urlencode "pageToken=$PAGE_TOKEN"` with the
+`.nextPageToken` from the previous response.
+
+## Video stats (views / likes / comments)
+
+```bash
+# Accepts a comma-separated id list.
+curl -sS -H "Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN" \
+  -G "https://www.googleapis.com/youtube/v3/videos" \
+  --data-urlencode "part=snippet,statistics,status" \
+  --data-urlencode "id=VIDEO_ID_1,VIDEO_ID_2" \
+  | jq '.items[] | {title: .snippet.title, views: .statistics.viewCount, likes: .statistics.likeCount, comments: .statistics.commentCount, privacy: .status.privacyStatus}'
+```
+
+## Read comments on a video
+
+```bash
+curl -sS -H "Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN" \
+  -G "https://www.googleapis.com/youtube/v3/commentThreads" \
+  --data-urlencode "part=snippet" \
+  --data-urlencode "videoId=VIDEO_ID" \
+  --data-urlencode "maxResults=20" \
+  --data-urlencode "order=relevance" \
+  | jq '.items[] | .snippet.topLevelComment.snippet | {author: .authorDisplayName, text: .textDisplay, likes: .likeCount}'
+```
+
+## Upload a video (needs `youtube.upload`)
+
+**Confirm with the user before publishing** — show the title, privacy and
+file you're about to upload. Uploads are a two-step *resumable* flow:
+init with metadata → PUT the bytes.
+
+```bash
+FILE="/path/to/video.mp4"
+TITLE="My title"
+DESC="My description"
+# privacyStatus: public | unlisted | private
+read -r -d '' META <<JSON
+{"snippet":{"title":"$TITLE","description":"$DESC","categoryId":"22"},
+ "status":{"privacyStatus":"unlisted","selfDeclaredMadeForKids":false}}
+JSON
+
+# 1. Init resumable session -> capture the upload URL from the Location header.
+UPLOAD_URL=$(curl -sS -D - -o /dev/null \
+  -H "Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN" \
+  -H "Content-Type: application/json; charset=UTF-8" \
+  -H "X-Upload-Content-Type: video/*" \
+  -X POST "https://www.googleapis.com/upload/youtube/v3/videos?uploadType=resumable&part=snippet,status" \
+  -d "$META" | tr -d '\r' | awk '/^[Ll]ocation:/{print $2}')
+
+# 2. Upload the bytes -> returns the created video resource (has .id).
+curl -sS -H "Authorization: Bearer $GOOGLE_YOUTUBE_TOKEN" \
+  -H "Content-Type: video/*" \
+  -X PUT --upload-file "$FILE" "$UPLOAD_URL" \
+  | jq '{id: .id, url: ("https://www.youtube.com/watch?v=" + .id), privacy: .status.privacyStatus}'
+```
+
+`categoryId` `22` = "People & Blogs" (a safe default). To set a custom
+thumbnail (needs the file to be processed first), call
+`POST /upload/youtube/v3/thumbnails/set?videoId=VIDEO_ID` with the image.
+
+## Gotchas
+
+- **Quota:** the Data API is quota-metered (default 10,000 units/day). A
+  `search` costs 100 units; an `upload` costs ~1,600. A burst of searches
+  can exhaust the daily quota → `403 quotaExceeded`; surface it plainly.
+- **No "my videos" endpoint** — always go via the uploads playlist.
+- **`search` results are eventually-consistent** — a freshly uploaded
+  video may not appear in `search` for minutes/hours; read it via the
+  uploads playlist or by id instead.
+- Uploaded videos start in `uploaded`/`processing` state; stats are `0`
+  until processing completes.