@rongyan/wxpost-cli 0.1.0

package/README.md

@@ -0,0 +1,178 @@
+# @rongyan/wxpost-cli
+
+微信公众号草稿发布命令行客户端。将本地 Markdown 文件转换为微信富文本，自动上传图片，创建/查看/发布草稿。
+
+## 要求
+
+- Node.js >= 18
+- 运行中的 [wxpost-server](https://github.com/rongyan6/wxpost-server) 实例
+
+## 安装
+
+```bash
+npm install -g @rongyan/wxpost-cli
+```
+
+或通过 npx 直接运行（无需安装）：
+
+```bash
+npx @rongyan/wxpost-cli add_draft article.md
+```
+
+## 配置
+
+首次运行时自动在 `~/.@rongyan/env-cli.json` 创建配置模板并退出。编辑后重新运行即可。
+
+```json
+{
+  "server_url": "http://localhost:3000",
+  "api_key": "your-api-key",
+  "need_open_comment": 1,
+  "only_fans_can_comment": 0,
+  "mdflow": {
+    "primary_color": null,
+    "heading_2": null,
+    "asset_dir": null
+  }
+}
+```
+
+| 字段 | 说明 | 默认值 |
+|------|------|--------|
+| `server_url` | wxpost-server 地址 | `http://localhost:3000` |
+| `api_key` | 与 wxpost-server 一致的鉴权密钥 | — |
+| `need_open_comment` | 草稿是否开启评论（0/1） | `1` |
+| `only_fans_can_comment` | 是否仅粉丝可评论（0/1） | `0` |
+| `mdflow.primary_color` | 文章主题色，`null` 则每次随机 | `null` |
+| `mdflow.heading_2` | 二级标题样式，`null` 则每次随机 | `null` |
+| `mdflow.asset_dir` | Mermaid 图表 PNG 输出目录（可选） | — |
+
+### mdflow 可选值
+
+**primary_color**：`blue` `green` `orange` `yellow` `purple` `sky` `rosegold` `olive` `black` `gray` `pink`
+
+**heading_2**：`default` `color` `bottom` `left`
+
+## 命令
+
+### add_draft — 创建草稿
+
+```bash
+wxpost add_draft <file.md> [--account <appid>]
+```
+
+从 Markdown 文件创建草稿。文章类型由 front matter 中的 `article_type` 字段决定，默认为 `news`（图文消息）。
+
+#### 图文消息（news）
+
+```markdown
+---
+title: 文章标题（最多 32 字，必填）
+author: 作者名（可选）
+digest: 自定义摘要（可选，不填则自动截取正文前 100 字）
+cover: ./images/cover.jpg
+---
+
+正文内容，支持标准 Markdown 语法...
+```
+
+| front matter 字段 | 说明 |
+|---|---|
+| `title` | 文章标题，必填，最多 32 字 |
+| `cover` | 封面图本地路径（相对于 .md 文件），必填 |
+| `author` | 作者，可选 |
+| `digest` | 摘要，可选，超出 128 字由服务端截断 |
+
+封面图会自动上传为永久素材；正文中引用的本地图片会自动上传为内容图并替换 URL。
+
+#### 图片消息（newspic）
+
+```markdown
+---
+title: 相册标题（必填）
+article_type: newspic
+image_list:
+  - ./photos/01.jpg
+  - ./photos/02.jpg
+  - ./photos/03.png
+---
+
+可选的图片说明文字（仅支持纯文本，不支持 Markdown 语法）
+```
+
+| front matter 字段 | 说明 |
+|---|---|
+| `title` | 标题，必填，最多 32 字 |
+| `article_type` | 固定填 `newspic` |
+| `image_list` | 本地图片路径列表（相对于 .md 文件），1-20 张，必填 |
+
+`image_list` 中的图片全部上传为永久素材；第一张自动作为封面。
+
+#### 图片处理
+
+所有图片均通过文件头（magic bytes）校验格式，扩展名与内容不符会报错。
+
+| 用途 | 支持格式 | 大小限制 | 超限处理 |
+|---|---|---|---|
+| 封面图（news cover） | JPG / PNG / BMP / GIF | 10MB | JPG/PNG 自动无损压缩；BMP/GIF 超限直接报错 |
+| 图片消息图片（newspic image_list） | JPG / PNG / BMP / GIF | 10MB | 同上 |
+| 正文内联图（news 正文 img 标签） | JPG / PNG | 1MB | 自动无损压缩；压缩后仍超则报错 |
+
+路径均相对于 Markdown 文件所在目录解析。
+
+### list_draft — 草稿列表
+
+```bash
+wxpost list_draft [--offset <n>] [--count <n>] [--account <appid>]
+```
+
+| 选项 | 说明 | 默认 |
+|---|---|---|
+| `--offset` | 起始偏移 | `0` |
+| `--count` | 返回数量，最大 20 | `20` |
+| `--account` | 指定公众号 AppID | 配置中的默认账号 |
+
+输出示例：
+
+```
+草稿总数: 12  本次返回: 3
+
+[1] 我的第一篇文章
+    media_id:   xxx
+    更新时间:   2026/3/28 10:30:00
+
+[2] 相册：春日出行
+    media_id:   yyy
+    更新时间:   2026/3/27 09:00:00
+```
+
+### publish — 发布草稿
+
+```bash
+wxpost publish <media_id> [--account <appid>]
+```
+
+将草稿正式发布为群发消息。
+
+## 多账号
+
+所有命令均支持 `--account <appid>` 指定公众号账号，不传则使用 wxpost-server 配置中的 `defaultAccount`。
+
+## 完整示例
+
+```bash
+# 创建图文草稿
+wxpost add_draft article.md
+
+# 创建并指定账号
+wxpost add_draft article.md --account wx84671d15576a9880
+
+# 查看草稿列表
+wxpost list_draft
+
+# 翻页
+wxpost list_draft --offset 20 --count 10
+
+# 发布
+wxpost publish <media_id>
+```

package/bin/wxpost-cli.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const cmdAddDraft = require('../src/commands/add-draft');
+const cmdListDraft = require('../src/commands/list-draft');
+const cmdPublish = require('../src/commands/publish');
+
+const HELP = `
+熔岩微信公众号发布客户端
+
+用法:
+  wxpost <命令> [参数] [选项]
+
+命令:
+  add_draft <file.md>      从 Markdown 文件创建草稿
+  list_draft               获取草稿列表
+  publish <media_id>       发布草稿
+
+add_draft 选项:
+  --account <appid>        指定公众号账号（默认使用配置中的 defaultAccount）
+
+  Markdown 文件需包含 front matter，图文消息（news）示例：
+
+    ---
+    title: 文章标题
+    author: 作者名
+    digest: 自定义摘要（可选，不填则自动截取正文前 100 字）
+    cover: ./images/cover.jpg
+    ---
+    正文内容...
+
+  图片消息（newspic）示例：
+
+    ---
+    title: 相册标题
+    article_type: newspic
+    image_list:
+      - ./photos/01.jpg
+      - ./photos/02.jpg
+    ---
+    图片说明文字...
+
+list_draft 选项:
+  --offset <n>             起始偏移，默认 0
+  --count <n>              返回数量 1-20，默认 20
+  --account <appid>        指定公众号账号
+
+publish 选项:
+  --account <appid>        指定公众号账号
+
+配置文件: ~/.@rongyan/env-cli.json
+  server_url               wxpost-server 地址，默认 http://localhost:3000
+  api_key                  API Key（与 wxpost-server 配置一致）
+  need_open_comment        是否开启评论，默认 1
+  only_fans_can_comment    仅粉丝可评论，默认 0
+  mdflow.primary_color     主题色（留 null 每次随机）
+  mdflow.heading_2         二级标题样式（留 null 每次随机）
+  mdflow.asset_dir         Mermaid PNG 输出目录（可选）
+
+示例:
+  wxpost add_draft article.md
+  wxpost add_draft article.md --account wx84671d15576a9880
+  wxpost list_draft
+  wxpost list_draft --offset 20 --count 10
+  wxpost publish <media_id>
+`;
+
+function parseArgs(argv) {
+  const args = [];
+  const opts = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith('--')) {
+        // camelCase 转换：--thumb-media-id => thumbMediaId
+        const camel = key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+        opts[camel] = next;
+        i++;
+      } else {
+        opts[key] = true;
+      }
+    } else {
+      args.push(a);
+    }
+  }
+  return { args, opts };
+}
+
+async function main() {
+  const { args, opts } = parseArgs(process.argv.slice(2));
+  const cmd = args[0];
+
+  if (!cmd || cmd === '--help' || cmd === '-h' || cmd === 'help') {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  if (cmd === 'add_draft') {
+    const file = args[1];
+    if (!file) {
+      console.error('用法: wxpost add_draft <file.md>');
+      process.exit(1);
+    }
+    await cmdAddDraft(file, opts);
+  } else if (cmd === 'list_draft') {
+    await cmdListDraft(opts);
+  } else if (cmd === 'publish') {
+    const mediaId = args[1];
+    await cmdPublish(mediaId, opts);
+  } else {
+    console.error(`未知命令: ${cmd}\n运行 wxpost --help 查看帮助`);
+    process.exit(1);
+  }
+}
+
+main().catch((e) => {
+  console.error(`意外错误: ${e.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@rongyan/wxpost-cli",
+  "version": "0.1.0",
+  "description": "熔岩微信公众号发布客户端",
+  "bin": {
+    "wxpost": "./bin/wxpost-cli.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "start": "node bin/wxpost-cli.js"
+  },
+  "keywords": [
+    "wechat",
+    "wxpost",
+    "cli",
+    "weixin",
+    "markdown",
+    "publish"
+  ],
+  "author": "rongyan",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rongyan6/wxpost-cli.git"
+  },
+  "homepage": "https://github.com/rongyan6/wxpost-cli#readme",
+  "bugs": {
+    "url": "https://github.com/rongyan6/wxpost-cli/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@rongyan/mdflow-cli": "^0.1.3",
+    "imagemin": "^9.0.1",
+    "imagemin-jpegtran": "^8.0.0",
+    "imagemin-optipng": "^8.0.0"
+  }
+}

package/src/api.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const { getCliConfig } = require('./config');
+
+function request(pathname, body) {
+  const { serverUrl, apiKey } = getCliConfig();
+  const url = new URL(pathname, serverUrl);
+  const isHttps = url.protocol === 'https:';
+  const driver = isHttps ? https : http;
+
+  const payload = JSON.stringify(body);
+
+  return new Promise((resolve, reject) => {
+    const req = driver.request(
+      url,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json; charset=utf-8',
+          'Content-Length': Buffer.byteLength(payload),
+          'Authorization': `Bearer ${apiKey}`,
+        },
+      },
+      (res) => {
+        let raw = '';
+        res.on('data', (chunk) => { raw += chunk; });
+        res.on('end', () => {
+          let data;
+          try {
+            data = JSON.parse(raw);
+          } catch {
+            return reject(new Error(`服务器响应解析失败: ${raw}`));
+          }
+          if (!data.ok) {
+            return reject(new Error(data.error || '请求失败'));
+          }
+          resolve(data);
+        });
+      }
+    );
+    req.on('error', (e) => reject(new Error(`连接服务器失败: ${e.message}`)));
+    req.write(payload);
+    req.end();
+  });
+}
+
+/**
+ * 上传本地图片为永久素材，返回 { media_id, url }。
+ * @param {Buffer} buffer
+ * @param {string} filename
+ * @param {string|null} appid
+ */
+function uploadMaterial(buffer, filename, appid) {
+  const { serverUrl, apiKey } = getCliConfig();
+  const qs = appid ? `?appid=${appid}` : '';
+  const url = new URL(`/upload-material${qs}`, serverUrl);
+  const isHttps = url.protocol === 'https:';
+  const driver = isHttps ? https : http;
+
+  const boundary = `----CliUploadBoundary${Date.now()}`;
+  const ext = filename.split('.').pop().toLowerCase();
+  const mimeTypes = { png: 'image/png', gif: 'image/gif', bmp: 'image/bmp', jpg: 'image/jpeg', jpeg: 'image/jpeg' };
+  const mimeType = mimeTypes[ext] || 'image/jpeg';
+  const safeFilename = filename.split(/[\\/]/).pop() || 'image';
+
+  const head = Buffer.from(
+    `--${boundary}\r\n` +
+    `Content-Disposition: form-data; name="media"; filename="${safeFilename}"\r\n` +
+    `Content-Type: ${mimeType}\r\n\r\n`
+  );
+  const tail = Buffer.from(`\r\n--${boundary}--\r\n`);
+  const body = Buffer.concat([head, buffer, tail]);
+
+  return new Promise((resolve, reject) => {
+    const req = driver.request(
+      url,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': `multipart/form-data; boundary=${boundary}`,
+          'Content-Length': body.length,
+          'Authorization': `Bearer ${apiKey}`,
+        },
+      },
+      (res) => {
+        let raw = '';
+        res.on('data', (chunk) => { raw += chunk; });
+        res.on('end', () => {
+          let data;
+          try {
+            data = JSON.parse(raw);
+          } catch {
+            return reject(new Error(`服务器响应解析失败: ${raw}`));
+          }
+          if (!data.ok) return reject(new Error(data.error || '上传失败'));
+          resolve(data);
+        });
+      }
+    );
+    req.on('error', (e) => reject(new Error(`连接服务器失败: ${e.message}`)));
+    req.write(body);
+    req.end();
+  });
+}
+
+/**
+ * 上传内容图（用于图文正文），返回微信 CDN url。
+ * @param {Buffer} buffer
+ * @param {string} filename
+ * @param {string|null} appid
+ */
+function uploadContentImage(buffer, filename, appid) {
+  const { serverUrl, apiKey } = getCliConfig();
+  const qs = appid ? `?appid=${appid}` : '';
+  const url = new URL(`/upload-image${qs}`, serverUrl);
+  const isHttps = url.protocol === 'https:';
+  const driver = isHttps ? https : http;
+
+  const boundary = `----CliUploadBoundary${Date.now()}`;
+  const ext = filename.split('.').pop().toLowerCase();
+  const mimeType = ext === 'png' ? 'image/png' : 'image/jpeg';
+  const safeFilename = filename.split(/[\\/]/).pop() || 'image';
+
+  const head = Buffer.from(
+    `--${boundary}\r\n` +
+    `Content-Disposition: form-data; name="media"; filename="${safeFilename}"\r\n` +
+    `Content-Type: ${mimeType}\r\n\r\n`
+  );
+  const tail = Buffer.from(`\r\n--${boundary}--\r\n`);
+  const body = Buffer.concat([head, buffer, tail]);
+
+  return new Promise((resolve, reject) => {
+    const req = driver.request(
+      url,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': `multipart/form-data; boundary=${boundary}`,
+          'Content-Length': body.length,
+          'Authorization': `Bearer ${apiKey}`,
+        },
+      },
+      (res) => {
+        let raw = '';
+        res.on('data', (chunk) => { raw += chunk; });
+        res.on('end', () => {
+          let data;
+          try {
+            data = JSON.parse(raw);
+          } catch {
+            return reject(new Error(`服务器响应解析失败: ${raw}`));
+          }
+          if (!data.ok) return reject(new Error(data.error || '上传失败'));
+          resolve(data.url);
+        });
+      }
+    );
+    req.on('error', (e) => reject(new Error(`连接服务器失败: ${e.message}`)));
+    req.write(body);
+    req.end();
+  });
+}
+
+function addDraft(articles, appid) {
+  const path = appid ? `/draft/add?appid=${appid}` : '/draft/add';
+  return request(path, { articles });
+}
+
+function listDraft({ offset = 0, count = 20, no_content = 0 } = {}, appid) {
+  const path = appid ? `/draft/list?appid=${appid}` : '/draft/list';
+  return request(path, { offset, count, no_content });
+}
+
+function publishDraft(mediaId, appid) {
+  const path = appid ? `/draft/publish?appid=${appid}` : '/draft/publish';
+  return request(path, { media_id: mediaId });
+}
+
+module.exports = { uploadMaterial, uploadContentImage, addDraft, listDraft, publishDraft };

package/src/commands/add-draft.js

@@ -0,0 +1,393 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { uploadMaterial, uploadContentImage, addDraft } = require('../api');
+const { getMdflowConfig, loadConfig } = require('../config');
+
+// ── mdflow 配置 ───────────────────────────────────────────────────────────────
+
+const PRIMARY_COLORS = ['blue', 'green', 'orange', 'yellow', 'purple', 'sky', 'rosegold', 'olive', 'black', 'gray', 'pink'];
+const HEADING_STYLES = ['default', 'color', 'bottom', 'left'];
+
+function pickRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function buildMdflowOptions(cfg) {
+  const opts = {
+    theme: 'default',
+    fontFamily: 'serif',
+    fontSize: '推荐',
+    primaryColor: cfg.primary_color || pickRandom(PRIMARY_COLORS),
+    heading1: 'default',
+    heading2: cfg.heading_2 || pickRandom(HEADING_STYLES),
+    heading3: 'default',
+    codeTheme: 'github-dark',
+    legend: 'none',
+    macCodeBlock: true,
+    codeLineNumbers: false,
+    citeStatus: false,
+    useIndent: false,
+    useJustify: false,
+  };
+  if (cfg.asset_dir) opts.assetDir = cfg.asset_dir;
+  return opts;
+}
+
+// ── 图片校验 & 压缩 ──────────────────────────────────────────────────────────
+
+// 内容图（正文内联）：仅支持 JPG/PNG，上限 1MB
+const CONTENT_IMAGE_EXTS = new Set(['.jpg', '.jpeg', '.png']);
+const CONTENT_IMAGE_LIMIT = 1 * 1024 * 1024;
+
+// 永久素材（封面图 / newspic 图片列表）：支持 JPG/PNG/BMP/GIF，上限 10MB
+const MATERIAL_IMAGE_EXTS = new Set(['.jpg', '.jpeg', '.png', '.bmp', '.gif']);
+const MATERIAL_IMAGE_LIMIT = 10 * 1024 * 1024;
+
+// BMP/GIF 没有可用的无损压缩器，超限时直接报错
+const COMPRESSIBLE_EXTS = new Set(['.jpg', '.jpeg', '.png']);
+
+function validateImageFormat(buffer, filename, allowedExts) {
+  const ext = path.extname(filename).toLowerCase();
+  if (!allowedExts.has(ext)) {
+    const list = [...allowedExts].map((e) => e.slice(1).toUpperCase()).join(' / ');
+    throw new Error(`不支持的图片格式 "${ext}"，仅支持 ${list}`);
+  }
+  if (buffer.length < 4) {
+    throw new Error(`"${filename}" 文件内容为空或过短，不是有效的图片`);
+  }
+  if (ext === '.png') {
+    if (buffer[0] !== 0x89 || buffer[1] !== 0x50 || buffer[2] !== 0x4E || buffer[3] !== 0x47) {
+      throw new Error(`"${filename}" 扩展名为 .png 但文件头不是有效的 PNG`);
+    }
+  } else if (ext === '.bmp') {
+    if (buffer[0] !== 0x42 || buffer[1] !== 0x4D) {
+      throw new Error(`"${filename}" 扩展名为 .bmp 但文件头不是有效的 BMP`);
+    }
+  } else if (ext === '.gif') {
+    if (buffer[0] !== 0x47 || buffer[1] !== 0x49 || buffer[2] !== 0x46 || buffer[3] !== 0x38) {
+      throw new Error(`"${filename}" 扩展名为 .gif 但文件头不是有效的 GIF`);
+    }
+  } else {
+    if (buffer[0] !== 0xFF || buffer[1] !== 0xD8 || buffer[2] !== 0xFF) {
+      throw new Error(`"${filename}" 扩展名为 ${ext} 但文件头不是有效的 JPEG`);
+    }
+  }
+}
+
+/**
+ * 校验图片格式，并在超过 sizeLimit 时尝试无损压缩（仅 JPG/PNG 支持）。
+ * BMP/GIF 不可压缩，超限直接报错。
+ * 压缩后若仍超过 hardLimit 则报错。
+ */
+async function maybeCompress(buffer, filename, sizeLimit, hardLimit, allowedExts) {
+  validateImageFormat(buffer, filename, allowedExts);
+  if (buffer.length <= sizeLimit) return buffer;
+
+  const ext = path.extname(filename).toLowerCase();
+
+  if (!COMPRESSIBLE_EXTS.has(ext)) {
+    throw new Error(
+      `"${filename}" 超过限制（${(buffer.length / 1024 / 1024).toFixed(1)}MB / 限 ${(hardLimit / 1024 / 1024).toFixed(0)}MB），${ext.slice(1).toUpperCase()} 格式不支持自动压缩，请手动处理`
+    );
+  }
+
+  const { default: imagemin } = await import('imagemin');
+  let plugin;
+  if (ext === '.png') {
+    const { default: imageminOptipng } = await import('imagemin-optipng');
+    plugin = imageminOptipng();
+  } else {
+    const { default: imageminJpegtran } = await import('imagemin-jpegtran');
+    plugin = imageminJpegtran();
+  }
+  const compressed = Buffer.from(await imagemin.buffer(buffer, { plugins: [plugin] }));
+
+  if (compressed.length >= hardLimit) {
+    throw new Error(
+      `"${filename}" 压缩后仍超过限制（${(compressed.length / 1024 / 1024).toFixed(1)}MB / 限 ${(hardLimit / 1024 / 1024).toFixed(0)}MB）`
+    );
+  }
+  return compressed;
+}
+
+/**
+ * 扫描 wxhtml 中所有本地 <img src> 路径，压缩后上传为内容图，并替换 URL。
+ * @param {string} wxhtml
+ * @param {string} mdDir  Markdown 文件所在目录，用于解析相对路径
+ * @param {string|undefined} appid
+ * @returns {Promise<string>} 替换后的 HTML
+ */
+async function uploadContentImages(wxhtml, mdDir, appid) {
+  const IMG_RE = /(<img\b[^>]*?\ssrc=")([^"]+)(")/gi;
+
+  // 收集所有唯一的本地 src
+  const localSrcs = new Set();
+  for (const m of wxhtml.matchAll(IMG_RE)) {
+    const src = m[2];
+    if (!src.startsWith('http://') && !src.startsWith('https://') && !src.startsWith('data:')) {
+      localSrcs.add(src);
+    }
+  }
+  if (localSrcs.size === 0) return wxhtml;
+
+  // 逐一上传，建立 src → wx_url 映射
+  const urlMap = new Map();
+  for (const src of localSrcs) {
+    const absPath = path.isAbsolute(src) ? src : path.resolve(mdDir, src);
+    if (!fs.existsSync(absPath)) {
+      throw new Error(`内容图不存在: ${absPath}`);
+    }
+    const raw = fs.readFileSync(absPath);
+    const filename = path.basename(absPath);
+
+    let buffer;
+    try {
+      buffer = await maybeCompress(raw, filename, CONTENT_IMAGE_LIMIT, CONTENT_IMAGE_LIMIT, CONTENT_IMAGE_EXTS);
+    } catch (e) {
+      throw new Error(`内容图处理失败 (${filename}): ${e.message}`);
+    }
+    if (buffer.length < raw.length) {
+      process.stdout.write(`  压缩内容图: ${filename} ${(raw.length / 1024).toFixed(0)}KB → ${(buffer.length / 1024).toFixed(0)}KB\n`);
+    }
+
+    process.stdout.write(`  上传内容图: ${filename} ...`);
+    const wxUrl = await uploadContentImage(buffer, filename, appid);
+    process.stdout.write(` ${wxUrl}\n`);
+    urlMap.set(src, wxUrl);
+  }
+
+  // 替换 HTML 中的 src
+  return wxhtml.replace(IMG_RE, (_, pre, src, post) => {
+    return pre + (urlMap.get(src) ?? src) + post;
+  });
+}
+
+// ── Front matter 解析 ────────────────────────────────────────────────────────
+
+/**
+ * 解析 Markdown 文件头部的 YAML front matter。
+ * 支持字符串、数字值；image_list 支持多行列表（- 路径）。
+ * @returns {{ meta: object, body: string }}
+ */
+function parseFrontMatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) return { meta: {}, body: content };
+
+  const rawMeta = match[1];
+  const body = match[2];
+  const meta = {};
+  const lines = rawMeta.split(/\r?\n/);
+
+  // 已知文件扩展名：结尾匹配则视为文件路径，整段原样保留（仅剥离两端引号）
+  const FILE_EXT_RE = /\.(jpe?g|png|gif|bmp|webp|tiff?|avif|heic|mp4|mp3|wav|amr|wma|m4a)$/i;
+
+  const parseVal = (raw) => {
+    const s = raw.trim();
+    if (!s) return null;
+    // 剥离两端匹配的单引号或双引号
+    const unquoted = s.replace(/^(['"])(.*)\1$/, '$2').trim();
+    if (!unquoted) return null;
+    // 以已知文件扩展名结尾 → 文件路径，原样返回（含空格、特殊字符）
+    if (FILE_EXT_RE.test(unquoted)) return unquoted;
+    // 普通值
+    return unquoted;
+  };
+
+  let currentKey = null;
+  for (const line of lines) {
+    // 列表项：  - value（尽可能抓取整行，兼容路径中的空格与特殊字符）
+    const listMatch = line.match(/^\s+-\s+([\s\S]+)$/);
+    if (listMatch && currentKey) {
+      if (!Array.isArray(meta[currentKey])) meta[currentKey] = [];
+      const v = parseVal(listMatch[1]);
+      if (v !== null) meta[currentKey].push(v);
+      continue;
+    }
+    // key: value（value 部分贪婪匹配整行剩余，确保含空格的路径不被截断）
+    const kvMatch = line.match(/^(\w+)\s*:\s*([\s\S]*)$/);
+    if (kvMatch) {
+      currentKey = kvMatch[1];
+      meta[currentKey] = parseVal(kvMatch[2]);
+    }
+  }
+
+  return { meta, body };
+}
+
+// ── 上传封面图，返回 media_id ─────────────────────────────────────────────────
+
+/**
+ * 读取本地图片 → 压缩（如需）→ 上传永久素材，返回 media_id。
+ * @param {string} imagePath  本地路径（绝对路径直接使用；相对路径相对 baseDir 解析）
+ * @param {string} baseDir    Markdown 文件所在目录，用于解析相对路径
+ * @param {string} label      日志前缀，如 "封面图" / "图片[1/3]"
+ * @param {string|undefined} appid
+ */
+async function uploadLocalImageAsMaterial(imagePath, baseDir, label, appid) {
+  const clean = imagePath.trim();
+  const absPath = path.isAbsolute(clean) ? clean : path.resolve(baseDir, clean);
+  if (!fs.existsSync(absPath)) {
+    throw new Error(`${label}不存在: ${absPath}`);
+  }
+  const raw = fs.readFileSync(absPath);
+  const filename = path.basename(absPath);
+
+  let buffer;
+  try {
+    buffer = await maybeCompress(raw, filename, MATERIAL_IMAGE_LIMIT, MATERIAL_IMAGE_LIMIT, MATERIAL_IMAGE_EXTS);
+  } catch (e) {
+    throw new Error(`${label}处理失败: ${e.message}`);
+  }
+  if (buffer.length < raw.length) {
+    process.stdout.write(`  压缩${label}: ${filename} ${(raw.length / 1024).toFixed(0)}KB → ${(buffer.length / 1024).toFixed(0)}KB\n`);
+  }
+
+  process.stdout.write(`  上传${label}: ${filename} ...`);
+  const result = await uploadMaterial(buffer, filename, appid);
+  process.stdout.write(` media_id=${result.media_id}\n`);
+  return result.media_id;
+}
+
+async function renderToWxhtml(body) {
+  const mdflowOpts = buildMdflowOptions(getMdflowConfig());
+  process.stdout.write(`  转换 Markdown → 微信富文本（主题色=${mdflowOpts.primaryColor} 二级标题=${mdflowOpts.heading2}）...`);
+  try {
+    const { renderMarkdown } = await import('@rongyan/mdflow-cli');
+    const rendered = await renderMarkdown(body, mdflowOpts);
+    process.stdout.write(' 完成\n');
+    return rendered.wxhtml;
+  } catch (e) {
+    process.stdout.write('\n');
+    throw new Error(`Markdown 转换失败: ${e.message}`);
+  }
+}
+
+// ── 主命令 ───────────────────────────────────────────────────────────────────
+
+async function cmdAddDraft(filePath, opts = {}) {
+  const absPath = path.resolve(filePath);
+  if (!fs.existsSync(absPath)) {
+    console.error(`文件不存在: ${absPath}`);
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(absPath, 'utf-8');
+  const { meta, body } = parseFrontMatter(content);
+
+  // ── 校验公共必填字段
+  const title = meta.title;
+  if (!title) {
+    console.error('front matter 缺少 title');
+    process.exit(1);
+  }
+  if (title.length > 64) title = title.slice(0, 64);
+
+  const articleType = meta.article_type || 'news';
+  const cfg = loadConfig();
+  let article;
+
+  if (articleType === 'newspic') {
+    // ── 图片消息
+    const imageList = Array.isArray(meta.image_list) ? meta.image_list : [];
+    if (imageList.length === 0) {
+      console.error('newspic 类型 front matter 缺少 image_list');
+      process.exit(1);
+    }
+    if (imageList.length > 20) {
+      console.error(`image_list 最多 20 张，当前 ${imageList.length} 张`);
+      process.exit(1);
+    }
+
+    // 上传每张图片为永久素材 → 收集 media_id
+    const mdDir = path.dirname(absPath);
+    const imageMediaIds = [];
+    for (let i = 0; i < imageList.length; i++) {
+      try {
+        const mediaId = await uploadLocalImageAsMaterial(
+          imageList[i], mdDir, `图片[${i + 1}/${imageList.length}]`, opts.account
+        );
+        imageMediaIds.push(mediaId);
+      } catch (e) {
+        console.error(`图片上传失败: ${e.message}`);
+        process.exit(1);
+      }
+    }
+
+    article = {
+      article_type: 'newspic',
+      title,
+      content: body.trim(),
+      need_open_comment: cfg.need_open_comment ?? 1,
+      only_fans_can_comment: cfg.only_fans_can_comment ?? 0,
+      image_info: {
+        image_list: imageMediaIds.map((id) => ({ image_media_id: id })),
+      },
+    };
+  } else {
+    // ── 图文消息
+    if (!meta.cover) {
+      console.error('front matter 缺少 cover（封面图路径）');
+      process.exit(1);
+    }
+    if (!body.trim()) {
+      console.error('正文内容不能为空');
+      process.exit(1);
+    }
+
+    // 上传封面图 → thumb_media_id
+    let thumbMediaId;
+    try {
+      thumbMediaId = await uploadLocalImageAsMaterial(
+        meta.cover, path.dirname(absPath), '封面图', opts.account
+      );
+    } catch (e) {
+      console.error(`封面图上传失败: ${e.message}`);
+      process.exit(1);
+    }
+
+    // 正文 Markdown → 微信富文本
+    let wxhtml;
+    try {
+      wxhtml = await renderToWxhtml(body);
+    } catch (e) {
+      console.error(e.message);
+      process.exit(1);
+    }
+
+    // 上传正文内联图片
+    try {
+      wxhtml = await uploadContentImages(wxhtml, path.dirname(absPath), opts.account);
+    } catch (e) {
+      console.error(`内容图上传失败: ${e.message}`);
+      process.exit(1);
+    }
+
+    const digest = meta.digest
+      || wxhtml.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim().slice(0, 100);
+
+    article = {
+      article_type: 'news',
+      title,
+      ...(meta.author && { author: meta.author }),
+      digest,
+      content: wxhtml,
+      thumb_media_id: thumbMediaId,
+      need_open_comment: cfg.need_open_comment ?? 1,
+      only_fans_can_comment: cfg.only_fans_can_comment ?? 0,
+    };
+  }
+
+  // ── 创建草稿
+  try {
+    const result = await addDraft([article], opts.account);
+    console.log(`草稿创建成功`);
+    console.log(`media_id: ${result.media_id}`);
+  } catch (e) {
+    console.error(`创建草稿失败: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = cmdAddDraft;

package/src/commands/list-draft.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { listDraft } = require('../api');
+
+async function cmdListDraft(opts = {}) {
+  const offset = parseInt(opts.offset ?? 0, 10);
+  const count = parseInt(opts.count ?? 20, 10);
+
+  try {
+    const result = await listDraft({ offset, count, no_content: 1 }, opts.account);
+    const items = result.item || [];
+
+    console.log(`草稿总数: ${result.total_count}  本次返回: ${result.item_count}`);
+    console.log('');
+
+    if (items.length === 0) {
+      console.log('暂无草稿');
+      return;
+    }
+
+    items.forEach((item, i) => {
+      const articles = item.content?.news_item || [];
+      const first = articles[0] || {};
+      const updateTime = item.update_time
+        ? new Date(item.update_time * 1000).toLocaleString('zh-CN')
+        : '-';
+      const extra = articles.length > 1 ? `  共 ${articles.length} 篇` : '';
+
+      console.log(`[${offset + i + 1}] ${first.title || '(无标题)'}${extra}`);
+      console.log(`    media_id:   ${item.media_id}`);
+      console.log(`    更新时间:   ${updateTime}`);
+      if (first.author) console.log(`    作者:       ${first.author}`);
+      console.log('');
+    });
+  } catch (e) {
+    console.error(`获取草稿列表失败: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = cmdListDraft;

package/src/commands/publish.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { publishDraft } = require('../api');
+
+async function cmdPublish(mediaId, opts = {}) {
+  if (!mediaId) {
+    console.error('请提供草稿的 media_id');
+    process.exit(1);
+  }
+
+  try {
+    const result = await publishDraft(mediaId, opts.account);
+    console.log(`发布成功`);
+    console.log(`publish_id:  ${result.publish_id}`);
+    if (result.msg_data_id) {
+      console.log(`msg_data_id: ${result.msg_data_id}`);
+    }
+  } catch (e) {
+    console.error(`发布失败: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = cmdPublish;

package/src/config.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.@rongyan');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'env-cli.json');
+
+const TEMPLATE = {
+  server_url: 'http://localhost:3000',
+  api_key: '__YOUR_API_KEY__',
+  need_open_comment: 1,
+  only_fans_can_comment: 0,
+  mdflow: {
+    primary_color: null,
+    heading_2: null,
+    asset_dir: null,
+  },
+};
+
+function ensureConfig() {
+  if (fs.existsSync(CONFIG_PATH)) return false;
+
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(TEMPLATE, null, 2) + '\n', 'utf-8');
+  return true;
+}
+
+let _cache = null;
+
+function loadConfig() {
+  if (_cache) return _cache;
+
+  const created = ensureConfig();
+  if (created) {
+    console.error([
+      '',
+      '  配置文件已创建：' + CONFIG_PATH,
+      '  请编辑该文件，填入 wxpost-server 地址和 API Key，然后重新运行。',
+      '',
+      '  格式说明：',
+      '    server_url          — wxpost-server 地址，例如 http://localhost:3000',
+      '    api_key             — 与 wxpost-server 配置中一致的 API Key',
+      '    mdflow.primary_color — 主题色（可选，留 null 则每次随机）',
+      '    mdflow.heading_2     — 二级标题样式（可选，留 null 则每次随机）',
+      '    mdflow.asset_dir     — Mermaid PNG 输出目录（可选）',
+      '',
+    ].join('\n'));
+    process.exit(1);
+  }
+
+  const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
+  try {
+    _cache = JSON.parse(raw);
+  } catch (e) {
+    console.error(`配置文件 JSON 格式错误 (${CONFIG_PATH}): ${e.message}`);
+    process.exit(1);
+  }
+
+  // 补全旧版配置文件缺失的字段
+  let patched = false;
+  if (_cache.need_open_comment === undefined) { _cache.need_open_comment = TEMPLATE.need_open_comment; patched = true; }
+  if (_cache.only_fans_can_comment === undefined) { _cache.only_fans_can_comment = TEMPLATE.only_fans_can_comment; patched = true; }
+  if (!_cache.mdflow) { _cache.mdflow = { ...TEMPLATE.mdflow }; patched = true; }
+  if (patched) fs.writeFileSync(CONFIG_PATH, JSON.stringify(_cache, null, 2) + '\n', 'utf-8');
+
+  return _cache;
+}
+
+function getCliConfig() {
+  const config = loadConfig();
+  const serverUrl = (config.server_url || 'http://localhost:3000').replace(/\/$/, '');
+  const apiKey = config.api_key || '';
+
+  if (!apiKey || apiKey === '__YOUR_API_KEY__') {
+    console.error([
+      '',
+      '  API Key 未配置。',
+      `  请编辑 ${CONFIG_PATH}，将 api_key 替换为真实值。`,
+      '',
+    ].join('\n'));
+    process.exit(1);
+  }
+
+  return { serverUrl, apiKey };
+}
+
+function getMdflowConfig() {
+  return loadConfig().mdflow || {};
+}
+
+module.exports = { loadConfig, getCliConfig, getMdflowConfig, CONFIG_PATH };