@lyhue1991/wxgzh 0.1.0

package/dist/core/cover.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCoverPresets = listCoverPresets;
+exports.createCover = createCover;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const sharp_1 = __importDefault(require("sharp"));
+const BUILTIN_BACKGROUND_DIR = node_path_1.default.resolve(__dirname, '../../assets/backgrounds');
+const FALLBACK_GRADIENT = {
+    start: '#e8f3ef',
+    end: '#c9ded6'
+};
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function escapeAttribute(value) {
+    return escapeXml(value);
+}
+function readFiles(dirPath, pattern) {
+    try {
+        return (0, node_fs_1.readdirSync)(dirPath)
+            .filter((fileName) => pattern.test(fileName))
+            .map((fileName) => node_path_1.default.join(dirPath, fileName))
+            .sort((left, right) => left.localeCompare(right, 'zh-Hans-CN'));
+    }
+    catch {
+        return [];
+    }
+}
+function pickRandom(items) {
+    if (items.length === 0) {
+        return undefined;
+    }
+    return items[Math.floor(Math.random() * items.length)];
+}
+function getBuiltinBackgrounds() {
+    return readFiles(BUILTIN_BACKGROUND_DIR, /\.(jpe?g|png)$/i);
+}
+function buildTitleLines(text, maxLineLength) {
+    const trimmed = text.trim() || '未命名文章';
+    const quoted = trimmed.includes('『') || trimmed.includes('』') ? trimmed : `『${trimmed}』`;
+    if (quoted.includes('\n')) {
+        return quoted.split('\n').map((line) => line.trim()).filter(Boolean);
+    }
+    const chars = [...quoted];
+    const lines = [];
+    for (let index = 0; index < chars.length; index += maxLineLength) {
+        lines.push(chars.slice(index, index + maxLineLength).join(''));
+    }
+    return lines;
+}
+function estimateFontSize(width, lines) {
+    const longestChars = Math.max(...lines.map((line) => [...line].length), 1);
+    const title = Math.max(42, Math.floor(width / (longestChars + 6)));
+    return {
+        title,
+        author: Math.max(20, Math.floor(title / 2)),
+        longestChars
+    };
+}
+function buildGradientBackground(width, height) {
+    const svg = `
+    <svg width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" xmlns="http://www.w3.org/2000/svg">
+      <defs>
+        <linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
+          <stop offset="0%" stop-color="${FALLBACK_GRADIENT.start}" />
+          <stop offset="100%" stop-color="${FALLBACK_GRADIENT.end}" />
+        </linearGradient>
+      </defs>
+      <rect width="${width}" height="${height}" fill="url(#bg)" />
+    </svg>`;
+    return Buffer.from(svg);
+}
+function buildTextSvg(params) {
+    const lines = buildTitleLines(params.title, 10);
+    const sizes = estimateFontSize(params.width, lines);
+    const lineHeight = Math.round(sizes.title * 1.15);
+    const titleBlockHeight = lineHeight * lines.length;
+    const titleTop = Math.round((params.height - titleBlockHeight) / 2);
+    const fontFamily = '"PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif';
+    const titleWidth = sizes.longestChars * sizes.title;
+    const titleRight = Math.round(params.width / 2 + titleWidth / 2);
+    const authorY = titleTop + titleBlockHeight + sizes.author + Math.round(sizes.author * 0.4);
+    const titleText = lines
+        .map((line, index) => {
+        const y = titleTop + sizes.title + index * lineHeight;
+        return `<text x="50%" y="${y}" text-anchor="middle" font-size="${sizes.title}" font-family="${escapeAttribute(fontFamily)}" fill="rgba(0,0,0,0.72)">${escapeXml(line)}</text>`;
+    })
+        .join('');
+    const authorText = params.author.trim()
+        ? `<text x="${titleRight}" y="${authorY}" text-anchor="end" font-size="${sizes.author}" font-family="${escapeAttribute(fontFamily)}" fill="rgba(0,0,0,0.72)">${escapeXml(params.author.trim())}</text>`
+        : '';
+    const svg = `
+    <svg width="${params.width}" height="${params.height}" viewBox="0 0 ${params.width} ${params.height}" xmlns="http://www.w3.org/2000/svg">
+      ${titleText}
+      ${authorText}
+    </svg>`;
+    return Buffer.from(svg);
+}
+function resolveBackgroundPath(backgroundPath, presetName) {
+    if (backgroundPath) {
+        return node_path_1.default.resolve(backgroundPath);
+    }
+    const backgrounds = getBuiltinBackgrounds();
+    if (backgrounds.length === 0) {
+        return undefined;
+    }
+    if (presetName) {
+        const matched = backgrounds.find((filePath) => node_path_1.default.basename(filePath, node_path_1.default.extname(filePath)) === presetName);
+        if (matched) {
+            return matched;
+        }
+    }
+    return pickRandom(backgrounds);
+}
+function listCoverPresets() {
+    const backgrounds = getBuiltinBackgrounds();
+    if (backgrounds.length === 0) {
+        return [];
+    }
+    return backgrounds.map((filePath) => node_path_1.default.basename(filePath, node_path_1.default.extname(filePath)));
+}
+async function createCover(options) {
+    const width = options.width ?? 1000;
+    const height = options.height ?? 700;
+    const author = options.author?.trim() || 'wxgzh';
+    const outputPath = node_path_1.default.resolve(options.outputPath);
+    const backgroundPath = resolveBackgroundPath(options.backgroundPath, options.presetName);
+    const background = backgroundPath
+        ? (0, sharp_1.default)(backgroundPath).resize(width, height, { fit: 'cover' })
+        : (0, sharp_1.default)(buildGradientBackground(width, height));
+    await background
+        .composite([
+        {
+            input: {
+                create: {
+                    width,
+                    height,
+                    channels: 4,
+                    background: { r: 255, g: 255, b: 255, alpha: 0.58 }
+                }
+            }
+        },
+        {
+            input: buildTextSvg({
+                title: options.title,
+                author,
+                width,
+                height
+            })
+        }
+    ])
+        .jpeg({ quality: 92 })
+        .toFile(outputPath);
+    return outputPath;
+}

