@acedatacloud/skills 2026.703.0 → 2026.703.2

package/README.md

@@ -71,6 +71,7 @@ These skills drive third-party connectors users wire up at [auth.acedata.cloud/u
 | [wechat-official-account](skills/wechat-official-account/) | Manage WeChat MP — drafts, publishing, materials, user tags | `wechat` (BYOC) |
 | [personal-wechat](skills/personal-wechat/) | Operate a personal WeChat account through a self-hosted Wisdom service | `personalwechat` (BYOC) |
 | [wecom](skills/wecom/) | WeCom (企业微信) self-built app — contacts, app messages, WeDoc, schedules, meetings | `wecom` (BYOC) |
+| [tencent-docs](skills/tencent-docs/) | Create / read / list / search / manage Tencent Docs — docs, sheets, slides, mind maps, flowcharts | `tencentdocs` (BYOC) |
 
 ## Prerequisites
 

package/package.json

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

@@ -25,7 +25,9 @@ The connector injects the cookie jar as an env var:
 
 - `MEDIUM_COOKIES` — a JSON array of cookies (`sid`, `uid`, `xsrf`). **Secret —
   never echo or print it.** The CLI echoes the `xsrf` cookie as the
-  `x-xsrf-token` header on writes for you.
+  `x-xsrf-token` header on writes for you. If the captured jar has no `xsrf`
+  cookie (common), the CLI mints one automatically before writing, so publishes
+  no longer fail with "Missing xsrf token".
 
 ## CLI
 
@@ -51,7 +53,11 @@ On an auth error the cookie is expired — have the user reconnect at
 ## Publishing — GATED (dry-run unless trailing `--confirm`)
 
 `publish` writes to the user's real account. Content is **Markdown** (converted
-to Medium paragraph blocks: `#`→H1, `##`→H2, `>`→quote, ```` ``` ````→code).
+to Medium paragraph blocks: `#`/`##`→heading, `###`→sub-heading, `>`→quote,
+```` ``` ````→code, `-`/`*`→bullet list, `1.`→numbered list, tables→aligned
+code block). Inline **bold**, *italic*, `code`, and `[links](url)` render as
+real Medium formatting (clickable links included). Bare `https://…` URLs in text
+are auto-linked too (URLs inside code spans are left untouched).
 Without a trailing `--confirm` it dry-runs. `--confirm` is honored **only as the
 last argument**. Always show the dry-run, get an explicit "yes", then re-run.
 
@@ -76,9 +82,12 @@ to a link paragraph (never blocks the post).
 ## Gotchas
 
 - **This is the user's real Medium account.** Confirm before any publish.
-- Markdown→Medium conversion is paragraph-level (headings, quotes, code, body);
-  complex inline formatting / images aren't converted — the user can polish in
-  the Medium editor before going public.
+- Markdown→Medium conversion covers headings, quotes, fenced code, bullet/
+  numbered lists, images, and inline markups (bold/italic/code/links). Medium's
+  editor has no table element: a narrow markdown table renders as an aligned
+  monospace code block, while a wide one (long cells / URLs, which would wrap into
+  an unreadable grid) is rendered as per-row records — the first column bolded as
+  a lead-in, the remaining columns as `header: value` bullets.
 - Medium sits behind Cloudflare; an occasional 403/429 is transient — the CLI
   auto-retries once after a short pause. A *persistent* 403 means the cookie is
   genuinely expired (reconnect).

package/skills/medium/scripts/medium.py

@@ -174,6 +174,32 @@ def api(method, url, jar, *, body=None, _retried=False):
     return d
 
 
+def prime_xsrf(jar) -> None:
+    """Ensure the jar carries an ``xsrf`` cookie. Captured jars frequently lack
+    it, but Medium hands one out on any GET of the site; without it the
+    ``x-xsrf-token`` header is absent and every write fails ('Missing xsrf token')."""
+    if cookie_value(jar, "xsrf"):
+        return
+    url = BASE + "/"
+    hdrs = {"User-Agent": UA, "Accept": "text/html",
+            "X-Requested-With": "XMLHttpRequest"}
+    req = urllib.request.Request(url, headers=hdrs, method="GET")
+    req.add_unredirected_header("Cookie", cookie_header(jar, url))
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            set_cookies = resp.headers.get_all("Set-Cookie") or []
+    except urllib.error.HTTPError as e:
+        set_cookies = e.headers.get_all("Set-Cookie") or []
+    except urllib.error.URLError:
+        return
+    for sc in set_cookies:
+        m = re.match(r"\s*xsrf=([^;]+)", sc)
+        if m:
+            jar.append({"name": "xsrf", "value": m.group(1).strip('"'),
+                        "domain": ".medium.com", "path": "/"})
+            return
+
+
 # ── commands ────────────────────────────────────────────────────────
 
 def md_me(jar):
@@ -336,15 +362,163 @@ def medium_upload_image(jar, post_id, img_bytes, content_type):
     return val["fileId"], val.get("imgWidth"), val.get("imgHeight")
 
 
+# Inline markdown → Medium markups. Groups: 1/2 link, 3 bold, 4 code, 5 italic,
+# 6 bare URL (autolinked).
+_INLINE = re.compile(
+    r"\[([^\]]+)\]\((https?://[^)\s]+)\)"
+    r"|\*\*([^*]+)\*\*"
+    r"|`([^`]+)`"
+    r"|(?<![\w*])\*([^*\n]+)\*(?![\w*])"
+    r"|(https?://[^\s<>()\[\]]+)"
+)
+_TABLE_SEP = re.compile(r"^\s*\|?[\s:|-]*-[\s:|-]*\|?\s*$")
+_LIST_ITEM = re.compile(r"^\s*([-*+]|\d+\.)\s+(.*)$")
+# Medium's code column wraps past ~66 monospace chars; wider tables are rendered
+# as per-row records instead of an unreadable wrapped grid.
+_TABLE_MAX_W = 66
+
+
+def _u16(s: str) -> int:
+    """Length in UTF-16 code units — Medium indexes markup offsets like JS."""
+    return len(s.encode("utf-16-le")) // 2
+
+
+def _inline(text: str):
+    """Parse inline markdown → (plain_text, markups). Emits Medium markups for
+    links (type 3), bold (1), italic (2) and inline code (10) so they render as
+    real formatting instead of literal ``**`` / ``[..](..)`` characters. Bold,
+    italic and link labels are parsed recursively so nested markup (e.g. a link
+    inside bold) is preserved as overlapping markups rather than dropped."""
+    plain: list[str] = []
+    markups: list[dict] = []
+    pos = 0
+    off = 0  # running UTF-16 offset into the assembled plain text
+
+    def _nest(inner: str, start: int):
+        sub_plain, sub_mk = _inline(inner)
+        plain.append(sub_plain)
+        for x in sub_mk:
+            markups.append({**x, "start": x["start"] + start, "end": x["end"] + start})
+        return _u16(sub_plain)
+
+    for m in _INLINE.finditer(text):
+        if m.start() > pos:
+            seg = text[pos:m.start()]
+            plain.append(seg)
+            off += _u16(seg)
+        start = off
+        if m.group(1) is not None:            # link
+            off += _nest(m.group(1), start)
+            markups.append({"type": 3, "start": start, "end": off,
+                            "href": m.group(2), "title": "", "rel": "", "anchorType": 0})
+        elif m.group(3) is not None:          # bold
+            off += _nest(m.group(3), start)
+            markups.append({"type": 1, "start": start, "end": off})
+        elif m.group(4) is not None:          # inline code — literal, no recursion
+            inner = m.group(4)
+            plain.append(inner); off += _u16(inner)
+            markups.append({"type": 10, "start": start, "end": off})
+        elif m.group(5) is not None:          # italic
+            off += _nest(m.group(5), start)
+            markups.append({"type": 2, "start": start, "end": off})
+        elif m.group(6) is not None:          # bare URL → autolink
+            url = m.group(6)
+            tail = ""
+            while url and url[-1] in ".,;:!?。，；：！？":
+                tail = url[-1] + tail
+                url = url[:-1]
+            plain.append(url); off += _u16(url)
+            markups.append({"type": 3, "start": start, "end": off,
+                            "href": url, "title": "", "rel": "", "anchorType": 0})
+            if tail:
+                plain.append(tail); off += _u16(tail)
+        pos = m.end()
+    if pos < len(text):
+        plain.append(text[pos:])
+    return "".join(plain), markups
+
+
+def _is_table(lines):
+    return (len(lines) >= 2 and "|" in lines[0]
+            and "-" in lines[1] and _TABLE_SEP.match(lines[1]) is not None)
+
+
+def _split_row(line):
+    line = line.strip()
+    if line.startswith("|"):
+        line = line[1:]
+    if line.endswith("|"):
+        line = line[:-1]
+    return [c.strip().replace("\\|", "|") for c in re.split(r"(?<!\\)\|", line)]
+
+
+def _render_table(lines):
+    """Markdown table → aligned monospace text (rendered as a PRE code block, the
+    closest faithful representation since Medium's editor has no table element)."""
+    rows = [_split_row(ln) for i, ln in enumerate(lines) if i != 1]
+    ncol = max(len(r) for r in rows)
+    rows = [r + [""] * (ncol - len(r)) for r in rows]
+    widths = [max(len(r[c]) for r in rows) for c in range(ncol)]
+    def fmt(r):
+        return " | ".join(r[c].ljust(widths[c]) for c in range(ncol)).rstrip()
+    sep = "-+-".join("-" * widths[c] for c in range(ncol))
+    body = [fmt(rows[0]), sep] + [fmt(r) for r in rows[1:]]
+    return "\n".join(body)
+
+
+def _table_paras(lines):
+    """Markdown table → Medium paragraphs. A table that fits Medium's ~66-char
+    code column keeps the aligned monospace grid; a wider one (long notes / full
+    URLs would wrap into an unreadable mess) becomes a per-row record — the first
+    cell as a bold lead-in, the remaining columns as ``header: value`` bullets.
+    Both paths stay inside the stdlib-only, no-image contract."""
+    grid = _render_table(lines)
+    if max((len(ln) for ln in grid.split("\n")), default=0) <= _TABLE_MAX_W:
+        return [{"type": 8, "text": grid}]
+    rows = [_split_row(ln) for i, ln in enumerate(lines) if i != 1]
+    header = rows[0] if rows else []
+    out = []
+    for r in rows[1:]:
+        cells = [c.strip() for c in r]
+        if not any(cells):
+            continue
+        if cells[0]:                               # lead cell → whole-cell bold
+            txt, mk = _inline(cells[0])
+            mk.append({"type": 1, "start": 0, "end": _u16(txt)})
+            out.append({"type": 1, "text": txt, "markups": mk})
+        for i in range(1, len(cells)):
+            if not cells[i]:
+                continue
+            vtxt, vmk = _inline(cells[i])
+            label = header[i].strip() if i < len(header) else ""
+            if label:                              # "label: value", label bolded
+                prefix = f"{label}: "
+                shift = _u16(prefix)
+                markups = [{"type": 1, "start": 0, "end": _u16(f"{label}:")}]
+                markups += [{**x, "start": x["start"] + shift, "end": x["end"] + shift}
+                            for x in vmk]
+                out.append({"type": 9, "text": prefix + vtxt, "markups": markups})
+            else:
+                out.append({"type": 9, "text": vtxt, "markups": vmk})
+    return out or [{"type": 8, "text": grid}]
+
+
+def _is_list(lines):
+    ls = [ln for ln in lines if ln.strip()]
+    return bool(ls) and all(_LIST_ITEM.match(ln) for ln in ls)
+
+
 def _build_deltas(jar, post_id, title, content, rehost=True):
-    """Markdown → Medium paragraph deltas (image-aware). A standalone
-    ``![alt](url)`` block is uploaded to Medium and emitted as an image
-    paragraph (type 4); on upload failure it degrades to a link paragraph."""
+    """Markdown → Medium paragraph deltas. Handles standalone ``![alt](url)``
+    images (uploaded → type-4 image paragraph), headings, quotes, fenced code,
+    tables (narrow → aligned code block; wide → per-row records), bullet/ordered
+    lists, and inline markups (links/bold/italic/code) on ordinary text."""
     paras = [{"type": 3, "text": title}]
     for block in re.split(r"\n\s*\n", content.strip()):
         b = block.strip("\n")
         if not b.strip():
             continue
+        lines = b.split("\n")
         first = b.lstrip()
         m = _MD_IMG.fullmatch(first)
         if m:
@@ -367,19 +541,34 @@ def _build_deltas(jar, post_id, title, content, rehost=True):
             continue
         if first.startswith("```"):
             paras.append({"type": 8, "text": re.sub(r"^```[^\n]*\n?|\n?```$", "", b)})
+        elif _is_table(lines):
+            paras.extend(_table_paras(lines))
+        elif _is_list(lines):
+            for ln in lines:
+                lm = _LIST_ITEM.match(ln)
+                if not lm:
+                    continue
+                ptype = 10 if lm.group(1).endswith(".") else 9
+                txt, mk = _inline(lm.group(2).strip())
+                paras.append({"type": ptype, "text": txt, "markups": mk})
         elif first.startswith("# "):
-            paras.append({"type": 12, "text": first[2:].strip()})
+            txt, mk = _inline(first[2:].strip())
+            paras.append({"type": 2, "text": txt, "markups": mk})
         elif first.startswith("## "):
-            paras.append({"type": 2, "text": first[3:].strip()})
+            txt, mk = _inline(first[3:].strip())
+            paras.append({"type": 2, "text": txt, "markups": mk})
         elif first.startswith("### "):
-            paras.append({"type": 3, "text": first[4:].strip()})
+            txt, mk = _inline(first[4:].strip())
+            paras.append({"type": 3, "text": txt, "markups": mk})
         elif first.startswith("> "):
-            paras.append({"type": 6, "text": first[2:].strip()})
+            txt, mk = _inline(first[2:].strip())
+            paras.append({"type": 6, "text": txt, "markups": mk})
         else:
-            paras.append({"type": 1, "text": b.replace("\n", " ").strip()})
+            txt, mk = _inline(b.replace("\n", " ").strip())
+            paras.append({"type": 1, "text": txt, "markups": mk})
     out_deltas = []
     for i, p in enumerate(paras):
-        para = {"type": p["type"], "text": p["text"], "markups": []}
+        para = {"type": p["type"], "text": p["text"], "markups": p.get("markups") or []}
         if "layout" in p:
             para["layout"] = p["layout"]
         if "metadata" in p:
@@ -413,6 +602,12 @@ def cmd_publish(jar, args):
         })
         return
 
