A Local-First AI Workbench That Refuses to Ghostwrite Your WeChat Posts

Project: Jianzi · WeChat Official Account Editor Workbench (wechat-newsroom-workbench, MIT open source, Windows only) Repository: github.com/shiker1996/wechat-newsroom-workbench

🎯 Why Build This

Anyone who writes for WeChat Official Accounts knows these pains:

• Asking a large model for a first draft produces heavy AI-flavored writing: parallelism, crescendos, buzzwords like "empower" and "leverage" — editing it is more tiring than writing from scratch.
• AI casually fabricates facts. A statistic, a person's name, a segment of an "official response" — if you don't verify every single one, publishing it means a PR disaster.
• Formatting is hell. Markdown requires manual styling, copying into the WeChat editor often breaks the layout, and sourcing images with proper attribution is a separate chore.
• The same content needs to be produced as a long-form article + Xiaohongshu cards, starting from scratch each time.
• Most critically: throwing your topic selection, account persona, and unpublished content onto some SaaS platform is genuinely unsettling.

So I thought: could I build a tool that keeps the entire chain — "hotspot collection → fact assessment → drafting → formatting → graphics" — on my local machine, where every step is auditable and reproducible, and no data ever leaves my computer?

Thus, this project was born.

📦 What It Is / What It Isn't

• ✅ Is: A local content production workbench for individual WeChat Official Account authors. A single pipeline runs from hotspots to directly pasteable WeChat rich text and Xiaohongshu graphics.
• ❌ Is Not: Not a SaaS, not a multi-user system, not designed for public network deployment. Listens only on 127.0.0.1, no login, no telemetry.

In one sentence: Your content production chain stays on your own computer.

🧱 Tech Stack: Deliberately "No Stack"

Honestly, this might be the most comfortable part — no need to install a pile of frameworks:

Node.js 24 native HTTP (no Express/Koa)
+ node:sqlite (Node built-in, zero native compilation dependencies)
+ Frontend native ES Modules (public/src)
= Listens on 127.0.0.1:4317

The data layer has about 25 tables: batches, hotspots, candidates, documents, artifacts, editing sessions, LLM call audits, generation snapshots, AI runs, tool executions. Migrations are idempotent CREATE TABLE IF NOT EXISTS + column detection, additive only, never destructive, so old databases start right up.

Installation is also extremely simple; Node can even be auto-downloaded to .node-runtime/ (without modifying the system environment):

setup-workbench.cmd   # One-click install dependencies, configure LLM Key, clone RSSHub
start-workbench.cmd   # Start, automatically opens browser

🔄 Two Pipelines: Stage Contracts Are Fixed

I think the most core design is the two pipelines with strictly fixed stage contracts.

Article Chain: Hotspot → Directly Pasteable WeChat Rich Text

Hotspot Collection → Tagging/Event Card → Event Assessment (Clustering → Dimension Grouping → Pre-selection → Scoring)
  → Editorial Meeting (Conversational structured decision-making, WRITE_NOW gate)
  → Drafting (brief→fact-base→planning→draft→quality gate→title→humanize→review→SEO→final review)
  → Formatting (rendered→design→images→draft→normalized→gate)

A few details I think are very valuable:

1️⃣ The editorial room asks only one question at a time. AI doesn't make decisions for you; instead, it breaks down what you say into "public facts / author's opinion / practical evidence / opposing angles / unresolved questions / prohibited items." It refuses to draft if the proposition isn't locked in. This is mechanistically combating AI ghostwriting, not relying on pleading prompt words.

2️⃣ Formatting is deterministic rendering. It doesn't ask the model to spit out HTML; instead, markdownToHtml outputs inline styles based on theme tokens, copy-pastes directly into the WeChat editor, without relying on an external copy page. Image handling goes through "local upload → explicit click to upload to CDN → obtain real HTTPS URL before allowing formal formatting."

3️⃣ Every step is audited. Background tasks record step-by-step logs, every LLM call writes to model_calls (tokens, duration, success/failure), and all artifacts are saved to the working directory, traceable.

Graphic Chain: Storyboard → Layout Audit → Page-by-Page PNG