package/dist/core/fixer.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixHtmlFile = fixHtmlFile;
+const node_path_1 = __importDefault(require("node:path"));
+const cheerio = __importStar(require("cheerio"));
+const converter_1 = require("./converter");
+const fs_1 = require("../utils/fs");
+function isRemoteUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+function toCdnUrl(cdn, source) {
+    const cleanBase = cdn.replace(/\/+$/, '');
+    const fileName = node_path_1.default.basename(source);
+    return `${cleanBase}/${encodeURIComponent(fileName)}`;
+}
+function resolveImageSource(baseDir, source) {
+    if (isRemoteUrl(source) || node_path_1.default.isAbsolute(source)) {
+        return source;
+    }
+    const normalizedSource = (() => {
+        try {
+            return decodeURIComponent(source);
+        }
+        catch {
+            return source;
+        }
+    })();
+    return node_path_1.default.resolve(baseDir, normalizedSource);
+}
+async function fixHtmlFile(articlePath, options) {
+    const html = await (0, fs_1.readTextFile)(articlePath);
+    const metadata = (0, converter_1.readHtmlMetadata)(html);
+    const $ = cheerio.load(html);
+    const sourceBaseDir = metadata.sourceDir ? node_path_1.default.resolve(metadata.sourceDir) : node_path_1.default.dirname(articlePath);
+    $('script,iframe').remove();
+    const images = $('img').toArray();
+    for (const element of images) {
+        const image = $(element);
+        const source = image.attr('src');
+        if (!source) {
+            continue;
+        }
+        if (options.upload && options.wechat && !source.includes('mmbiz.qpic.cn')) {
+            const uploadedUrl = await options.wechat.uploadArticleImage(resolveImageSource(sourceBaseDir, source));
+            image.attr('src', uploadedUrl);
+            image.attr('data-original-src', source);
+        }
+        else if (options.cdn && !isRemoteUrl(source)) {
+            image.attr('src', toCdnUrl(options.cdn, source));
+        }
+        image.attr('style', [
+            'display:block',
+            'max-width:100%',
+            'height:auto',
+            'margin:0 auto',
+            'border-radius:6px'
+        ].join(';'));
+    }
+    await (0, fs_1.writeTextFile)(articlePath, $.html());
+    return { imageCount: images.length };
+}