+    # Captured jars often lack an xsrf cookie; mint one so writes don't 400.
+    prime_xsrf(jar)
+    if not cookie_value(jar, "xsrf"):
+        die("could not obtain an xsrf token from Medium (cookie may be expired) — "
+            "reconnect at https://auth.acedata.cloud/user/connections.")
+
     # 1. create empty draft
     d = api("POST", f"{BASE}/new-story", jar, body={})
     payload = d.get("payload") or {}

package/skills/tencent-docs/SKILL.md

@@ -0,0 +1,224 @@
+---
+name: tencent-docs
+description: Create, read, list, search, and manage Tencent Docs (腾讯文档) — online documents, sheets, slides, mind maps, flowcharts, smart tables, and forms — via the Tencent Docs Open API. Use when the user mentions 腾讯文档 / Tencent Docs / docs.qq.com, a docs.qq.com link, or wants to create / read / organize a doc, sheet, slide, mind map, or flowchart in their Tencent Docs space.
+when_to_use: |
+  Trigger when the user wants to work with their Tencent Docs (腾讯文档) space —
+  create a new document / sheet / slide / mind map / flowchart / smart table /
+  form, read a doc or sheet's content, list a folder, search files by keyword,
+  or rename / move / copy / delete a file. Acts in the user's own Tencent Docs
+  account, so destructive or outward-facing writes are gated behind confirmation.
+connections: [tencentdocs]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+# Tencent Docs (腾讯文档)
+
+Drive the [Tencent Docs Open API](https://docs.qq.com/open/document/app/) with
+`curl + jq`. Everything runs **in the user's own Tencent Docs account** — only
+files they can access, only the scopes they granted at connect time.
+
+## Auth — three headers (NOT a single Bearer)
+
+The `tencentdocs` BYOC connector injects three env vars; every call sends **all
+three** headers:
+
+- `TENCENTDOCS_ACCESS_TOKEN` → `Access-Token` header (OAuth2 access token). **Secret.**
+- `TENCENTDOCS_CLIENT_ID` → `Client-Id` header (the developer app's Client ID).
+- `TENCENTDOCS_OPEN_ID` → `Open-Id` header (the user id returned with the token).
+
+All endpoints live under `https://docs.qq.com/openapi`. Define a reusable header
+set once per session:
+
+```sh
+AUTH=(-H "Access-Token: $TENCENTDOCS_ACCESS_TOKEN" \
+      -H "Client-Id: $TENCENTDOCS_CLIENT_ID" \
+      -H "Open-Id: $TENCENTDOCS_OPEN_ID")
+```
+
+Never echo, print, or log `TENCENTDOCS_ACCESS_TOKEN` — it is full account access.
+
+## Response shape & error handling
+
+Every response is `{"ret": 0, "msg": "Succeed", "data": {…}}`. **`ret == 0`
+means success**; any non-zero `ret` is an error — surface `msg` to the user.
+Always check it:
+
+```sh
+resp=$(curl -sS "${AUTH[@]}" … )
+echo "$resp" | jq 'if .ret == 0 then .data else error("Tencent Docs \(.ret): \(.msg)") end'
+```
+
+Common error codes:
+
+| code | meaning | what to do |
+|---|---|---|
+| `400006` | access token invalid / expired | tell the user to reconnect 腾讯文档 at <https://auth.acedata.cloud/user/connections> — do **not** loop-retry |
+| `400007` | VIP (超级会员) privilege required | the requested capability needs a Tencent Docs 超级会员; tell the user, link <https://docs.qq.com/vip> |
+| `400008` | 积分 (credits) insufficient | AI-generation quota is exhausted; tell the user to top up |
+| `11607` / `-32603` | bad request params | recheck `fileID` / `type` / body fields against the recipe below |
+
+## Doc types (`type` when creating)
+
+| type | Product | Notes |
+|---|---|---|
+| `doc` | 在线文档 (Word-style) | classic rich-text document |
+| `sheet` | 在线表格 (Excel) | data tables |
+| `slide` | 幻灯片 (PPT) | presentations |
+| `mind` | 思维导图 | mind map |
+| `flowchart` | 流程图 | flowchart |
+| `smartsheet` | 智能表格 | structured multi-view table |
+| `form` | 收集表 | form / survey |
+
+## Recipes
+
+### Verify auth (always run first)
+
+Cheap sanity check — read the app's OpenAPI usage counter:
+
+```sh
+curl -sS "${AUTH[@]}" "https://docs.qq.com/openapi/drive/v2/util/resource-use" \
+  | jq 'if .ret == 0 then .data else "ERR \(.ret): \(.msg)" end'
+```
+
+If this returns `400006`, the connection is expired — have the user reconnect.
+
+### List a folder (root = `/`)
+
+```sh
+curl -sS "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/drive/v2/folders/%2F?listType=folder&sortType=browse&asc=0" \
+  | jq 'if .ret == 0 then [.data.list[]? | {ID, title, type, url}] else . end'
+```
+
+`%2F` is the URL-encoded root folder id. For a sub-folder use its folder id in
+the path.
+
+### Search files by keyword
+
+```sh
+curl -sS -G "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/drive/v2/search" \
+  --data-urlencode "searchName=Q1 预算" \
+  | jq 'if .ret == 0 then [.data.list[]? | {ID, title, type, url}] else . end'
+```
+
+### Read a file's metadata
+
+The `fileID` is the last path segment of a `https://docs.qq.com/doc/<id>` (or
+`/sheet/`, `/slide/`, …) URL.
+
+```sh
+curl -sS "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/drive/v2/files/FILE_ID/metadata" \
+  | jq 'if .ret == 0 then .data else . end'
+```
+
+### Read an online document's content
+
+```sh
+curl -sS "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/document/v3/files/FILE_ID/export?exportType=text" \
+  | jq 'if .ret == 0 then .data else . end'
+```
+
+### Read a sheet's cell range
+
+Get the sheet's `sheetId` list from the metadata first, then read a range
+(`A1:D10`):
+
+```sh
+curl -sS "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/spreadsheet/v2/files/FILE_ID/sheets/SHEET_ID/values?range=A1:D10" \
+  | jq 'if .ret == 0 then .data.values else . end'
+```
+
+### Create a file
+
+`POST /openapi/drive/v2/files` with form-urlencoded `title` + `type`. Returns the
+new file's `ID` and `url`.
+
+```sh
+curl -sS -X POST "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/drive/v2/files" \
+  --data-urlencode "title=会议纪要 2026-07-03" \
+  --data-urlencode "type=doc" \
+  | jq 'if .ret == 0 then {ID: .data.ID, url: .data.url} else . end'
+```
+
+Swap `type=sheet` / `slide` / `mind` / `flowchart` / `smartsheet` / `form` for
+other doc types. Pass `--data-urlencode "folderID=<id>"` to create inside a
+folder instead of the root.
+
+### Upload an image (for embedding in docs)
+
+```sh
+curl -sS -X POST "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/resources/v2/images" \
+  -F "file=@./cover.png" \
+  | jq 'if .ret == 0 then .data else . end'
+```
+
+### Rename a file — GATED, confirm first
+
+Show the user the current `title` + `url` and the new title, get an explicit
+"yes", then run:
+
+```sh
+curl -sS -X PATCH "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/drive/v2/files/FILE_ID" \
+  --data-urlencode "title=新的标题" \
+  | jq 'if .ret == 0 then "renamed" else . end'
+```
+
+### Move a file — GATED, confirm first
+
+Show the user the file's current `title` + location and the destination folder,
+get an explicit "yes", then run. `folderID=/` moves it back to the root.
+
+```sh
+curl -sS -X PATCH "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/drive/v2/files/FILE_ID/move" \
+  --data-urlencode "folderID=DEST_FOLDER_ID" \
+  | jq 'if .ret == 0 then "moved" else . end'
+```
+
+### Copy a file
+
+```sh
+curl -sS -X POST "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/drive/v2/files/FILE_ID/copy" \
+  --data-urlencode "title=副本 - 项目计划" \
+  | jq 'if .ret == 0 then {ID: .data.ID, url: .data.url} else . end'
+```
+
+### Delete a file — GATED, confirm first
+
+Deletion moves the file to the recycle bin but is still destructive. **Show the
+user the exact `title` + `url`, get an explicit "yes", then run:**
+
+```sh
+curl -sS -X DELETE "${AUTH[@]}" \
+  "https://docs.qq.com/openapi/drive/v2/files/FILE_ID" \
+  | jq 'if .ret == 0 then "deleted" else . end'
+```
+
+## Notes
+
+- **Gate writes.** Rename / move / delete / copy and any share-permission change
+  act on the user's real files — confirm the exact target before running.
+- **Extract ids from links.** When the user pastes a `docs.qq.com/doc/<id>` (or
+  `/sheet/`, `/slide/`, `/mind/`, `/flowchart/`, `/form/`, `/smartsheet/`) URL,
+  take the id from the path rather than asking for it.
+- **Pagination.** List / search endpoints return a cursor / `next` marker in
+  `data`; pass it back to fetch the next page. Stop when the marker is empty.
+- **Rate / quota.** Free apps get 20,000 API calls/month (超级会员 20,000/day,
+  Plus 40,000/day). AI-generation features additionally consume 积分 and may
+  require 超级会员 — a `400007` / `400008` means the account tier / credits, not a
+  bug in the request.
+- **Full API index.** Beyond the recipes above, the Open API also covers
+  smart-table records, form collection, folder CRUD, permissions, and
+  import/export — see the [接口索引](https://docs.qq.com/open/document/app/openapi/v2/file/).