Graphic Fact Base → Storyboard Planning → Generation (card_plan + copy)
  → Layout Audit → Screenshot (Puppeteer page-by-page PNG) → Delivery Gate

Graphics are uniformly 375×667, supporting both WeChat Official Account and Xiaohongshu channels. After AI generates the storyboard, you can manually modify content blocks page by page — add/delete blocks, change types, switch layouts. The layout audit checks utilization, overflow, and cropping; if it fails, it first tries composition fallback and relaxed layout, and if that still doesn't work, it automatically locates the specific problem page and opens the editor, letting you fix it directly, rather than throwing a "please open the editor and find it yourself" message.

🧩 Skills + Plugins: Extensibility Is Serious

This isn't a hardcoded tool, but a content production runtime that can install skills and plugins:

• 31 built-in skills (SKILL.md + references structure), each declaring input/output contracts, capabilities, and compatible versions.
• Third-party skill packages can be installed, with validation (path traversal, compatibleApp, size limits).
• 8 built-in tool plugins: ECharts/Mermaid rendering, repository checking, image hosting upload, URL fetching, local project reading, Tavily search, document retrieval, all following "input schema → policy check → execution → audit log."
• Remote plugins are purely declarative Manifests: HTTPS + timeout + response limit + intranet rejection, no distribution of executable code allowed.

⚙️ LLM Gateway: Handling All the Pitfalls of Large Models

• Multiple providers (DeepSeek / MiniMax / Kimi), OpenAI compatible, each provider configurable with context window, output limit, jsonMode, search.
• Controllable thinking reasoning intensity: structured extraction defaults to reasoning off, writing turns it on, reasoning_effort configurable as low/high/max. Don't underestimate this — I've genuinely encountered runaway reasoning producing 40,000 characters, blowing past max_tokens; now there's a fallback to retry without thinking.
• Context budget: if over budget, first ask the model to summarize old messages (without adding new facts); if still over, drop the oldest unprotected messages, never silently truncate.
• Audit: every call (including failures) writes to model_calls, with a separate reasoning_tokens column, making reasoning overhead clear at a glance.

🚀 Background Tasks: Concurrency Isn't for Show

AI tasks use fine-grained concurrency: candidate-level tasks run in parallel per candidate, batch-level tasks are mutually exclusive within the same batch, with a global concurrency limit + FIFO queue. You can generate two graphic cards simultaneously; tagging and graphics don't block each other. Tasks exceeding the limit queue up (status shows "queued"), no longer waiting on each other.

🔐 Privacy & Security: Default Is No Internet

• Listens only on loopback address, x-admin-confirm is just an anti-misclick gate, not authentication — the project explicitly does not support public network deployment, threat modeling is documented (docs/threat-model.md).
• No telemetry, open source won't secretly report either.
• Sensitive files (.env, account persona) are not committed to Git, with pre-commit secret scanning hooks + CI scanning.

🚀 Getting Started: Three Steps + A Demo Mode

# 1. Install
setup-workbench.cmd

# 2. Start
start-workbench.cmd

# 3. No LLM Key but want to see the effect? Demo mode, zero config
npm start -- --demo

Demo mode writes a completely fictional demo batch (hotspots, topic pool, formatted artifacts) to a separate database, never touching real data — see what the interface looks like first before deciding whether to configure a Key, very thoughtful.

💡 Final Thoughts

The problem this project aims to solve isn't "can AI write," but rather: how can an AI-involved production chain be trustworthy.

Keeping every step local, leaving traces, auditable; making formatting a deterministic render rather than letting the model freewheel; turning editorial decisions from "the model's glib nonsense" into "your explicit statement" — this is what I imagine a content tool should look like.

If you're also creating content for WeChat Official Accounts/Xiaohongshu, or are interested in a "skill-based + plugin-based" local AI runtime, welcome to check out the repository. If you have ideas, feel free to raise an issue; if you find it helpful, a star ⭐ is the greatest support for me.

---

Project Info

• 📦 Repository: github.com/shiker1996/wechat-newsroom-workbench
• 📄 Documentation: docs/ (architecture, data flow, threat modeling, configuration, extension development all included)
• 🪪 License: MIT
• ⚠️ Note: Only supports Windows 10/11; service only listens on local loopback, please do not modify to expose to the public network