package/dist/core/parser.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMarkdown = parseMarkdown;
+const gray_matter_1 = __importDefault(require("gray-matter"));
+function extractFirstHeading(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    let inCodeBlock = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        if (line.trim().startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock) {
+            continue;
+        }
+        const match = line.match(/^#\s+(.+)$/);
+        if (!match) {
+            continue;
+        }
+        const nextLines = [...lines.slice(0, index), ...lines.slice(index + 1)];
+        if ((nextLines[index] ?? '').trim() === '') {
+            nextLines.splice(index, 1);
+        }
+        return {
+            title: match[1].trim(),
+            body: nextLines.join('\n')
+        };
+    }
+    return { body: markdown };
+}
+function extractSecondaryHeadings(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const headings = [];
+    let inCodeBlock = false;
+    for (const rawLine of lines) {
+        const line = rawLine ?? '';
+        if (line.trim().startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock) {
+            continue;
+        }
+        const match = line.match(/^##\s+(.+)$/);
+        if (!match) {
+            continue;
+        }
+        const heading = match[1].trim();
+        if (heading) {
+            headings.push(heading);
+        }
+    }
+    return headings;
+}
+function buildDigest(markdown, title) {
+    const headings = extractSecondaryHeadings(markdown);
+    if (headings.length > 0) {
+        return headings.join('；');
+    }
+    if (title?.trim()) {
+        return title.trim();
+    }
+    return '由 wxgzh 自动生成的公众号草稿';
+}
+function normalizeMetadata(data) {
+    const metadata = {};
+    if (typeof data.title === 'string' && data.title.trim()) {
+        metadata.title = data.title.trim();
+    }
+    if (typeof data.author === 'string' && data.author.trim()) {
+        metadata.author = data.author.trim();
+    }
+    if (typeof data.digest === 'string' && data.digest.trim()) {
+        metadata.digest = data.digest.trim();
+    }
+    if (typeof data.theme === 'string' && data.theme.trim()) {
+        metadata.theme = data.theme.trim();
+    }
+    if (typeof data.cover === 'string' && data.cover.trim()) {
+        metadata.cover = data.cover.trim();
+    }
+    if (typeof data.enableComment === 'boolean') {
+        metadata.enableComment = data.enableComment;
+    }
+    return metadata;
+}
+function parseMarkdown(rawMarkdown) {
+    const parsed = (0, gray_matter_1.default)(rawMarkdown);
+    const frontMatter = normalizeMetadata(parsed.data);
+    const extracted = extractFirstHeading(parsed.content.trim());
+    const resolvedTitle = frontMatter.title ?? extracted.title;
+    return {
+        metadata: {
+            ...frontMatter,
+            title: resolvedTitle,
+            digest: frontMatter.digest ?? buildDigest(extracted.body, resolvedTitle)
+        },
+        body: extracted.body,
+        originalBody: parsed.content
+    };
+}

package/dist/core/themes.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAvailableThemes = listAvailableThemes;
+exports.isValidTheme = isValidTheme;
+exports.assertThemeExists = assertThemeExists;
+exports.getDefaultThemeName = getDefaultThemeName;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const DEFAULT_THEME = 'default';
+function getStylesDir() {
+    return node_path_1.default.resolve(__dirname, '../../styles');
+}
+function normalizeThemeName(fileName) {
+    if (!fileName.endsWith('.css')) {
+        return undefined;
+    }
+    const themeName = node_path_1.default.basename(fileName, '.css');
+    if (!themeName || themeName === 'custom') {
+        return undefined;
+    }
+    return themeName;
+}
+function listAvailableThemes() {
+    try {
+        const themes = (0, node_fs_1.readdirSync)(getStylesDir())
+            .map(normalizeThemeName)
+            .filter((themeName) => Boolean(themeName))
+            .sort((left, right) => left.localeCompare(right, 'en'));
+        if (!themes.includes(DEFAULT_THEME)) {
+            return [DEFAULT_THEME, ...themes];
+        }
+        return themes;
+    }
+    catch {
+        return [DEFAULT_THEME];
+    }
+}
+function isValidTheme(theme) {
+    if (!theme) {
+        return false;
+    }
+    return listAvailableThemes().includes(theme.trim());
+}
+function assertThemeExists(theme) {
+    const normalized = theme?.trim();
+    if (!normalized) {
+        throw new Error('主题名不能为空');
+    }
+    if (!isValidTheme(normalized)) {
+        throw new Error(`不支持的主题: ${normalized}。可用主题：${listAvailableThemes().join(', ')}`);
+    }
+    return normalized;
+}
+function getDefaultThemeName() {
+    return DEFAULT_THEME;
+}

package/dist/core/wechat.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WechatClient = void 0;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const tls_1 = require("../utils/tls");
+const CONFIG_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.config', 'wxgzh');
+const http = axios_1.default.create({
+    httpsAgent: (0, tls_1.getHttpsAgent)(),
+    timeout: 30_000
+});
+function tokenCachePath(appid) {
+    return node_path_1.default.join(CONFIG_DIR, `token.${appid}.json`);
+}
+async function pathExists(filePath) {
+    try {
+        await (0, promises_1.access)(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assertWechatResponse(data, fallbackMessage) {
+    if (typeof data.errcode === 'number' && data.errcode !== 0) {
+        throw new Error(`微信接口调用失败: ${data.errmsg ?? fallbackMessage} (${data.errcode})`);
+    }
+}
+function guessContentType(fileName) {
+    const ext = node_path_1.default.extname(fileName).toLowerCase();
+    if (ext === '.png') {
+        return 'image/png';
+    }
+    if (ext === '.gif') {
+        return 'image/gif';
+    }
+    if (ext === '.webp') {
+        return 'image/webp';
+    }
+    return 'image/jpeg';
+}
+class WechatClient {
+    credentials;
+    constructor(credentials) {
+        this.credentials = credentials;
+    }
+    async readTokenCache() {
+        const cachePath = tokenCachePath(this.credentials.appid);
+        if (!(await pathExists(cachePath))) {
+            return null;
+        }
+        const raw = await (0, promises_1.readFile)(cachePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    async writeTokenCache(cache) {
+        await (0, promises_1.mkdir)(CONFIG_DIR, { recursive: true });
+        await (0, promises_1.writeFile)(tokenCachePath(this.credentials.appid), `${JSON.stringify(cache, null, 2)}\n`, 'utf8');
+    }
+    async getAccessToken(forceRefresh = false) {
+        if (!forceRefresh) {
+            const cached = await this.readTokenCache();
+            if (cached && cached.expires_at > Date.now() + 60_000) {
+                return cached.access_token;
+            }
+        }
+        const response = await http.get('https://api.weixin.qq.com/cgi-bin/token', {
+            params: {
+                grant_type: 'client_credential',
+                appid: this.credentials.appid,
+                secret: this.credentials.appsecret
+            }
+        });
+        const data = response.data;
+        assertWechatResponse(data, '获取 access_token 失败');
+        const accessToken = String(data.access_token);
+        const expiresIn = Number(data.expires_in ?? 7200);
+        await this.writeTokenCache({
+            access_token: accessToken,
+            expires_at: Date.now() + Math.max(expiresIn - 300, 60) * 1000
+        });
+        return accessToken;
+    }
+    async buildImageForm(source) {
+        const form = new form_data_1.default();
+        if (/^https?:\/\//i.test(source)) {
+            const response = await http.get(source, { responseType: 'arraybuffer' });
+            const fileName = node_path_1.default.basename(new URL(source).pathname || 'image.jpg') || 'image.jpg';
+            form.append('media', Buffer.from(response.data), {
+                filename: fileName,
+                contentType: response.headers['content-type'] ?? guessContentType(fileName)
+            });
+            return form;
+        }
+        const absolutePath = node_path_1.default.resolve(source);
+        form.append('media', (0, node_fs_1.createReadStream)(absolutePath), {
+            filename: node_path_1.default.basename(absolutePath),
+            contentType: guessContentType(absolutePath)
+        });
+        return form;
+    }
+    async uploadArticleImage(source) {
+        const accessToken = await this.getAccessToken();
+        const form = await this.buildImageForm(source);
+        const response = await http.post('https://api.weixin.qq.com/cgi-bin/media/uploadimg', form, {
+            params: { access_token: accessToken },
+            headers: form.getHeaders()
+        });
+        const data = response.data;
+        assertWechatResponse(data, '上传正文图片失败');
+        if (!data.url) {
+            throw new Error('微信未返回正文图片地址');
+        }
+        return String(data.url).split('?')[0] ?? String(data.url);
+    }
+    async uploadCoverImage(source) {
+        const accessToken = await this.getAccessToken();
+        const form = await this.buildImageForm(source);
+        const response = await http.post('https://api.weixin.qq.com/cgi-bin/material/add_material', form, {
+            params: { access_token: accessToken, type: 'thumb' },
+            headers: form.getHeaders()
+        });
+        const data = response.data;
+        assertWechatResponse(data, '上传封面失败');
+        if (!data.media_id) {
+            throw new Error('微信未返回封面 media_id');
+        }
+        return {
+            mediaId: String(data.media_id),
+            url: typeof data.url === 'string' ? String(data.url).split('?')[0] : undefined
+        };
+    }
+    async createDraft(payload) {
+        const accessToken = await this.getAccessToken();
+        const response = await http.post('https://api.weixin.qq.com/cgi-bin/draft/add', {
+            articles: [
+                {
+                    title: payload.title,
+                    author: payload.author,
+                    digest: payload.digest,
+                    content: payload.content,
+                    thumb_media_id: payload.thumbMediaId,
+                    need_open_comment: payload.enableComment ? 1 : 0,
+                    only_fans_can_comment: 0
+                }
+            ]
+        }, {
+            params: { access_token: accessToken },
+            headers: { 'Content-Type': 'application/json; charset=utf-8' }
+        });
+        const data = response.data;
+        assertWechatResponse(data, '创建草稿失败');
+        return data;
+    }
+}
+exports.WechatClient = WechatClient;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/config.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserConfigPath = getUserConfigPath;
+exports.loadConfig = loadConfig;
+exports.saveUserConfig = saveUserConfig;
+exports.clearUserConfig = clearUserConfig;
+exports.maskSecret = maskSecret;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const themes_1 = require("../core/themes");
+const CONFIG_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.config', 'wxgzh');
+const USER_CONFIG_PATH = node_path_1.default.join(CONFIG_DIR, 'wxgzh.json');
+function getUserConfigPath() {
+    return USER_CONFIG_PATH;
+}
+async function pathExists(filePath) {
+    try {
+        await (0, promises_1.access)(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(filePath) {
+    if (!(await pathExists(filePath))) {
+        return {};
+    }
+    const raw = await (0, promises_1.readFile)(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+function sanitizeConfig(input) {
+    const output = {};
+    if (typeof input.appid === 'string' && input.appid.trim()) {
+        output.appid = input.appid.trim();
+    }
+    if (typeof input.appsecret === 'string' && input.appsecret.trim()) {
+        output.appsecret = input.appsecret.trim();
+    }
+    if (typeof input.author === 'string' && input.author.trim()) {
+        output.author = input.author.trim();
+    }
+    if (typeof input.defaultTheme === 'string' && input.defaultTheme.trim()) {
+        output.defaultTheme = (0, themes_1.assertThemeExists)(input.defaultTheme.trim());
+    }
+    if (typeof input.enableComment === 'boolean') {
+        output.enableComment = input.enableComment;
+    }
+    return output;
+}
+function envConfig() {
+    return sanitizeConfig({
+        appid: process.env.WX_APPID,
+        appsecret: process.env.WX_APPSECRET
+    });
+}
+async function loadConfig() {
+    const env = envConfig();
+    const user = sanitizeConfig(await readJson(getUserConfigPath()));
+    return {
+        ...env,
+        ...user
+    };
+}
+async function saveUserConfig(patch) {
+    await (0, promises_1.mkdir)(CONFIG_DIR, { recursive: true });
+    const current = sanitizeConfig(await readJson(getUserConfigPath()));
+    const next = sanitizeConfig({ ...current, ...patch });
+    await (0, promises_1.writeFile)(getUserConfigPath(), `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+    return next;
+}
+async function clearUserConfig() {
+    if (await pathExists(getUserConfigPath())) {
+        await (0, promises_1.rm)(getUserConfigPath(), { force: true });
+    }
+}
+function maskSecret(secret) {
+    if (!secret) {
+        return undefined;
+    }
+    if (secret.length <= 8) {
+        return '*'.repeat(secret.length);
+    }
+    return `${secret.slice(0, 4)}${'*'.repeat(secret.length - 8)}${secret.slice(-4)}`;
+}