@acedatacloud/skills 2026.703.10 → 2026.703.12

package/package.json

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

@@ -0,0 +1,147 @@
+---
+name: bluesky
+description: Publish, delete and read your own posts on Bluesky via the AT Protocol (XRPC). Use when the user wants to post to their Bluesky account, cross-post an article as a short dev-focused post, delete a post, or list their own recent posts with engagement stats (reposts, likes, replies). Auth uses the user's handle plus an App Password.
+when_to_use: |
+  Trigger when the user wants to publish a post to their Bluesky account,
+  delete one, or review their own recent posts and engagement. Bluesky runs on
+  the AT Protocol: the connector stores the user's handle plus an App Password
+  (NOT the main account password) and a PDS service URL (default
+  https://bsky.social). Confirm the post text with the user before publishing.
+connections: [bluesky]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+Call the **Bluesky AT Protocol** XRPC endpoints with `curl + jq`. Three
+connector credentials are injected: `$BLUESKY_HANDLE` (e.g. `name.bsky.social`),
+`$BLUESKY_APP_PASSWORD` (an App Password created in Bluesky **Settings →
+Privacy and Security → App Passwords**, NOT the account login password) and
+`$BLUESKY_SERVICE` (the PDS base URL, default `https://bsky.social`).
+
+Errors come back as JSON `{"error":"<name>","message":"<detail>"}` — show it
+verbatim. A `401 {"error":"AuthenticationRequired"}` on session creation means
+the handle or App Password is wrong/revoked → the user must re-connect the
+Bluesky connector (or generate a fresh App Password).
+
+## Step 1 — always create a session first
+
+Everything needs a short-lived `accessJwt` and your account `did`. Do this once
+per task and reuse the values:
+
+```bash
+SVC="${BLUESKY_SERVICE:-https://bsky.social}"
+SESSION=$(curl -sS -X POST "$SVC/xrpc/com.atproto.server.createSession" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -n --arg id "$BLUESKY_HANDLE" --arg pw "$BLUESKY_APP_PASSWORD" \
+        '{identifier:$id, password:$pw}')")
+echo "$SESSION" | jq '{did, handle, active}'
+JWT=$(echo "$SESSION" | jq -r .accessJwt)
+DID=$(echo "$SESSION" | jq -r .did)
+```
+
+If `JWT` / `DID` are empty or `null`, print the raw `$SESSION` (it contains the
+error) and stop — do not continue to post.
+
+## Post to Bluesky
+
+**Confirm the text with the user before posting.** Text is limited to **300
+graphemes**; longer text → `400 {"error":"InvalidRequest"}`. `createdAt` must be
+an ISO-8601 UTC timestamp.
+
+```bash
+TEXT="Hello Bluesky 👋 shipping with the AT Protocol"
+NOW=$(date -u +%Y-%m-%dT%H:%M:%S.000Z)
+curl -sS -X POST "$SVC/xrpc/com.atproto.repo.createRecord" \
+  -H "Authorization: Bearer $JWT" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -n --arg did "$DID" --arg text "$TEXT" --arg now "$NOW" \
+        '{repo:$did, collection:"app.bsky.feed.post",
+          record:{ "$type":"app.bsky.feed.post", text:$text, createdAt:$now, langs:["en"] }}')" \
+  | jq '{uri, cid}'
+```
+
+The returned `uri` looks like `at://did:plc:xxxx/app.bsky.feed.post/<rkey>`. The
+public web URL is `https://bsky.app/profile/$BLUESKY_HANDLE/post/<rkey>` where
+`<rkey>` is the last path segment of the `uri`.
+
+### Clickable links, mentions and hashtags (facets)
+
+Plain URLs/hashtags in `text` are shown but **not clickable** — Bluesky needs
+`facets` with UTF-8 **byte** offsets. Add a hashtag link like this (byteStart/
+byteEnd are byte indices into the UTF-8 text, not character indices):
+
+```bash
+# text = "New post about #ai" — "#ai" starts at byte 15, ends at byte 18
+curl -sS -X POST "$SVC/xrpc/com.atproto.repo.createRecord" \
+  -H "Authorization: Bearer $JWT" -H "Content-Type: application/json" \
+  -d "$(jq -n --arg did "$DID" --arg now "$NOW" '
+    {repo:$did, collection:"app.bsky.feed.post",
+     record:{ "$type":"app.bsky.feed.post", text:"New post about #ai", createdAt:$now,
+       facets:[ { index:{byteStart:15, byteEnd:18},
+                  features:[{ "$type":"app.bsky.richtext.facet#tag", tag:"ai" }] } ] }}')" \
+  | jq '{uri, cid}'
+```
+
+For a link, use feature `app.bsky.richtext.facet#link` with a `uri` field; for a
+mention, `app.bsky.richtext.facet#mention` with a `did`. Compute byte offsets
+with e.g. `printf '%s' "$prefix" | wc -c`.
+
+## List my recent posts + engagement
+
+```bash
+curl -sS "$SVC/xrpc/app.bsky.feed.getAuthorFeed?actor=$DID&limit=20&filter=posts_no_replies" \
+  -H "Authorization: Bearer $JWT" \
+  | jq '.feed[] | {uri: .post.uri,
+                   text: .post.record.text,
+                   reposts: .post.repostCount,
+                   likes: .post.likeCount,
+                   replies: .post.replyCount,
+                   at: .post.indexedAt}'
+```
+
+`limit` max 100. `filter` options: `posts_with_replies`, `posts_no_replies`,
+`posts_with_media`, `posts_and_author_threads`.
+
+## Delete a post
+
+`deleteRecord` needs the `rkey` (the last path segment of the post `uri`):
+
+```bash
+POST_URI="at://$DID/app.bsky.feed.post/3kabc123xyz"
+RKEY="${POST_URI##*/}"
+curl -sS -X POST "$SVC/xrpc/com.atproto.repo.deleteRecord" \
+  -H "Authorization: Bearer $JWT" -H "Content-Type: application/json" \
+  -d "$(jq -n --arg did "$DID" --arg rkey "$RKEY" \
+        '{repo:$did, collection:"app.bsky.feed.post", rkey:$rkey}')" \
+  | jq '{deleted: true, rkey: "'"$RKEY"'"}'
+```
+
+An empty `{}` response is success. `400 {"error":"InvalidRequest"}` usually
+means the record is already gone or the `rkey` is wrong.
+
+## Attaching images (optional)
+
+Upload each image via `POST $SVC/xrpc/com.atproto.repo.uploadBlob`
+(`Content-Type: image/jpeg`, raw bytes body, Bearer `$JWT`) → returns a `blob`
+object. Then set `record.embed` to
+`{ "$type":"app.bsky.embed.images", images:[{ alt:"<desc>", image:<blob> }] }`.
+Max 4 images per post; each blob ≲ 1 MB (resize/compress first).
+
+## Gotchas
+
+- **App Password, not account password:** creating a session with the real
+  login password may be rejected or trip 2FA. Always the App Password from
+  Settings → App Passwords.
+- **Byte offsets, not char offsets:** facet `byteStart`/`byteEnd` are UTF-8
+  byte indices — emoji and CJK take multiple bytes. Get them wrong and the
+  link highlights the wrong span.
+- **300 graphemes**, counted as user-perceived characters (emoji = 1).
+- **Rate limits:** the PDS rate-limits writes per account; space out bulk posts
+  or you'll get `429 {"error":"RateLimitExceeded"}`.
+- **Self-hosted PDS:** if the user runs their own PDS, `$BLUESKY_SERVICE` points
+  there; all XRPC calls target that host, not `bsky.social`.
+- The `accessJwt` is short-lived (~2h). For a single task it's fine; if it
+  expires mid-task, just re-run Step 1.

package/skills/vk/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: vk
+description: Publish posts to your VK (ВКонтакте) profile or community wall and read your own recent posts, via the official VK API (wall.post / wall.get). Use when the user wants to post to VK, cross-post an article for a Russian-speaking audience, or list their own recent VK wall posts with engagement. Auth uses a VK access token (community access key recommended).
+when_to_use: |
+  Trigger when the user wants to publish content to their VK wall or community,
+  or review their own recent VK posts. VK's user-token OAuth flows were disabled
+  in June 2024, so the connector stores a long-lived **community access key**
+  (VK community → Manage → Settings → API usage, with the `wall` right). Posting
+  to a community wall uses a negative owner_id + from_group=1. Confirm the post
+  text with the user before publishing.
+connections: [vk]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+Call the **VK API** with `curl + jq`. The token is injected as `$VK_ACCESS_TOKEN`
+and is passed in the `Authorization: Bearer` header. **Every** VK API call also
+requires the `v` (API version) query parameter — use `v=5.199`. Base URL:
+`https://api.vk.com/method/<method>`.
+
+VK always returns HTTP 200; success is `{"response": ...}` and failure is
+`{"error":{"error_code":<n>,"error_msg":"<detail>"}}` — always check for `.error`
+and show `error_msg` verbatim. Common codes: `5` = auth failed (token wrong or
+revoked → user must re-connect the VK connector), `214` = access to adding post
+denied (the token lacks the `wall` right — a community access key with `wall` is
+required), `15`/`203` = access denied to that owner.
+
+## Step 1 — identify who you can post as
+
+A **community access key** posts on the community wall: `owner_id` must be the
+**negative** community id and you pass `from_group=1`. Resolve the community id
+from the token:
+
+```bash
+curl -sS "https://api.vk.com/method/groups.getById?v=5.199" \
+  -H "Authorization: Bearer $VK_ACCESS_TOKEN" \
+  | jq '.response, .error'
+```
+
+Take the group `id` (e.g. `123456`) → `owner_id` is `-123456`. (For a personal
+user token, `owner_id` is your positive user id from `users.get`, and you omit
+`from_group`.)
+
+## Post to the wall
+
+**Confirm the message text with the user before posting.** The post must have
+text and/or attachments.
+
+```bash
+OWNER_ID="-123456"   # negative = community; from_group=1 posts as the community
+MSG="Пример поста через VK API. #ai"
+curl -sS -G "https://api.vk.com/method/wall.post" \
+  -H "Authorization: Bearer $VK_ACCESS_TOKEN" \
+  --data-urlencode "v=5.199" \
+  --data-urlencode "owner_id=$OWNER_ID" \
+  --data-urlencode "from_group=1" \
+  --data-urlencode "message=$MSG" \
+  | jq '.response, .error'
+```
+
+Success returns `{"response":{"post_id":<id>}}`. The public URL is
+`https://vk.com/wall<OWNER_ID>_<post_id>` (e.g. `https://vk.com/wall-123456_17`).
+
+- Hashtags (`#tag`) and plain URLs in `message` are rendered/clickable natively —
+  no facet/offset handling needed (unlike Bluesky).
+- Attach media/links with `attachments` (comma-separated), format
+  `{type}{owner_id}_{media_id}` (e.g. `photo-123456_789`) or a single external
+  URL. Only **one** link may be attached; more than one link → error 222.
+- `publish_date` (Unix timestamp) schedules a deferred post.
+- Always send Cyrillic `message` via `--data-urlencode` so it isn't mangled.
+
+## List my recent wall posts + engagement
+
+```bash
+OWNER_ID="-123456"
+curl -sS -G "https://api.vk.com/method/wall.get" \
+  -H "Authorization: Bearer $VK_ACCESS_TOKEN" \
+  --data-urlencode "v=5.199" \
+  --data-urlencode "owner_id=$OWNER_ID" \
+  --data-urlencode "count=20" \
+  | jq '.error, (.response.items[]? | {id,
+        text,
+        likes: .likes.count,
+        reposts: .reposts.count,
+        comments: .comments.count,
+        views: .views.count,
+        date})'
+```
+
+`count` max 100. Combine `owner_id` + a post `id` to build the URL
+`https://vk.com/wall<owner_id>_<id>`.
+
+## Delete a post
+
+```bash
+OWNER_ID="-123456"; POST_ID="17"
+curl -sS -G "https://api.vk.com/method/wall.delete" \
+  -H "Authorization: Bearer $VK_ACCESS_TOKEN" \
+  --data-urlencode "v=5.199" \
+  --data-urlencode "owner_id=$OWNER_ID" \
+  --data-urlencode "post_id=$POST_ID" \
+  | jq '.response, .error'
+```
+
+## Gotchas
+
+- **`v` is mandatory** on every call — omitting it returns an error.
+- **User tokens can't be freshly minted via OAuth** (Implicit / Authorization
+  Code flows for user tokens were disabled 2024-06); use a **community access
+  key** (unlimited lifetime, created in the community's API settings) with the
+  `wall` right.
+- Posting as the community requires both `owner_id` negative **and**
+  `from_group=1`.
+- Rate/anti-spam: repeated identical posts or too-frequent posting can hit codes
+  like `214`/`219` — space posts out.