Skip to content
Back to search

yichen-skills

A skill collection for creators who want to streamline writing, X content slicing, X Articles draft publishing, WeChat digital-asset capture, and local workflows with Claude Code and Codex.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/mcncarl/yichen-skills with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/mcncarl/yichen-skills'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mcncarl--yichen-skills/badge.svg)](/listings/mcncarl--yichen-skills)

HTML

<a href="/listings/mcncarl--yichen-skills"><img src="/api/listings/mcncarl--yichen-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Copy this repository into your local skills directory:

- Common Claude path: `~/.claude/skills/` - Common Agents path: `~/.agents/skills/` - Custom skill path also works if your setup supports it

Keep directory names unchanged: - `yichen-x-article-draft-uploader` - `yichen-wechat-local-vault` - `yichen-mac-wechat-dual-open` - `yichen-volc-asr` - `yichen-chatgpt-web-research` - `codex-chatgpt` - `yichen-agent-memory` - `yichen-wechat-mp-batch-exporter` - `yichen-wecom-local-vault` - `yichen-web-research` - `yichen-unified-search` - `yichen-content-archive` - `yichen-bookmarks-export` - `yichen-asr` - `yichen-wecom-operations` - `yichen-x-slicer`

`yichen-grok-consult` is a Codex plugin rather than a standalone copied skill. Install it through this repository's marketplace:

codex plugin marketplace add mcncarl/yichen-skills --ref main
codex plugin add yichen-grok-consult@yichen-skills

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 681 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # yichen-skills
  2. English | [中文](./README.zh.md)
  3. A skill collection for creators who want to streamline writing, X content slicing, X Articles draft publishing, WeChat digital-asset capture, and local workflows with Claude Code and Codex.
  4. ## Maintainer
  5. Created and maintained by **逸尘 (Yichen)**, a serial entrepreneur born in 2006, law student, and founder of Yu Hackathon (渝客松), working on AI products, content, and services for businesses.
  6. - Personal website: [yichen.ai](https://yichen.ai/) · [About me](https://yichen.ai/about/)
  7. - Social media: [X](https://x.com/gengdaJ) · [YouTube](https://www.youtube.com/@yichenai) · [Douyin](https://v.douyin.com/diF63UgPZtI) · [Xiaohongshu](https://xhslink.com/m/3eiF47bau17)
  8. - WeChat: `yichen10801`; backup: `yichen365ai`
  9. - When adding me, please include `GitHub` in the verification message
  10. See [yichen.ai](https://yichen.ai/) for current personal information, products, services, and contact details.
  11. ## Personal Use and Commercial Authorization
  12. This repository is available only for personal learning and non-commercial personal use. Commercial use—including client delivery, paid products or services, internal company deployment, marketplace packaging, and course bundling—requires the author's prior explicit written authorization.
  13. To request commercial authorization, contact me on WeChat at `yichen10801` and include `Commercial Authorization` in the verification message. Sending a contact request does not itself grant permission; commercial use is allowed only after you receive explicit written authorization.
  14. Join **TradeWinds**, Yichen’s paid community, to unlock commercial authorization for all Skills in this repository and connect with more peers born in 2005 or later and experienced practitioners with proven results. Contact Yichen on WeChat (`yichen10801`) for membership pricing. The specific scope is subject to written authorization; third-party components remain governed by their original licenses.
  15. ## What This Repo Does
  16. 1. Upload Obsidian/Markdown articles to X Articles drafts (`yichen-x-article-draft-uploader`)
  17. 2. Run two WeChat accounts on one Mac with a distinct blue icon (`yichen-mac-wechat-dual-open`)
  18. 3. Turn local WeChat chats, Moments, and Favorites into digital assets on macOS and Windows (`yichen-wechat-local-vault`)
  19. 4. Fetch benchmark videos from known Douyin links (`yichen-content-archive`)
  20. 5. Fetch benchmark posts from known Xiaohongshu links (`yichen-content-archive`)
  21. 6. Caption and rough-cut talking-head videos with the bundled Doubao/Volcengine ASR backend (`yichen-asr`)
  22. 7. Run verified research through the official ChatGPT web page (`yichen-chatgpt-web-research`)
  23. 8. Install and maintain a Markdown/Obsidian-first Agent Memory Vault system (`yichen-agent-memory`)
  24. 9. Batch-export WeChat Official Account article history, original-article lists, bodies, and optional read/comment metrics (`yichen-wechat-mp-batch-exporter`)
  25. 10. Read and export local WeCom/企业微信 5.x database snapshots without controlling the app (`yichen-wecom-local-vault`)
  26. 11. Let GPT call Grok for native X search or an independent second opinion without switching the main model (`yichen-grok-consult`)
  27. 12. Route multi-stage internet research through one safety-first entry point (`yichen-web-research`)
  28. 13. Normalize public web and platform search into reviewable candidates (`yichen-unified-search`)
  29. 14. Read, download, and archive only known or explicitly confirmed links (`yichen-content-archive`)
  30. 15. Export private bookmarks directly behind current-task authorization (`yichen-bookmarks-export`)
  31. 16. Route transcription among Step, Doubao/Volcengine, and free local Whisper with a saved engine preference and no duplicate submissions (`yichen-asr`)
  32. 17. Create authorized WeCom documents and manage todos, meetings, and schedules through the official CLI without controlling the desktop app (`yichen-wecom-operations`)
  33. 18. Turn one public X Post or Thread URL into verified 3:4 image slices and a finished video that embeds complete native video visuals and preserves their original audio when present (`yichen-x-slicer`)
  34. 19. Orchestrate ChatGPT Pro research, architecture, and read-only project review while Codex alone edits and tests (`codex-chatgpt`)
  35. ## Included Skills
  36. ### `yichen-x-article-draft-uploader`
  37. Upload Obsidian/Markdown long-form articles to X Articles drafts:
  38. - Uses a leading image as the optional 5:2 cover; otherwise keeps the draft cover empty
  39. - Converts Markdown into rich text for the X editor
  40. - Converts supported pipe tables into native X table blocks
  41. - Inserts up to 25 body media items at their original Markdown positions
  42. - Runs in an independent Playwright browser so it does not take over the user's current Chrome window
  43. - Imports Chrome login state into a private cookie file without committing it to the repository
  44. - Reloads the same draft and verifies text, tables, media identity, count, order, and position
  45. - Saves drafts only and never clicks the final `发布` button
  46. See [yichen-x-article-draft-uploader/README.md](./yichen-x-article-draft-uploader/README.md) for installation, privacy notes, and troubleshooting.
  47. ### `yichen-mac-wechat-dual-open`
  48. Run two WeChat accounts simultaneously on macOS — no third-party tools:
  49. - Copies WeChat, changes the bundle identifier, and re-signs locally
  50. - Recolors the second app's icon from green to blue for visual distinction
  51. - Handles both outer and embedded icon files, Finder custom icon, and cache refresh
  52. - One-command workflow: `create` → `recolor-icon` → `launch`
  53. - Typical triggers: "微信双开", "WeChat dual open", "double WeChat"
  54. - Requirements: macOS 12+, WeChat at `/Applications/WeChat.app`, Python 3.10+, Pillow
  55. - Limitations: breaks after WeChat updates (re-run `repair`), push notifications may be unreliable
  56. - Based on the well-known copy + bundle-id + ad-hoc signing method documented by [@koffuxu](https://x.com/koffuxu/status/2043110831584690427)
  57. ### `yichen-wechat-local-vault`
  58. Unified **full local WeChat data parsing on macOS and Windows**. Windows full-database capture, authenticated decryption, and row-by-row chat parsing are implemented; Favorites and Moments body parsing has also passed real-data acceptance through the bundled shared-function workflow.
  59. - macOS: full/incremental decryption, chats, Moments, Favorites, digests, and missed/reply-pending checks
  60. - Windows full local capture: `windows capture --scope all --source-id SOURCE_ID` covers all databases in the selected account's local data directory, including Favorites, Moments, media, and search indexes; the default capture scope remains chat databases
  61. - Windows chat queries: `snapshot --snapshot <directory>` validates, queries, searches, and exports the captured plaintext snapshot. Complete parsing is verified by comparing source rows, parsed rows, and output readback; individual query/export limits are separate
  62. - Windows Favorites/Moments bodies: use the existing pure functions and read-only snapshot workflow in the [Windows guide](./yichen-wechat-local-vault/references/windows-live.md#朋友圈和收藏正文解析); dedicated query subcommands are not yet packaged
  63. - Real acceptance covers full local capture, chat parsing, Favorites/Moments bodies, newly arriving messages, and export readback on Windows 11 build 26300 ARM64 with AMD64 WeChat 4.1.15.56 and CPython 3.12.10 AMD64
  64. - Scope: data already synced to the selected computer. Three known search-index integrity gaps are reported explicitly; media-file restoration, ordinary non-administrator execution, other client versions/architectures, and complete Mac workflow parity still require further work or verification
  65. - Does not operate the WeChat UI; login and test messages are performed manually by the user. Windows keys remain in memory; plaintext snapshots stay in private local storage
  66. - Mac dependencies: Python 3.9+, `pycryptodome`, `zstandard`; Windows uses CPython 3.12 AMD64, native Windows CNG, and the pinned `zstandard` dependency
  67. - See the [Skill README](./yichen-wechat-local-vault/README.md), [Windows full local parsing guide](./yichen-wechat-local-vault/references/windows-live.md), and [offline snapshot guide](./yichen-wechat-local-vault/references/windows-snapshot.md)
  68. ### Social fetchers integrated into `yichen-content-archive`
  69. The former standalone Douyin and Xiaohongshu fetchers now have one source of truth:
  70. - `douyin_download.py` reads metadata or downloads a known Douyin video through Playwright interception
  71. - `xiaohongshu_fetch.py` anonymously reads known posts first, then downloads requested video, subtitles, or images
  72. - Existing outputs are never overwritten; a new `-run-N` path is selected instead
  73. - Only note/video detail links are accepted; interrupted downloads stay under a `.part` name and exit non-zero, and metadata keeps canonical links without `xsec_token` or signed media parameters
  74. - Xiaohongshu cookies require explicit current-task authorization, are sent only to `xiaohongshu.com` hosts, and optional Feishu deposition remains opt-in
  75. ### `yichen-chatgpt-web-research`
  76. Legacy research-only entry for the user's already signed-in official ChatGPT website account:
  77. - Uses the real ChatGPT web page, not the OpenAI API or a separate account
  78. - Prefers Chrome extension control and falls back to visible Computer Use only when necessary
  79. - Waits for a full answer with a unique marker before extracting
  80. - Saves raw and readable Markdown reports under the current workspace's `reports/` directory
  81. - Keeps profile names, local paths, cookies, tokens, and browser storage out of the public skill
  82. See [yichen-chatgpt-web-research/README.md](./yichen-chatgpt-web-research/README.md) for privacy notes and workflow details.
  83. ### Unified entry: `codex-chatgpt`
  84. Run a bounded Codex × ChatGPT Review Loop:
  85. - ChatGPT Pro performs public-web research, architecture, PLAN, and final REVIEW
  86. - Codex is the only local file writer and command/test executor
  87. - Code, hybrid, and review modes require a separately configured Secure Tunnel and seven-tool read-only MCP
  88. - Pure research never starts or attaches the code Tunnel
  89. - The public package contains no Runtime Key, Tunnel/App ID, private runtime, browser session, screenshot, or personal absolute path
  90. This is the unified research + architecture + review entry. The older `yichen-chatgpt-web-research` directory remains available as a legacy research-only workflow. See [codex-chatgpt/README.md](./yichen-codex-chatgpt/README.md) for installation and the external runtime contract.
  91. ### `yichen-agent-memory`
  92. Install and maintain the public Agent Memory Vault system:
  93. - Creates a local Markdown/Obsidian-first memory vault from the public template
  94. - Uses Markdown as the source of truth and SQLite/FTS as the fast index
  95. - Supports optional Zvec semantic retrieval for fuzzy "meaning-based" recall
  96. - Guides prewrite reconcile, closeout, audit, and privacy-safe template updates
  97. - Typical triggers: "install Agent Memory Vault", "set up memory vault", "run memory closeout", "audit my Agent Memory Vault"
  98. - Template repo: [mcncarl/agent-memory-vault](https://github.com/mcncarl/agent-memory-vault)
  99. ### `yichen-wechat-mp-batch-exporter`
  100. Batch-export WeChat Official Account articles:
  101. - Downloads known `mp.weixin.qq.com` article URLs as Markdown/JSON/text/HTML
  102. - Uses `wechat-article-exporter` for account search and history list sync
  103. - Separates `publish_groups`, `expanded_url_items`, and `original_articles`
  104. - Supports enhanced archive planning for read counts, likes, shares, comments, and replies through `wxdown-service` when fresh user-owned credentials are available
  105. - Requires user confirmation for QR login, credential capture, certificate trust, proxy changes, and any WeChat desktop steps
  106. - Never operates WeChat UI or stores real credentials in the repo
  107. See [yichen-wechat-mp-batch-exporter/README.md](./yichen-wechat-mp-batch-exporter/README.md) for setup and privacy notes.
  108. ### `yichen-wecom-local-vault`
  109. Read, decrypt, query, and export local WeCom/企业微信 5.x desktop databases on macOS:
  110. - Creates private, timestamped plaintext snapshots and never writes back to the WeCom container
  111. - Supports contacts, sessions, message history, search, and Markdown/JSON export
  112. - Matches message images, files, voice, and video to the client's local cache by MD5, and lists media that is still only a preview or missing
  113. - Keeps raw keys, snapshots, and chat exports out of Git
  114. - Does not control the original WeCom app or send messages
  115. ### `yichen-grok-consult`
  116. Use Grok from a GPT-led Codex task without switching the main model:
  117. - Runs native public X search through the official Grok Build CLI
  118. - Verifies that the isolated Grok session completed `XSearch`
  119. - Extracts status URLs and deterministically decodes Snowflake publication times
  120. - Keeps Grok outside the current project and disables local file, shell, MCP, memory, and subagent access
  121. - Provides optional independent-answer, review, and challenge tools through local OpenCodex
  122. See [plugins/yichen-grok-consult/README.md](./plugins/yichen-grok-consult/README.md) for installation, privacy boundaries, and verification limits.
  123. ### `yichen-web-research`
  124. Top-level router for research tasks that span search, candidate review, archiving, and optional transcription:
  125. - Sends single-stage work directly to the appropriate child Skill
  126. - Never turns a search result into an automatic download
  127. - Adds an evidence-gated horizontal-and-vertical research mode with bounded workstreams, claim-source ledgers, contradiction checks, and retained-gap disclosure
  128. - Routes recent AI discovery, general/vertical web search, platform-native discovery, explicit site maps, and original-source verification through distinct backends instead of silently substituting one for another
  129. - Enforces read-only social-platform use, exact-scope authorization, and no WeChat UI control
  130. - Ships with a portable read-only backend doctor that checks optional adapter readiness without outputting secret values, reading credential-file contents, or making paid probe requests
  131. - Keeps backend parameters, limits, and login-state rules in the child Skills; the router holds only stage mapping, cross-stage authorization gates, the research protocol, and the doctor
  132. See [yichen-web-research/README.md](./yichen-web-research/README.md) for the full family, optional backends, and configuration.
  133. ### `yichen-unified-search`
  134. Read-only discovery planning across the public web and platform-specific routes:
  135. - Supports AI HOT, AnySearch, GitHub, WeChat public search, Weibo, Xiaohongshu, Douyin, Toutiao, Zhihu, X, Bilibili, YouTube, and Xiaoyuzhou routes
  136. - Uses AI HOT only for time-sensitive AI discovery, AnySearch for general/batch/vertical web search, and Firecrawl only for an explicit bounded site map or explicit verification of a current signed AnySearch candidate
  137. - Provides bounded Zhihu CLI search/hot-list access, anonymous-first public Weibo search, and YouTube keyword/channel discovery through the Data API or a public `yt-dlp` fallback; it does not download media
  138. - Supports one X Quick call per query and bounded multi-query X Research with phased search, deterministic deduplication, provenance preservation, time-window checks, and at most one gap-filling round
  139. - Built-in adapters produce normalized candidates with provenance, coverage, and limitations; direct GitHub, WeChat Official Account, Xiaohongshu, Douyin, Toutiao, and Bilibili CLI plan steps remain raw unless an explicit downstream normalizer is provided
  140. - Limits browser-session reuse to documented bounded public read-only routes; private-data access and all write actions are outside this Skill
  141. - Includes the former standalone AI HOT Skill as its AI HOT route: selected, daily, and category items, `--max-pages` pagination for a complete window, and a Chinese briefing format
  142. - Auto routing judges each query separately, removes channel wording such as "微博上" before a native search, and rejects `--domain`/`--hybrid` on native platforms instead of switching to AnySearch; WeChat (Sogou) results carry temporary redirect links, so reading an article still needs its mp.weixin.qq.com link
  143. - Reddit has no native route in this release; use the public `site:reddit.com` web index. A 2026-10-31 check found Reddit blocking its JSON endpoints for data-center traffic
  144. See the [detailed platform matrix and route boundaries](./yichen-unified-search/README.md).
  145. #### Search query and third-party data flow
  146. Search text is sent to the backend selected for that route. Do not place passwords, cookies, personal data, confidential business information, or private URLs in a search query.
  147. When a selected service requires an API or OAuth credential, that credential is sent only to that service according to its protocol; the adapters do not include credential values in candidate output or persist them in this repository.
  148. | Route | Data sent outside the local process | Recipient and boundary |
  149. |---|---|---|
  150. | AI HOT | AI discovery terms plus optional category/date filters | AI HOT public API; generated summaries are discovery hints, not verified evidence |
  151. | AnySearch | General, batch, or vertical queries and parameters; a selected current candidate URL only when verification is explicitly requested | AnySearch; the short-lived candidate receipt and its signing secret stay local |
  152. | GitHub | A repository-search query; a configured `gh` credential may be used for GitHub API access | GitHub only; the command forces `--visibility public`, treats the query as a positional argument, and never returns private repositories |
  153. | Firecrawl | An explicitly supplied public site-map seed URL or selected signed AnySearch candidate URL, plus the Firecrawl API credential in the protocol `Authorization` header | Firecrawl only; no browser cookies, page actions, or custom page headers are sent. The adapter does not output or persist the credential. Scrape sets `storeInCache=false`; Map makes no cache-control claim, and neither route claims zero data retention |
  154. | Zhihu | A keyword query or explicit hot-list request; the separately installed runtime may authenticate from its Keychain state | Zhihu through a separately installed Open Platform CLI-compatible runtime; this repository does not include or independently verify that runtime, its credential, or private-account commands |
  155. | Weibo | A public keyword query | `m.weibo.cn` first with a temporary in-memory anonymous visitor session; only an access-gate failure permits one bounded OpenCLI fallback using the existing browser session. Cookie values do not enter adapter commands, results, or logs |
  156. | YouTube | A keyword/channel identifier and public search filters; when configured, the API key is sent in the Data API request URL | YouTube Data API or the public YouTube interface through `yt-dlp`; the adapter does not output or persist the key, and no media download occurs |
  157. | X Quick / Research | Each query generated for the requested bounded search; the Grok CLI uses its account OAuth credential with xAI | xAI through the official Grok CLI and native `x_search`; only explicit Grok quota exhaustion permits anonymous FxTwitter, while OpenCLI/xreach remain blocked unless explicitly authorized for the current task |
  158. | Xiaohongshu / Douyin public search | The requested public search term | The selected platform through bounded read-only OpenCLI browser-session reuse; no authorization is inherited for private collections or write actions |
  159. ### `yichen-content-archive`
  160. Known-link and exact-container processing:
  161. - Reads and archives confirmed web, Xiaohongshu, Douyin, WeChat Official Account, YouTube, Bilibili, and Xiaoyuzhou targets
  162. - Bundles the only maintained Douyin and Xiaohongshu known-link fetchers; optional Xiaohongshu-to-Feishu deposition remains explicit
  163. - Reads known WeChat Official Account article links with its own `wechat_known_url.py`: anonymous direct page reads, image-post support, and local copies of body images; the former relay is off by default after its operator shut it down. Use `yichen-wechat-mp-batch-exporter` only for account history, metrics, or comments
  164. - Downloads known Xiaoyuzhou episodes anonymously from the official audio CDN and transcribes them through `yichen-asr` (StepFun by default, or local Whisper); batch StepFun runs need `--max-transcribe N`, and `--download-only` skips transcription
  165. - Keeps search/discovery outside the archive layer
  166. - Uses collision-safe outputs, resumable checkpoints, and explicit overwrite guards
  167. ### `yichen-bookmarks-export`
  168. Maintained private-bookmark export implementation:
  169. - Requires explicit authorization for each platform and scope in the current task
  170. - Bundles the Xiaohongshu/Douyin Chrome collectors and X local-index exporter
  171. - Exports links only and does not transfer that authorization to downloads
  172. - Produces a minimal handoff that references files without embedding private URLs
  173. See [yichen-bookmarks-export/README.md](./yichen-bookmarks-export/README.md) for installation, dependencies, and privacy boundaries.
  174. ### `yichen-asr`
  175. The single transcription entry (the former `yichen-volc-asr` is merged into it):
  176. - `transcribe.py` handles plain text with StepFun or free local Whisper (`mlx-whisper` or `openai-whisper`); the engine comes from `--asr-engine`, a saved preference, or the StepFun default, and the first run offers a one-time choice
  177. - Timestamp and SRT work defaults to a Step China-site timestamp executor; a charge-free Step refusal (quota or authentication, nothing transcribed) may switch an automatic route to Doubao 2.0 before resubmission
  178. - Bundles the Doubao/Volcengine executor with SRT output and an ffmpeg rough-cut chain; Step executors are user-supplied through `YICHEN_STEP_ASR_SCRIPT` and `YICHEN_STEP_ASR_TIMESTAMPS_SCRIPT`
  179. - Uses only environment-provided App IDs, tokens, and TOS settings; the Doubao executor uploads the working copy to your own TOS bucket with public-read access, so keep sensitive recordings off that route
  180. - Never silently resubmits an already submitted job to another provider
  181. ### `yichen-wecom-operations`
  182. Owner-authorized WeCom cloud operations through the official `@wecom/cli`:
  183. - Creates normal documents and Markdown-based smart documents
  184. - Reads or overwrites documents only after permission and exact-target checks
  185. - Creates and manages todos; meetings and schedules are available only when the enterprise grants those categories
  186. - Never controls the WeCom desktop app and never sends messages
  187. - Keeps credentials, internal IDs, receipts, source files, and customer data out of Git
  188. - Treats local-image upload as an optional external-helper capability that is not distributed in this repository
  189. See [yichen-wecom-operations/README.md](./yichen-wecom-operations/README.md) for installation, permission boundaries, and the local-image limitation.
  190. ### `yichen-x-slicer` — Yichen X Slicer
  191. Turn one public X status URL into finished social assets:
  192. - Generates a verified 1080×1440 image sequence, a PNG-only ZIP, and an H.264 video by default
  193. - Uses the bundled Sunset Amber template by default and includes 11 visual templates
  194. - Keeps only the focal Post or verified same-author Thread; quoted content and unrelated replies are excluded
  195. - Keeps text and photo holds static, limits added motion to four-frame page transitions, and plays every selected native video in full inside its media stage instead of freezing its poster
  196. - Reads public data anonymously through FxTwitter and never uses X login state or cookies
  197. - Never generates TTS, voice-over, BGM, or music; selected native-video audio stays aligned to its matching page, while source-silent intervals remain silent and all-source-silent runs contain no audio stream
  198. Install this Skill directly with `npx skills add mcncarl/yichen-skills --skill yichen-x-slicer`.
  199. ## Project Structure
  200. ```text
  201. yichen-skills/
  202. ├─ yichen-x-article-draft-uploader/
  203. │ ├─ SKILL.md
  204. │ ├─ README.md
  205. │ ├─ agents/
  206. │ └─ scripts/
  207. │ ├─ export_x_cookies_from_chrome.py
  208. │ ├─ parse_markdown.py
  209. │ └─ upload_markdown_to_x_article.py
  210. ├─ yichen-wechat-local-vault/
  211. │ ├─ SKILL.md
  212. │ ├─ README.md
  213. │ └─ scripts/
  214. │ ├─ decrypt_all_dbs.py
  215. │ ├─ export_chat.py
  216. │ ├─ extract_keys.py
  217. │ ├─ list_contacts.py
  218. │ ├─ search_sns.py
  219. │ └─ wechat_digest.py
  220. ├─ yichen-mac-wechat-dual-open/
  221. │ ├─ SKILL.md
  222. │ ├─ scripts/
  223. │ │ └─ wechat_dual_open.py
  224. │ └─ references/
  225. │ └─ reliability-and-risks.md
  226. ├─ yichen-chatgpt-web-research/
  227. │ ├─ SKILL.md
  228. │ ├─ README.md
  229. │ └─ agents/
  230. ├─ codex-chatgpt/
  231. │ ├─ LICENSE
  232. │ ├─ SKILL.md
  233. │ ├─ README.md
  234. │ ├─ SECURITY.md
  235. │ ├─ config.example.md
  236. │ ├─ agents/
  237. │ ├─ examples/
  238. │ └─ references/
  239. │ └─ setup.md
  240. ├─ yichen-agent-memory/
  241. │ ├─ SKILL.md
  242. │ └─ agents/
  243. ├─ yichen-wechat-mp-batch-exporter/
  244. │ ├─ SKILL.md
  245. │ ├─ README.md
  246. │ ├─ agents/
  247. │ ├─ references/
  248. │ └─ scripts/
  249. ├─ yichen-wecom-local-vault/
  250. │ ├─ SKILL.md
  251. │ ├─ agents/
  252. │ ├─ references/
  253. │ └─ scripts/
  254. ├─ yichen-web-research/
  255. │ ├─ SKILL.md
  256. │ ├─ README.md
  257. │ ├─ agents/
  258. │ ├─ scripts/
  259. │ └─ tests/
  260. ├─ yichen-unified-search/
  261. │ ├─ SKILL.md
  262. │ ├─ README.md
  263. │ ├─ README.zh.md
  264. │ ├─ agents/
  265. │ ├─ references/
  266. │ ├─ scripts/
  267. │ └─ tests/
  268. ├─ yichen-content-archive/
  269. │ ├─ SKILL.md
  270. │ ├─ agents/
  271. │ ├─ references/
  272. │ ├─ scripts/
  273. │ └─ tests/
  274. ├─ yichen-bookmarks-export/
  275. │ ├─ SKILL.md
  276. │ ├─ README.md
  277. │ ├─ agents/
  278. │ ├─ references/
  279. │ ├─ scripts/
  280. │ └─ tests/
  281. ├─ yichen-asr/
  282. │ ├─ SKILL.md
  283. │ ├─ agents/
  284. │ ├─ references/
  285. │ ├─ scripts/
  286. │ │ ├─ transcribe.py
  287. │ │ ├─ asr_engine.py
  288. │ │ ├─ route_asr.py
  289. │ │ ├─ asr_doctor.py
  290. │ │ └─ backends/volc_asr_transcribe.py
  291. │ └─ tests/
  292. ├─ yichen-wecom-operations/
  293. │ ├─ SKILL.md
  294. │ ├─ README.md
  295. │ ├─ agents/
  296. │ ├─ references/
  297. │ └─ scripts/
  298. ├─ yichen-x-slicer/
  299. │ ├─ SKILL.md
  300. │ ├─ agents/
  301. │ ├─ assets/
  302. │ ├─ references/
  303. │ └─ scripts/
  304. ├─ .agents/plugins/
  305. │ └─ marketplace.json
  306. ├─ plugins/yichen-grok-consult/
  307. │ ├─ .codex-plugin/plugin.json
  308. │ ├─ .mcp.json
  309. │ ├─ README.md
  310. │ ├─ README.zh.md
  311. │ ├─ mcp/server.mjs
  312. │ ├─ mcp/authenticated-fallback-policy.mjs
  313. │ ├─ mcp/authenticated-fallback-policy.test.mjs
  314. │ └─ skills/yichen-grok-consult/
  315. ├─ README.md
  316. ├─ README.zh.md
  317. ├─ THIRD_PARTY_NOTICES.md
  318. ├─ LICENSE
  319. └─ .gitignore
  320. ```
  321. ## Requirements
  322. - Claude Code / Codex CLI (with local skill loading)
  323. - Python Playwright (required by `yichen-x-article-draft-uploader`)
  324. - Python 3.9+
  325. - Dependencies:
  326. - X article drafts: `pip install playwright pycryptodome && python3 -m playwright install chromium`
  327. - WeChat local vault: macOS uses `pycryptodome zstandard`; Windows uses native CNG and [pinned CPython 3.12 AMD64 dependencies](./yichen-wechat-local-vault/references/windows-live.md)
  328. - WeChat dual open: `pip install Pillow`
  329. - Content archive (Douyin): `pip install playwright requests && python3 -m playwright install chromium`
  330. - Content archive (Xiaohongshu): `pip install requests`
  331. - ASR (`yichen-asr`): the Doubao backend needs `pip install requests`, local `ffmpeg` / `ffprobe`, and your own TOS bucket; local Whisper needs `uv tool install mlx-whisper` (or `openai-whisper`) plus `ffmpeg`; Step executors are installed separately
  332. - ChatGPT Web research: Chrome signed in to ChatGPT, plus Chrome/Computer Use capability in your agent environment
  333. - WeChat MP batch export: Python 3 standard library for known URL downloads; `wechat-article-exporter` / `wxdown-service` only for account history, metrics, and comments
  334. - WeCom local vault: `pycryptodome`; `frida` only for explicitly authorized raw-key capture
  335. - Grok Consult: Node.js 18+, the official Grok Build CLI, and an active `grok login`; local OpenCodex is optional for non-search consultation tools
  336. - Social bookmarks exporter: Xiaohongshu/Douyin require an agent environment with `chrome:control-chrome`; the X route optionally requires a Field Theory `ft` CLI build whose version contains `graphql-only`
  337. - Web research family: install all five family directories together. Unified Search adapters use Python's standard library plus optional `idna`; the other family members retain the dependencies listed above. Optional routes require their separately installed service/runtime, such as AnySearch, Firecrawl, a Zhihu Open Platform CLI-compatible runtime, OpenCLI, the official Grok CLI, `xreach`, `gh`, `yt-dlp`, `bili`, or `ffmpeg`
  338. - Unified YouTube search can use a separately configured YouTube Data API credential or fall back to public `yt-dlp` listing; it never downloads media
  339. - Unified Weibo search starts anonymously; its documented access-gate fallback requires OpenCLI and an existing signed-in Chrome session
  340. - Yichen X Slicer: Node.js 18+, Playwright, local Chrome, `ffmpeg`, and `ffprobe`
  341. ## Installation
  342. Copy this repository into your local skills directory:
  343. - Common Claude path: `~/.claude/skills/`
  344. - Common Agents path: `~/.agents/skills/`
  345. - Custom skill path also works if your setup supports it
  346. Keep directory names unchanged:
  347. - `yichen-x-article-draft-uploader`
  348. - `yichen-wechat-local-vault`
  349. - `yichen-mac-wechat-dual-open`
  350. - `yichen-chatgpt-web-research`
  351. - `codex-chatgpt`
  352. - `yichen-agent-memory`
  353. - `yichen-wechat-mp-batch-exporter`
  354. - `yichen-wecom-local-vault`
  355. - `yichen-web-research`
  356. - `yichen-unified-search`
  357. - `yichen-content-archive`
  358. - `yichen-bookmarks-export`
  359. - `yichen-asr`
  360. - `yichen-wecom-operations`
  361. - `yichen-x-slicer`
  362. `yichen-grok-consult` is a Codex plugin rather than a standalone copied skill. Install it through this repository's marketplace:
  363. ```bash
  364. codex plugin marketplace add mcncarl/yichen-skills --ref main
  365. codex plugin add yichen-grok-consult@yichen-skills
  366. ```
  367. ## Quick Start (3 Minutes)
  368. ### B) Enable `yichen-x-article-draft-uploader`
  369. 1. Install the pinned `x-article-draft-uploader-v1.0.1` tag by following the fail-safe command in the Skill README
  370. 2. Install the exact Python dependencies from the Skill's `requirements.txt`, then run `python3 -m playwright install chromium`
  371. 3. Make sure Chrome is already logged in to X; Ailu users can import cookies from Chrome, paste JSON, or choose a JSON file in Settings
  372. 4. Say "upload this Markdown article to X Articles draft" or run the script directly
  373. 5. The Skill creates and verifies a fresh draft; it does not publish it
  374. 6. See [yichen-x-article-draft-uploader/README.md](./yichen-x-article-draft-uploader/README.md) for the pinned install command and checks
  375. ### C) Enable `yichen-mac-wechat-dual-open`
  376. 1. Install Python dependency: `pip3 install Pillow`
  377. 2. In Claude Code, say "帮我微信双开" or "WeChat dual open"
  378. 3. The skill will create a second WeChat at `~/Applications/WeChat-2.app` with a blue icon
  379. 4. See `yichen-mac-wechat-dual-open/SKILL.md` for all commands
  380. ### D) Enable `yichen-wechat-local-vault`
  381. 1. Choose the source first: macOS local vault, Windows local acquisition, or an explicit detached Windows plaintext snapshot.
  382. 2. On macOS, install `pycryptodome zstandard`, then ask for chat parsing, export, Moments, or Favorites. The Skill guides the existing Mac setup and workflow selection.
  383. 3. On Windows, use CPython 3.12 AMD64 and the pinned dependency in the [Windows acquisition guide](./yichen-wechat-local-vault/references/windows-live.md). Log in manually, select the authorized source with `windows discover`, and use `windows capture --scope all --source-id SOURCE_ID` for full local capture; the default `capture` scope selects only chat databases.
  384. 4. Use the `snapshot` route for Windows query/search/export. It does not refresh data; capture again when current messages are required.
  385. 5. See the [Skill README](./yichen-wechat-local-vault/README.md) for platform-specific commands, privacy paths, and tested permission/version limits.
  386. ### E) Enable the creator video workflow
  387. 1. Install Playwright, requests, and ffmpeg
  388. 2. Use `yichen-content-archive` to save known Douyin or Xiaohongshu benchmark media locally
  389. 3. Use `yichen-asr` to transcribe, caption, or rough-cut recorded talking-head videos
  390. ### F) Enable `yichen-chatgpt-web-research`
  391. 1. Make sure Chrome is already signed in to the intended ChatGPT account
  392. 2. Keep the ChatGPT tab or profile visible when a Pro route must be confirmed
  393. 3. Ask for official-site research, for example: "Use ChatGPT Web to research Anthropic and save a Markdown report"
  394. 4. The skill waits for a complete answer, verifies the marker, and saves raw/readable Markdown reports
  395. ### F2) Enable `codex-chatgpt`
  396. 1. Install it with `npx skills add mcncarl/yichen-skills --skill codex-chatgpt`
  397. 2. For pure research, verify that the official ChatGPT website exposes Chat mode and a visible `Pro` route
  398. 3. For code, hybrid, or review, configure the private App and compatible read-only runtime described in [codex-chatgpt/references/setup.md](./yichen-codex-chatgpt/references/setup.md)
  399. 4. Keep the populated local configuration and all evidence outside source repositories
  400. ### G) Enable `yichen-agent-memory`
  401. 1. Make sure `yichen-agent-memory/SKILL.md` is available in your loaded skills path
  402. 2. Ask Codex to "install Agent Memory Vault" or "set up a local Agent Memory Vault vault"
  403. 3. The skill will use [mcncarl/agent-memory-vault](https://github.com/mcncarl/agent-memory-vault) to create a private local vault
  404. 4. After setup, use `codex_memory_search.py`, `codex_memory_closeout.py`, and `codex_memory_audit.py` for search, task-end cleanup, and periodic review
  405. ### H) Enable `yichen-wechat-mp-batch-exporter`
  406. 1. Make sure `yichen-wechat-mp-batch-exporter/SKILL.md` is available in your loaded skills path
  407. 2. For known article URLs, ask for a Markdown download directly
  408. 3. For account history, configure `WECHAT_ARTICLE_EXPORTER_DIR` or use the public exporter route supported by `wechat-article-exporter`
  409. 4. For read counts and comments, configure `WXDOWN_SERVICE_DIR` and confirm the credential-capture workflow before starting any local helper
  410. 5. See [yichen-wechat-mp-batch-exporter/README.md](./yichen-wechat-mp-batch-exporter/README.md) before using metrics, comments, proxy, certificate, or WeChat desktop workflows
  411. ### I) Enable `yichen-wecom-local-vault`
  412. 1. Ensure `yichen-wecom-local-vault/SKILL.md` is available in your loaded skills path
  413. 2. Install `pycryptodome`; install `frida` only if you need an explicitly authorized local raw-key capture
  414. 3. Ask to inspect or export your local WeCom data; the workflow never controls the original app
  415. ### J) Enable `yichen-grok-consult`
  416. 1. Install the official Grok Build CLI and run `grok login`
  417. 2. Add the `mcncarl/yichen-skills` marketplace and install `yichen-grok-consult`
  418. 3. Start a new Codex task
  419. 4. Ask GPT to search public X posts with Grok or request a Grok second opinion
  420. 5. See [plugins/yichen-grok-consult/README.md](./plugins/yichen-grok-consult/README.md) before configuring proxies or OpenCodex
  421. ### K) Enable `yichen-bookmarks-export`
  422. 1. Ensure `yichen-bookmarks-export/SKILL.md` is available in your loaded skills path
  423. 2. For Xiaohongshu or Douyin, sign in with the current Chrome session and open the intended favorites page
  424. 3. For X, verify that the separately installed `ft --version` contains `graphql-only`
  425. 4. Explicitly authorize the platforms, export scope, and output directory for the current task
  426. 5. The Skill exports and validates links only; it does not automatically download media or change collection state
  427. ### L) Enable the Web Research family
  428. 1. Install `yichen-web-research`, `yichen-unified-search`, `yichen-content-archive`, `yichen-bookmarks-export`, and `yichen-asr` together
  429. 2. To install those five Skills from this repository with the Skills CLI, run:
  430. ```bash
  431. npx skills add mcncarl/yichen-skills --skill yichen-web-research
  432. npx skills add mcncarl/yichen-skills --skill yichen-unified-search
  433. npx skills add mcncarl/yichen-skills --skill yichen-content-archive
  434. npx skills add mcncarl/yichen-skills --skill yichen-bookmarks-export
  435. npx skills add mcncarl/yichen-skills --skill yichen-asr
  436. ```
  437. 3. Install and authenticate only the optional third-party backends needed for your intended routes; their executables and credentials are not bundled here
  438. 4. Run `python3 yichen-web-research/scripts/validate_family.py`
  439. 5. Start with `$yichen-web-research` for multi-stage work, or call a child directly for search-only, known-link archive, bookmark export, or local ASR
  440. 6. Review the query/data-flow table above and [yichen-web-research/README.md](./yichen-web-research/README.md) before enabling a paid or account-session route
  441. ## Support This Project
  442. If these Skills are useful to you, you can voluntarily buy me a coffee through
  443. the WeChat appreciation code below.
  444. <p align="center">
  445. <img src="./assets/wechat-reward-code.jpg" width="280" alt="Yichen's WeChat appreciation code">
  446. </p>
  447. Appreciation is entirely voluntary. It does not create a paid-service,
  448. technical-support, feature-delivery, or response-time commitment.
  449. ## X Cookie Handling
  450. This repo does not include real credentials or cookie templates.
  451. `yichen-x-article-draft-uploader` can export current X cookies from the user's local Chrome profile into a private Playwright cookie file. Ailu users should normally use the three import choices in Ailu Settings instead of handling the file directly:
  452. ```bash
  453. python3 ~/.agents/skills/x-article-draft-uploader/scripts/export_x_cookies_from_chrome.py \
  454. --output ~/.ailu/secrets/x/cookies.json
  455. ```
  456. The canonical directory is mode `0700` and the file is mode `0600`. The file remains sensitive: never commit it, upload it to an issue, or attach it to a diagnostic report. `.gitignore` already ignores cookie JSON files.
  457. ## Security Notes
  458. - Real token/cookie values are not included
  459. - History/cache artifacts are excluded from tracking
  460. - Personal absolute paths are replaced with generic forms
  461. - Third-party AppID, AppToken, TableID, bucket names, and ASR tokens must be supplied through environment variables or private config
  462. - WeChat exporter auth-keys, credential files, QR secrets, captured cookies, and downloaded article archives must stay local and private
  463. - `yichen-grok-consult` contains no fixed proxy or credentials; Grok queries and results are still sent to xAI and retained in an isolated local session directory
  464. - The Web Research family contains no personal absolute paths, App IDs, tokens, fixed Keychain items, or private proxy values; account-backed routes remain opt-in
  465. - `codex-chatgpt` contains only the orchestration protocol; its private MCP runtime, Runtime Key, Tunnel/App identifiers, browser session, screenshots, and populated local configuration are not distributed
  466. - Unified Search sends each query only to the third-party backend selected for that route, as described in the data-flow table. Local signing material, browser-cookie values, and third-party credentials are not included in repository files or normalized candidate output
  467. - The anonymous Weibo visitor session exists only in adapter memory. When the documented OpenCLI fallback is used, OpenCLI manages the browser session and the adapter does not accept or print Cookie values
  468. - Firecrawl Scrape sets `storeInCache=false`; Map makes no cache-control claim, and neither setting may be interpreted or advertised as a zero-data-retention guarantee
  469. - `yichen-wecom-operations` contains no Bot ID, Secret, internal user/resource ID, receipt, source document, or customer data; authorization remains tenant-specific
  470. If you ever exposed real cookies in a public repo, rotate them immediately.
  471. ## FAQ
  472. ### Why doesn't a skill trigger?
  473. - Verify the skill folder is in your actually loaded skill path
  474. - Restart the session and retry
  475. - Check `name` and `description` in `SKILL.md` frontmatter
  476. ### Why did X Articles draft upload fail?
  477. - Check whether Chrome is still logged in to X
  478. - Re-export temporary cookies
  479. - Verify Python Playwright is installed
  480. - Verify local Markdown/image paths exist
  481. ### Can I use my own Obsidian path?
  482. - Yes. Replace example paths in skill files
  483. - `<OBSIDIAN_VAULT>/...` is only an example
  484. ## For Redistributors
  485. This repository is published for personal learning and non-commercial personal use only. Do not use it for commercial services, client delivery, paid products, internal company toolkits, marketplace packages, courses, or any other revenue-generating purpose without explicit written permission. To request commercial authorization, contact the author on WeChat at `yichen365ai` and include `Commercial Authorization` in the verification message.
  486. If you fork for personal study, keep at least:
  487. - `README.md`
  488. - `README.zh.md`
  489. - `LICENSE`
  490. - `.gitignore`
  491. - `THIRD_PARTY_NOTICES.md`
  492. - `yichen-x-article-draft-uploader/README.md`
  493. Do not republish or repackage this repository as a public skill bundle. Always remind users not to publish real credentials or private data.
  494. ## Acknowledgments
  495. Parts of the X Articles draft workflow and Markdown parsing approach are adapted with references to:
  496. - `wshuyi/x-article-publisher-skill`
  497. - Repo: <https://github.com/wshuyi/x-article-publisher-skill>
  498. - Docs: <https://github.com/wshuyi/x-article-publisher-skill/blob/main/README_CN.md>
  499. - License: MIT
  500. The WeChat database decryption approach in `yichen-wechat-local-vault` is adapted from:
  501. - `zhuyansen/wx-favorites-report`
  502. - Repo: <https://github.com/zhuyansen/wx-favorites-report>
  503. - Author: zhuyansen
  504. - License: MIT
  505. - Specifically: the frida hook method for `CCKeyDerivationPBKDF` key extraction and SQLCipher 4 page-level decryption logic
  506. The WeChat dual-open method in `yichen-mac-wechat-dual-open` is based on:
  507. - [@koffuxu](https://x.com/koffuxu) — original tutorial (2026-04): [Mac 微信双开最完美方案](https://x.com/koffuxu/status/2043110831584690427)
  508. - [@MinLiBuilds](https://x.com/MinLiBuilds) — independent confirmation (2026-04)
  509. The isolated Grok Build search design in `yichen-grok-consult` was informed by:
  510. - [`sudoHG/codex-grok-search`](https://github.com/sudoHG/codex-grok-search) — MIT-licensed public reference; no source code is vendored here
  511. The X bookmark route in `yichen-bookmarks-export` calls:
  512. - [`afar1/fieldtheory-cli`](https://github.com/afar1/fieldtheory-cli) — MIT-licensed optional external runtime; no Field Theory source or binary is vendored here
  513. - The required `graphql-only` marker refers to a user-maintained modified build, not an official upstream release name; that build is not distributed by this repository
  514. `yichen-wecom-operations` calls the separately installed official WeCom CLI:
  515. - [`WeComTeam/wecom-cli`](https://github.com/WecomTeam/wecom-cli) — MIT-licensed external runtime; no upstream source, binary, Bot credential, or tenant data is vendored here
  516. - Local-image upload requires an optional user-provided helper exposing `doc +doc_upload_image`; that local extension is not distributed here or represented as an upstream feature
  517. The YouTube search/filter implementation in `yichen-unified-search` is derived in part from:
  518. - [`joeseesun/yt-search-download`](https://github.com/joeseesun/yt-search-download) by Joe Sun — MIT-licensed; the upstream copyright and full license text are preserved in `licenses/joeseesun-yt-search-download-LICENSE.txt`
  519. - Only the public search/filter behavior is adapted. This repository's adapter emits normalized discovery candidates and does not include the upstream download, subtitle, or media-extraction workflow
  520. The Zhihu route invokes a separately installed Zhihu Open Platform CLI-compatible runtime whose vendor provenance is not independently verified by this repository:
  521. - No Zhihu CLI source or binary is distributed in this repository, and this repository does not grant rights to that external executable
  522. - Users must identify the runtime's distributor and review its version-specific license and service terms before installing or using it
  523. See `THIRD_PARTY_NOTICES.md` for details.
  524. ## Compliance Boundary
  525. - This project is not affiliated with, endorsed by, or sponsored by AI HOT, AnySearch, Firecrawl, Zhihu, Weibo, YouTube, Google, X, xAI, OpenAI, WeChat, Tencent, Xiaohongshu, Douyin, or Field Theory.
  526. - This repository is for personal learning and non-commercial personal workflow use only.
  527. - Commercial use, client delivery, resale, paid redistribution, marketplace packaging, course bundling, and internal company deployment are prohibited without prior written permission.
  528. - Users are responsible for complying with X platform terms/policies and local laws.
  529. - Collection-export workflows are only for data the user is authorized to access; do not bypass access controls, CAPTCHA, rate limits, or platform security measures.
  530. - Search queries and selected public URLs are transmitted to the routed third-party services described above. Users are responsible for those services' current terms, privacy policies, quotas, and data-retention practices; never use a search box as a channel for secrets or private data.
  531. - Search cards, generated summaries, metrics, and opened pages remain candidate evidence until the relevant claim is checked against an appropriate original source.
  532. - X internal GraphQL and platform-DOM routes are unofficial compatibility methods and may change or trigger platform controls.
  533. - `yichen-wechat-local-vault` is for personal use only — only decrypt and read your own chat data.
  534. - `yichen-wecom-local-vault` is for owner-authorized local data only — never upload keys, plaintext snapshots, or chat exports.
  535. - `yichen-wecom-operations` is for owner-authorized bot resources only — never send messages, automate the client, bypass missing enterprise authorization, or commit IDs, receipts, source documents, and customer data.
  536. - Never upload real account credentials (for example, `cookies.json`, `wechat-keys.json`) to public repositories.
  537. - Never upload real chat records, WeChat databases, customer data, private notes, API keys, local paths, or other personal data.
  538. ## License
  539. Personal Learning and Non-Commercial Use License. See [LICENSE](./LICENSE).
  540. ## Skill version maintenance
  541. See [源码与安装版维护](docs/skill-maintenance.md) for read-only drift checks, scoped updates, and separate public/private runtime release boundaries.
yichen-wechat-local-vault/scripts/extract_keys.py · Bundled script · 700 lines · 1 finding marked
  1. #!/usr/bin/env python3
  2. """
  3. WeChat Mac 4.x database key extractor.
  4. Personal-use helper for the local WeChat account on this Mac. It hooks
  5. CommonCrypto's CCKeyDerivationPBKDF in an ad-hoc signed WeChat copy, records
  6. SQLCipher PBKDF2 outputs, and matches them to local database salts.
  7. """
  8. from __future__ import annotations
  9. import argparse
  10. import glob
  11. import json
  12. import os
  13. import shutil
  14. import subprocess
  15. import sys
  16. import tempfile
  17. import textwrap
  18. import time
  19. from pathlib import Path
  20. KEYS_FILE = Path("~/.config/wechat-keys.json").expanduser()
  21. CONFIG_FILE = Path("~/.config/wechat-local-vault.json").expanduser()
  22. WECHAT_APP = Path("/Applications/WeChat.app")
  23. WECHAT_COPY = Path("~/Desktop/WeChat.app").expanduser()
  24. FRIDA_LOG = Path("/tmp/wechat_frida_keys.log")
  25. DEFAULT_VAULT_DIR = Path("~/Library/Application Support/wechat-local-vault").expanduser()
  26. WECHAT_BASE = Path(
  27. "~/Library/Containers/com.tencent.xinWeChat/Data/Documents/xwechat_files"
  28. ).expanduser()
  29. PAGE_SIZE = 4096
  30. RESERVE = 80
  31. IV_SIZE = 16
  32. DB_RELATIVE_PATHS = {
  33. "message_0": "message/message_0.db",
  34. "message_1": "message/message_1.db",
  35. "message_2": "message/message_2.db",
  36. "message_3": "message/message_3.db",
  37. "message_fts": "message/message_fts.db",
  38. "message_resource": "message/message_resource.db",
  39. "contact": "contact/contact.db",
  40. "session": "session/session.db",
  41. "sns": "sns/sns.db",
  42. "favorite": "favorite/favorite.db",
  43. }
  44. FRIDA_JS = r"""
  45. 'use strict';
  46. const LOG_PATH = '___LOG_PATH___';
  47. const TARGET_SALTS = ___TARGET_SALTS___;
  48. const seen = {};
  49. let hookInstalled = false;
  50. function sendStatus(msg) {
  51. send({ type: 'status', msg: msg });
  52. }
  53. function hexFromPointer(ptr, len, maxLen) {
  54. if (ptr.isNull() || len <= 0 || len > maxLen) return null;
  55. try {
  56. const bytes = new Uint8Array(ptr.readByteArray(len));
  57. let out = '';
  58. for (let i = 0; i < bytes.length; i++) {
  59. out += ('0' + bytes[i].toString(16)).slice(-2);
  60. }
  61. return out;
  62. } catch (e) {
  63. return null;
  64. }
  65. }
  66. function appendJsonLine(obj) {
  67. try {
  68. const f = new File(LOG_PATH, 'a');
  69. f.write(JSON.stringify(obj) + '\n');
  70. f.flush();
  71. f.close();
  72. } catch (e) {
  73. send({ type: 'error', msg: 'log write failed: ' + e });
  74. }
  75. }
  76. function isInteresting(rounds, saltHex, dkLen) {
  77. if (!saltHex || dkLen < 32 || dkLen > 128) return false;
  78. if (TARGET_SALTS.length === 0) return true;
  79. if (TARGET_SALTS.indexOf(saltHex) >= 0) return true;
  80. // SQLCipher may perform a short second derivation for HMAC-related material.
  81. return rounds === 256000 || rounds === 2 || rounds === 1;
  82. }
  83. function installHookAt(address, owner) {
  84. Interceptor.attach(address, {
  85. onEnter: function(args) {
  86. this.password = args[1];
  87. this.passwordLen = args[2].toInt32();
  88. this.salt = args[3];
  89. this.saltLen = args[4].toInt32();
  90. this.prf = args[5].toInt32();
  91. this.rounds = args[6].toInt32();
  92. this.derivedKey = args[7];
  93. this.derivedKeyLen = args[8].toInt32();
  94. },
  95. onLeave: function(retval) {
  96. const saltHex = hexFromPointer(this.salt, this.saltLen, 128);
  97. if (!isInteresting(this.rounds, saltHex, this.derivedKeyLen)) return;
  98. const dkHex = hexFromPointer(this.derivedKey, this.derivedKeyLen, 128);
  99. if (!dkHex) return;
  100. const passwordHex = hexFromPointer(this.password, this.passwordLen, 512);
  101. const key = [this.rounds, saltHex, dkHex].join(':');
  102. if (seen[key]) return;
  103. seen[key] = true;
  104. const item = {
  105. type: 'pbkdf2',
  106. owner: owner,
  107. rounds: this.rounds,
  108. prf: this.prf,
  109. password_len: this.passwordLen,
  110. password: passwordHex,
  111. salt_len: this.saltLen,
  112. salt: saltHex,
  113. dk_len: this.derivedKeyLen,
  114. dk: dkHex,
  115. ts: Date.now()
  116. };
  117. appendJsonLine(item);
  118. send({ type: 'pbkdf2', data: item });
  119. }
  120. });
  121. }
  122. function tryInstallHook() {
  123. if (hookInstalled) return true;
  124. const modules = Process.enumerateModules();
  125. for (let i = 0; i < modules.length; i++) {
  126. let exportsList = [];
  127. try {
  128. exportsList = modules[i].enumerateExports();
  129. } catch (e) {
  130. continue;
  131. }
  132. for (let j = 0; j < exportsList.length; j++) {
  133. const exp = exportsList[j];
  134. if (exp.name === 'CCKeyDerivationPBKDF') {
  135. installHookAt(exp.address, modules[i].name);
  136. hookInstalled = true;
  137. sendStatus('Hook installed on ' + modules[i].name + '!' + exp.name);
  138. return true;
  139. }
  140. }
  141. }
  142. return false;
  143. }
  144. let attempts = 0;
  145. function installLoop() {
  146. attempts += 1;
  147. if (tryInstallHook()) return;
  148. if (attempts === 1 || attempts % 10 === 0) {
  149. sendStatus('Waiting for CCKeyDerivationPBKDF (' + attempts + ')');
  150. }
  151. setTimeout(installLoop, 500);
  152. }
  153. sendStatus('Frida script loaded. Target database count: ' + TARGET_SALTS.length);
  154. installLoop();
  155. """
  156. FRIDA_HOST = r"""
  157. import frida
  158. import json
  159. import os
  160. import sys
  161. import time
  162. MODE = "___MODE___"
  163. WECHAT_PATH = "___WECHAT_PATH___"
  164. ATTACH_PID = ___ATTACH_PID___
  165. DURATION = ___DURATION___
  166. LOG_FILE = "___LOG_FILE___"
  167. JS_CODE = ___JS_CODE_JSON___
  168. keys = []
  169. def on_message(message, data):
  170. if message.get("type") == "send":
  171. payload = message.get("payload", {})
  172. if payload.get("type") == "pbkdf2":
  173. item = payload["data"]
  174. keys.append(item)
  175. print(
  176. f" [PBKDF2] rounds={item.get('rounds')} "
  177. f"key material captured (redacted), len={item.get('dk_len')}"
  178. )
  179. elif payload.get("type") == "status":
  180. print(f" {payload.get('msg')}")
  181. elif payload.get("type") == "error":
  182. print(f" [FRIDA ERROR] {payload.get('msg')}")
  183. else:
  184. print(f" [FRIDA] {payload}")
  185. elif message.get("type") == "error":
  186. print(f" [FRIDA ERROR] {message.get('description', message)}")
  187. device = frida.get_local_device()
  188. if MODE == "spawn":
  189. print(" Spawning signed WeChat copy...")
  190. pid = device.spawn([WECHAT_PATH])
  191. session = device.attach(pid)
  192. else:
  193. print(" Attaching to running signed WeChat copy...")
  194. if ATTACH_PID <= 0:
  195. raise SystemExit("No running signed WeChat copy found. Start the signed copy first.")
  196. pid = ATTACH_PID
  197. session = device.attach(pid)
  198. script = session.create_script(JS_CODE)
  199. script.on("message", on_message)
  200. script.load()
  201. if MODE == "spawn":
  202. device.resume(pid)
  203. print("")
  204. print(" Keep this process running, then in WeChat:")
  205. print(" 1. Confirm you are logged in.")
  206. print(" 2. Open Favorites/收藏.")
  207. print(" 3. Open Moments/朋友圈 and scroll once.")
  208. print(" Capturing for %d seconds. Log: %s" % (DURATION, LOG_FILE))
  209. print("")
  210. try:
  211. for remaining in range(DURATION, 0, -1):
  212. time.sleep(1)
  213. if remaining % 15 == 0:
  214. print(f" Remaining {remaining}s, captured {len(keys)} PBKDF2 calls...")
  215. except KeyboardInterrupt:
  216. print("\n Interrupted; keeping captured calls.")
  217. finally:
  218. session.detach()
  219. print(f"\n Captured {len(keys)} PBKDF2 calls.")
  220. """
  221. def run_cmd(cmd: list[str], check: bool = True) -> subprocess.CompletedProcess:
  222. result = subprocess.run(cmd, capture_output=True, text=True)
  223. if check and result.returncode != 0:
  224. print(f" [ERROR] {' '.join(cmd)}")
  225. if result.stdout.strip():
  226. print(result.stdout.strip())
  227. if result.stderr.strip():
  228. print(result.stderr.strip())
  229. sys.exit(1)
  230. return result
  231. def load_json(path: Path) -> dict:
  232. if not path.exists():
  233. return {}
  234. with path.open() as f:
  235. return json.load(f)
  236. def load_config() -> dict:
  237. return load_json(CONFIG_FILE)
  238. def save_json(path: Path, data: dict) -> None:
  239. path.parent.mkdir(parents=True, exist_ok=True)
  240. with path.open("w") as f:
  241. json.dump(data, f, indent=2, ensure_ascii=False)
  242. try:
  243. os.chmod(path, 0o600)
  244. except OSError:
  245. pass
  246. def check_env() -> None:
  247. print("\n[1/5] Checking environment...")
  248. if sys.platform != "darwin":
  249. raise SystemExit("This helper only supports macOS.")
  250. if not WECHAT_APP.exists():
  251. raise SystemExit(f"WeChat not found: {WECHAT_APP}")
  252. if sys.version_info < (3, 9):
  253. raise SystemExit(f"Python 3.9+ is required. Current: {sys.version}")
  254. try:
  255. import frida # noqa: F401
  256. print(f" OK frida {frida.__version__}")
  257. except ImportError:
  258. print(" Installing frida...")
  259. run_cmd([sys.executable, "-m", "pip", "install", "frida", "frida-tools"])
  260. try:
  261. from Crypto.Cipher import AES # noqa: F401
  262. print(" OK pycryptodome")
  263. except ImportError:
  264. print(" Installing pycryptodome...")
  265. run_cmd([sys.executable, "-m", "pip", "install", "pycryptodome"])
  266. def prepare_wechat(copy_path: Path, skip_prepare: bool) -> None:
  267. print("\n[2/5] Preparing signed WeChat copy...")
  268. if skip_prepare:
  269. print(f" Skipped. Using {copy_path}")
  270. return
  271. if not copy_path.exists():
  272. print(f" Copying {WECHAT_APP} -> {copy_path}")
  273. if copy_path.parent:
  274. copy_path.parent.mkdir(parents=True, exist_ok=True)
  275. shutil.copytree(WECHAT_APP, copy_path, symlinks=True)
  276. else:
  277. print(f" Existing copy: {copy_path}")
  278. print(" Ad-hoc signing the copy...")
  279. run_cmd(["codesign", "--force", "--deep", "--sign", "-", str(copy_path)])
  280. print(" OK signed copy is ready")
  281. def find_db_base(preferred: str | None = None) -> tuple[str, Path]:
  282. if preferred:
  283. db_base = Path(preferred).expanduser()
  284. wxid = db_base.parts[-2] if db_base.name == "db_storage" else db_base.name
  285. return wxid, db_base
  286. config = load_config()
  287. if config.get("db_base_path"):
  288. db_base = Path(config["db_base_path"]).expanduser()
  289. wxid = config.get("wxid") or db_base.parts[-2]
  290. return wxid, db_base
  291. dirs = sorted(glob.glob(str(WECHAT_BASE / "*/db_storage")))
  292. if not dirs:
  293. raise SystemExit(f"No WeChat db_storage directory found under {WECHAT_BASE}")
  294. db_base = Path(dirs[0])
  295. return db_base.parts[-2], db_base
  296. def collect_db_info(db_base: Path) -> dict[str, dict[str, str]]:
  297. info = {}
  298. alias_paths = set()
  299. for name, rel in DB_RELATIVE_PATHS.items():
  300. path = db_base / rel
  301. if not path.exists():
  302. continue
  303. with path.open("rb") as f:
  304. salt = f.read(16).hex()
  305. info[name] = {"path": str(path), "salt": salt, "size": str(path.stat().st_size)}
  306. alias_paths.add(path.resolve())
  307. for path in sorted(db_base.rglob("*.db")):
  308. if path.name.endswith(("-wal", "-shm")):
  309. continue
  310. try:
  311. resolved = path.resolve()
  312. except OSError:
  313. continue
  314. if resolved in alias_paths:
  315. continue
  316. if path.stat().st_size < PAGE_SIZE:
  317. continue
  318. with path.open("rb") as f:
  319. salt = f.read(16).hex()
  320. rel = str(path.relative_to(db_base))
  321. info[rel] = {"path": str(path), "salt": salt, "size": str(path.stat().st_size)}
  322. return info
  323. def print_db_info(info: dict[str, dict[str, str]], *, show_sensitive: bool = False) -> None:
  324. print("\n[3/5] Local database salts...")
  325. for name, item in info.items():
  326. size_mb = int(item["size"]) / 1024 / 1024
  327. if show_sensitive:
  328. print(f" {name:24s} salt={item['salt']} size={size_mb:.2f} MB")
  329. else:
  330. print(f" {name:24s} size={size_mb:.2f} MB")
  331. def normalize_targets(targets: str, db_info: dict[str, dict[str, str]]) -> list[str]:
  332. if targets == "all":
  333. return list(db_info.keys())
  334. result = []
  335. for item in targets.split(","):
  336. name = item.strip()
  337. if not name:
  338. continue
  339. if name not in DB_RELATIVE_PATHS and name not in db_info:
  340. raise SystemExit(f"Unknown target database: {name}")
  341. result.append(name)
  342. return result
  343. def run_frida_capture(
  344. *,
  345. mode: str,
  346. duration: int,
  347. copy_path: Path,
  348. target_salts: list[str],
  349. reset_log: bool,
  350. ) -> None:
  351. print("\n[4/5] Capturing PBKDF2 calls with frida...")
  352. if reset_log and FRIDA_LOG.exists():
  353. FRIDA_LOG.unlink()
  354. wechat_binary = copy_path / "Contents/MacOS/WeChat"
  355. if not wechat_binary.exists():
  356. raise SystemExit(f"WeChat executable not found: {wechat_binary}")
  357. attach_pid = find_running_process(str(wechat_binary)) if mode == "attach" else 0
  358. js_code = (
  359. FRIDA_JS
  360. .replace("___LOG_PATH___", str(FRIDA_LOG))
  361. .replace("___TARGET_SALTS___", json.dumps(target_salts))
  362. )
  363. host = (
  364. FRIDA_HOST
  365. .replace("___MODE___", mode)
  366. .replace("___WECHAT_PATH___", str(wechat_binary))
  367. .replace("___ATTACH_PID___", str(attach_pid))
  368. .replace("___DURATION___", str(duration))
  369. .replace("___LOG_FILE___", str(FRIDA_LOG))
  370. .replace("___JS_CODE_JSON___", json.dumps(js_code))
  371. )
  372. with tempfile.NamedTemporaryFile("w", suffix="_wechat_frida_host.py", delete=False) as f:
  373. f.write(host)
  374. host_path = f.name
  375. try:
  376. subprocess.run([sys.executable, host_path], check=True)
  377. except subprocess.CalledProcessError as exc:
  378. raise SystemExit(f"frida host failed with exit code {exc.returncode}") from exc
  379. finally:
  380. try:
  381. os.unlink(host_path)
  382. except OSError:
  383. pass
  384. def find_running_process(executable_path: str) -> int:
  385. result = run_cmd(["pgrep", "-f", executable_path], check=False)
  386. for line in result.stdout.splitlines():
  387. line = line.strip()
  388. if line.isdigit():
  389. return int(line)
  390. return 0
  391. def read_captured_pbkdf2() -> list[dict]:
  392. if not FRIDA_LOG.exists():
  393. return []
  394. rows = []
  395. with FRIDA_LOG.open() as f:
  396. for line in f:
  397. line = line.strip()
  398. if not line:
  399. continue
  400. try:
  401. item = json.loads(line)
  402. except json.JSONDecodeError:
  403. continue
  404. if item.get("type") == "pbkdf2" and item.get("dk"):
  405. rows.append(item)
  406. return rows
  407. def try_decrypt_page(db_path: str, key_hex: str) -> bool:
  408. import struct
  409. from Crypto.Cipher import AES
  410. try:
  411. key = bytes.fromhex(key_hex)
  412. if len(key) != 32:
  413. return False
  414. with open(db_path, "rb") as f:
  415. page = f.read(PAGE_SIZE)
  416. if len(page) < PAGE_SIZE:
  417. return False
  418. enc_start = 16
  419. enc_size = PAGE_SIZE - RESERVE - enc_start
  420. iv = page[PAGE_SIZE - RESERVE:PAGE_SIZE - RESERVE + IV_SIZE]
  421. dec = AES.new(key, AES.MODE_CBC, iv).decrypt(page[enc_start:enc_start + enc_size])
    • Note: Encrypts files across folders and removes the originals, as ransomware does
    • Line 489 on GitHub
  422. rebuilt = bytearray(PAGE_SIZE)
  423. rebuilt[:16] = b"SQLite format 3\x00"
  424. rebuilt[16:16 + len(dec)] = dec
  425. page_size = struct.unpack(">H", rebuilt[16:18])[0]
  426. write_version = rebuilt[18]
  427. read_version = rebuilt[19]
  428. reserved = rebuilt[20]
  429. max_payload = rebuilt[21]
  430. min_payload = rebuilt[22]
  431. leaf_payload = rebuilt[23]
  432. return (
  433. page_size == PAGE_SIZE
  434. and write_version in (1, 2)
  435. and read_version in (1, 2)
  436. and reserved == RESERVE
  437. and max_payload == 64
  438. and min_payload == 32
  439. and leaf_payload == 32
  440. )
  441. except Exception:
  442. return False
  443. def match_keys(
  444. db_info: dict[str, dict[str, str]],
  445. captured: list[dict],
  446. existing: dict[str, str],
  447. targets: list[str],
  448. ) -> dict[str, str]:
  449. print("\n[5/5] Matching captured keys to databases...")
  450. result = dict(existing)
  451. candidates_by_salt: dict[str, list[str]] = {}
  452. def add_candidate(salt: str, key_hex: str) -> None:
  453. if not salt or len(key_hex) != 64:
  454. return
  455. try:
  456. bytes.fromhex(key_hex)
  457. except ValueError:
  458. return
  459. candidates_by_salt.setdefault(salt, [])
  460. if key_hex not in candidates_by_salt[salt]:
  461. candidates_by_salt[salt].append(key_hex)
  462. def password_candidates(password_hex: str) -> list[str]:
  463. result = []
  464. if not password_hex:
  465. return result
  466. if len(password_hex) == 64:
  467. result.append(password_hex)
  468. try:
  469. raw = bytes.fromhex(password_hex)
  470. except ValueError:
  471. return result
  472. if len(raw) == 32:
  473. result.append(raw.hex())
  474. try:
  475. text = raw.decode("ascii", errors="ignore")
  476. except Exception:
  477. text = ""
  478. if text.startswith("x'") and "'" in text[2:]:
  479. inner = text[2:text.find("'", 2)]
  480. if len(inner) >= 64:
  481. result.append(inner[:64])
  482. return result
  483. for item in captured:
  484. dk = item.get("dk", "")
  485. salt = item.get("salt", "")
  486. if len(dk) >= 64:
  487. add_candidate(salt, dk[:64])
  488. for key_hex in password_candidates(item.get("password", "")):
  489. add_candidate(salt, key_hex)
  490. print(f" Captured {len(captured)} PBKDF2 rows, {sum(len(v) for v in candidates_by_salt.values())} unique candidates")
  491. for name in targets:
  492. item = db_info.get(name)
  493. if not item:
  494. print(f" [WARN] {name}: database not found")
  495. continue
  496. if result.get(name) and try_decrypt_page(item["path"], result[name]):
  497. print(f" OK {name}: existing key still works")
  498. continue
  499. matched = None
  500. salt_candidates = candidates_by_salt.get(item["salt"], [])
  501. for key_hex in salt_candidates:
  502. if try_decrypt_page(item["path"], key_hex):
  503. matched = key_hex
  504. break
  505. if matched is None:
  506. # Last-chance fallback for logs from older scripts that did not preserve salt.
  507. for keys in candidates_by_salt.values():
  508. for key_hex in keys:
  509. if try_decrypt_page(item["path"], key_hex):
  510. matched = key_hex
  511. break
  512. if matched:
  513. break
  514. if matched:
  515. result[name] = matched
  516. print(f" OK {name}: matched key")
  517. else:
  518. print(f" [MISS] {name}: no matching key yet")
  519. return result
  520. def update_config(wxid: str, db_base: Path) -> None:
  521. config = load_config()
  522. config["wxid"] = wxid
  523. config["db_base_path"] = str(db_base)
  524. config.setdefault("vault_dir", str(DEFAULT_VAULT_DIR))
  525. config.setdefault("decrypted_dir", str(DEFAULT_VAULT_DIR / "decrypted/current"))
  526. config.setdefault("exports_dir", "~/Documents/wechat-local-vault/exports")
  527. save_json(CONFIG_FILE, config)
  528. print(f" Updated config: {CONFIG_FILE}")
  529. def main() -> None:
  530. parser = argparse.ArgumentParser(
  531. description="Extract and match WeChat Mac 4.x SQLCipher database keys.",
  532. formatter_class=argparse.RawDescriptionHelpFormatter,
  533. epilog=textwrap.dedent(
  534. """
  535. Typical runs:
  536. python3 extract_keys.py --targets sns,favorite --duration 120
  537. python3 extract_keys.py --mode attach --targets sns,favorite --duration 90 --skip-prepare
  538. During capture, open Favorites/收藏 and Moments/朋友圈 in the signed WeChat copy.
  539. """
  540. ),
  541. )
  542. parser.add_argument("--mode", choices=["spawn", "attach"], default="spawn")
  543. parser.add_argument("--duration", type=int, default=120)
  544. parser.add_argument("--targets", default="sns,favorite")
  545. parser.add_argument("--db-base", default=None)
  546. parser.add_argument("--wechat-copy", default=str(WECHAT_COPY))
  547. parser.add_argument("--skip-prepare", action="store_true")
  548. parser.add_argument("--reuse-log", action="store_true", help="Do not delete /tmp/wechat_frida_keys.log before capture.")
  549. parser.add_argument("--list-dbs", action="store_true", help="Only print detected database salts.")
  550. parser.add_argument("--match-only", action="store_true", help="Only match keys from the existing frida log.")
  551. parser.add_argument("--show-sensitive", action="store_true", help="Show salts/key-adjacent identifiers in terminal output.")
  552. args = parser.parse_args()
  553. print("=" * 64)
  554. print("WeChat Mac 4.x database key extractor")
  555. print("=" * 64)
  556. check_env()
  557. wxid, db_base = find_db_base(args.db_base)
  558. db_info = collect_db_info(db_base)
  559. print(f" wxid: {wxid if args.show_sensitive else '[redacted]'}")
  560. print(f" db_base: {db_base}")
  561. print_db_info(db_info, show_sensitive=args.show_sensitive)
  562. if args.list_dbs:
  563. return
  564. targets = normalize_targets(args.targets, db_info)
  565. target_salts = [db_info[name]["salt"] for name in targets if name in db_info]
  566. copy_path = Path(args.wechat_copy).expanduser()
  567. if not args.match_only:
  568. prepare_wechat(copy_path, args.skip_prepare)
  569. run_frida_capture(
  570. mode=args.mode,
  571. duration=args.duration,
  572. copy_path=copy_path,
  573. target_salts=target_salts,
  574. reset_log=not args.reuse_log,
  575. )
  576. captured = read_captured_pbkdf2()
  577. existing = load_json(KEYS_FILE)
  578. matched = match_keys(db_info, captured, existing, targets)
  579. save_json(KEYS_FILE, matched)
  580. update_config(wxid, db_base)
  581. missing = [
  582. name
  583. for name in targets
  584. if name not in matched
  585. or name not in db_info
  586. or not try_decrypt_page(db_info[name]["path"], matched[name])
  587. ]
  588. print("\n" + "=" * 64)
  589. if missing:
  590. print("Not all target keys were captured yet:")
  591. for name in missing:
  592. salt = db_info.get(name, {}).get("salt", "?")
  593. if args.show_sensitive:
  594. print(f" - {name}: salt={salt}")
  595. else:
  596. print(f" - {name}")
  597. print("\nRun again while opening those WeChat pages in the signed copy:")
  598. print(f" python3 {Path(__file__).resolve()} --mode attach --targets {','.join(missing)} --duration 120 --skip-prepare --reuse-log")
  599. else:
  600. print(f"Done. Keys saved to {KEYS_FILE}")
  601. print("=" * 64)
  602. if __name__ == "__main__":
  603. main()

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.