@wenyan-md/core 2.0.8 → 3.0.0

package/dist/publish.js

@@ -1,222 +1,37 @@
-import { JSDOM } from "jsdom";
-import { fileFromPath } from "formdata-node/file-from-path";
-import path from "node:path";
-import fs, { stat } from "node:fs/promises";
-import crypto from "node:crypto";
 import { createWechatClient } from "./wechat.js";
-import { FormDataEncoder } from "form-data-encoder";
-import { FormData } from "formdata-node";
-import { Readable } from "node:stream";
-import os from "node:os";
-async function readFileContent(filePath) {
-  return await fs.readFile(filePath, "utf-8");
-}
-async function readBinaryFile(filePath) {
-  return await fs.readFile(filePath);
-}
-async function safeReadJson(file, fallback) {
-  try {
-    const content = await fs.readFile(file, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return fallback;
-  }
-}
-async function safeWriteJson(file, data) {
-  const tmp = file + ".tmp";
-  await fs.writeFile(tmp, JSON.stringify(data ?? {}, null, 2), "utf-8");
-  await fs.rename(tmp, file);
-}
-async function ensureDir(dir) {
-  await fs.mkdir(dir, { recursive: true });
-}
-function md5FromBuffer(buf) {
-  return crypto.createHash("md5").update(buf).digest("hex");
-}
-async function md5FromFile(filePath) {
-  const buf = await fs.readFile(filePath);
-  return md5FromBuffer(buf);
-}
-function normalizePath(p) {
-  return p.replace(/\\/g, "/").replace(/\/+$/, "");
-}
-function isAbsolutePath(path2) {
-  if (!path2) return false;
-  const winAbsPattern = /^[a-zA-Z]:\//;
-  const linuxAbsPattern = /^\//;
-  return winAbsPattern.test(path2) || linuxAbsPattern.test(path2);
-}
-function getNormalizeFilePath(inputPath) {
-  const isContainer = !!process.env.CONTAINERIZED;
-  const hostFilePath = normalizePath(process.env.HOST_FILE_PATH || "");
-  if (isContainer && hostFilePath) {
-    const containerFilePath = normalizePath(process.env.CONTAINER_FILE_PATH || "/mnt/host-downloads");
-    let relativePart = normalizePath(inputPath);
-    if (relativePart.startsWith(hostFilePath)) {
-      relativePart = relativePart.slice(hostFilePath.length);
-    }
-    if (!relativePart.startsWith("/")) {
-      relativePart = "/" + relativePart;
-    }
-    return containerFilePath + relativePart;
-  } else {
-    return path.resolve(inputPath);
-  }
-}
-const RuntimeEnv = {
-  isContainer: !!process.env.CONTAINERIZED,
-  hostFilePath: normalizePath(process.env.HOST_FILE_PATH || ""),
-  containerFilePath: normalizePath(process.env.CONTAINER_FILE_PATH || "/mnt/host-downloads"),
-  resolveLocalPath(inputPath, relativeBase) {
-    if (!this.isContainer) {
-      if (relativeBase) {
-        return path.resolve(relativeBase, inputPath);
-      } else {
-        if (!path.isAbsolute(inputPath)) {
-          throw new Error(
-            `Invalid input: '${inputPath}'. InputPath must be an absolute path.`
-          );
-        }
-        return path.normalize(inputPath);
-      }
-    }
-    let normalizedInput = normalizePath(inputPath);
-    relativeBase = normalizePath(relativeBase || "");
-    if (relativeBase) {
-      if (!isAbsolutePath(normalizedInput)) {
-        normalizedInput = relativeBase + (normalizedInput.startsWith("/") ? "" : "/") + normalizedInput;
-      }
-    } else {
-      if (!isAbsolutePath(normalizedInput)) {
-        throw new Error(
-          `Invalid input: '${inputPath}'. InputPath must be an absolute path.`
-        );
-      }
-    }
-    if (this.hostFilePath && normalizedInput.startsWith(this.hostFilePath)) {
-      let relativePart = normalizedInput.slice(this.hostFilePath.length);
-      if (relativePart && !relativePart.startsWith("/")) {
-        return normalizedInput;
-      }
-      if (!relativePart.startsWith("/")) {
-        relativePart = "/" + relativePart;
-      }
-      return this.containerFilePath + relativePart;
-    }
-    return normalizedInput;
-  }
-};
-const nodeHttpAdapter = {
-  fetch,
-  createMultipart(field, file, filename) {
-    const form = new FormData();
-    form.append(field, file, filename);
-    const encoder = new FormDataEncoder(form);
-    return {
-      body: Readable.from(encoder),
-      headers: encoder.headers,
-      duplex: "half"
-    };
-  }
-};
-const defaultConfig = {};
-const configDir = process.env.APPDATA ? path.join(process.env.APPDATA, "wenyan-md") : path.join(os.homedir(), ".config", "wenyan-md");
-const configPath = path.join(configDir, "config.json");
-class ConfigStore {
-  config = { ...defaultConfig };
-  initPromise;
-  constructor() {
-    this.initPromise = this.load();
-  }
-  async load() {
-    await ensureDir(configDir);
-    this.config = await safeReadJson(configPath, defaultConfig);
-  }
-  async save() {
-    try {
-      await ensureDir(configDir);
-      await safeWriteJson(configPath, this.config);
-    } catch (error) {
-      throw new Error(`无法保存配置文件: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async getConfig() {
-    await this.initPromise;
-    return this.config;
-  }
-  async getThemes() {
-    await this.initPromise;
-    return Object.values(this.config.themes ?? {});
-  }
-  async getThemeById(themeId) {
-    await this.initPromise;
-    const themeOption = this.config.themes?.[themeId];
-    if (!themeOption) return void 0;
-    const absoluteFilePath = path.join(configDir, themeOption.path);
-    try {
-      return await fs.readFile(absoluteFilePath, "utf-8");
-    } catch {
-      return void 0;
-    }
-  }
-  async addThemeToConfig(name, content) {
-    await this.initPromise;
-    const savedPath = await this.addThemeFile(name, content);
-    this.config.themes ??= {};
-    this.config.themes[name] = {
-      id: name,
-      name,
-      path: savedPath
-    };
-    await this.save();
-  }
-  async addThemeFile(themeId, themeContent) {
-    const filePath = `themes/${themeId}.css`;
-    const absoluteFilePath = path.join(configDir, filePath);
-    await ensureDir(path.dirname(absoluteFilePath));
-    await fs.writeFile(absoluteFilePath, themeContent, "utf-8");
-    return filePath;
-  }
-  async deleteThemeFromConfig(themeId) {
-    await this.initPromise;
-    const theme = this.config.themes?.[themeId];
-    if (!theme) return;
-    await this.deleteThemeFile(theme.path);
-    delete this.config.themes[themeId];
-    await this.save();
-  }
-  async deleteThemeFile(filePath) {
-    try {
-      await fs.unlink(path.join(configDir, filePath));
-    } catch {
-    }
-  }
-}
-const configStore = new ConfigStore();
-const tokenPath = path.join(configDir, "token.json");
-const defaultCache = {
+const defaultTokenCache = {
   appid: "",
   accessToken: "",
   expireAt: 0
 };
 class TokenStore {
-  cache = { ...defaultCache };
+  cache = { ...defaultTokenCache };
+  adapter;
   initPromise;
-  constructor() {
+  constructor(adapter) {
+    this.adapter = adapter;
     this.initPromise = this.load();
   }
   async load() {
-    await ensureDir(configDir);
-    this.cache = await safeReadJson(tokenPath, defaultCache);
+    try {
+      const loadedData = await this.adapter.loadToken();
+      if (loadedData) {
+        this.cache = loadedData;
+      }
+    } catch (error) {
+      throw new Error(`无法加载 token: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
   async save() {
     try {
-      await ensureDir(configDir);
-      await safeWriteJson(tokenPath, this.cache);
+      await this.adapter.saveToken(this.cache);
     } catch (error) {
       throw new Error(`无法保存 token: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
+  async waitForInit() {
+    await this.initPromise;
+  }
   isValid(appid) {
     const currentTime = Math.floor(Date.now() / 1e3);
     const bufferTime = 600;
@@ -232,209 +47,115 @@ class TokenStore {
     this.cache = {
       appid,
       accessToken,
+      // 计算绝对过期时间戳（秒）
       expireAt: Math.floor(Date.now() / 1e3) + expiresIn
     };
     await this.save();
   }
   async clear() {
     await this.initPromise;
-    this.cache = { ...defaultCache };
-    try {
-      await fs.unlink(tokenPath);
-    } catch {
-      await this.save();
-    }
+    this.cache = { ...defaultTokenCache };
+    await this.adapter.clearToken();
   }
 }
-const tokenStore = new TokenStore();
-const cachePath = path.join(configDir, "upload-cache.json");
 class UploadCacheStore {
   cache = {};
+  adapter;
   initPromise;
-  constructor() {
+  constructor(adapter) {
+    this.adapter = adapter;
     this.initPromise = this.load();
   }
   async load() {
-    await ensureDir(configDir);
-    this.cache = await safeReadJson(cachePath, {});
+    try {
+      this.cache = await this.adapter.loadCache();
+    } catch (error) {
+      throw new Error(`无法加载上传缓存: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
   async save() {
     try {
-      await ensureDir(configDir);
-      await safeWriteJson(cachePath, this.cache);
+      await this.adapter.saveCache(this.cache);
     } catch (error) {
       throw new Error(`无法保存上传缓存: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  async get(md5) {
+  async waitForInit() {
     await this.initPromise;
-    return this.cache[md5];
   }
-  async set(md5, mediaId, url) {
+  async get(hash) {
     await this.initPromise;
-    this.cache[md5] = { media_id: mediaId, url, updated_at: Date.now() };
+    return this.cache[hash];
+  }
+  async set(hash, mediaId, url) {
+    await this.initPromise;
+    this.cache[hash] = {
+      media_id: mediaId,
+      url,
+      updated_at: Date.now()
+    };
     await this.save();
   }
-}
-const uploadCacheStore = new UploadCacheStore();
-const { uploadMaterial, publishArticle, fetchAccessToken } = createWechatClient(nodeHttpAdapter);
-const mediaIdMapping = /* @__PURE__ */ new Map();
-async function uploadImage(imageUrl, accessToken, fileName, relativePath) {
-  let fileData;
-  let finalName;
-  let md5;
-  if (imageUrl.startsWith("http")) {
-    const response = await fetch(imageUrl);
-    if (!response.ok || !response.body) {
-      throw new Error(`下载图片失败 URL: ${imageUrl}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    if (arrayBuffer.byteLength === 0) {
-      throw new Error(`远程图片大小为0，无法上传: ${imageUrl}`);
-    }
-    const buffer = Buffer.from(arrayBuffer);
-    md5 = md5FromBuffer(buffer);
-    const cached = await uploadCacheStore.get(md5);
-    if (cached) {
-      mediaIdMapping.set(cached.url, cached.media_id);
-      return {
-        media_id: cached.media_id,
-        url: cached.url
-      };
-    }
-    const fileNameFromUrl = path.basename(imageUrl.split("?")[0]);
-    const ext = path.extname(fileNameFromUrl);
-    finalName = fileName ?? (ext === "" ? `${fileNameFromUrl}.jpg` : fileNameFromUrl);
-    const contentType = response.headers.get("content-type") || "image/jpeg";
-    fileData = new Blob([buffer], { type: contentType });
-  } else {
-    const resolvedPath = RuntimeEnv.resolveLocalPath(imageUrl, relativePath);
-    const stats = await stat(resolvedPath);
-    if (stats.size === 0) {
-      throw new Error(`本地图片大小为0，无法上传: ${resolvedPath}`);
-    }
-    md5 = await md5FromFile(resolvedPath);
-    const cached = await uploadCacheStore.get(md5);
+  async clear() {
+    await this.initPromise;
+    this.cache = {};
+    await this.adapter.clearCache();
+  }
+  async calcHash(buffer) {
+    return this.adapter.calcHash(buffer);
+  }
+}
+class WechatPublisher {
+  tokenStore;
+  uploadCacheStore;
+  uploadMaterial;
+  publishArticle;
+  fetchAccessToken;
+  constructor(httpAdapter, tokenStoreAdapter, uploadCacheStoreAdapter) {
+    const { uploadMaterial, publishArticle, fetchAccessToken } = createWechatClient(httpAdapter);
+    this.uploadMaterial = uploadMaterial;
+    this.publishArticle = publishArticle;
+    this.fetchAccessToken = fetchAccessToken;
+    this.tokenStore = tokenStoreAdapter ? new TokenStore(tokenStoreAdapter) : void 0;
+    this.uploadCacheStore = uploadCacheStoreAdapter ? new UploadCacheStore(uploadCacheStoreAdapter) : void 0;
+  }
+  async getAccessTokenWithCache(appId, appSecret) {
+    if (!this.tokenStore) {
+      const result2 = await this.fetchAccessToken(appId, appSecret);
+      return result2.access_token;
+    }
+    const cached = this.tokenStore.getToken(appId);
     if (cached) {
-      mediaIdMapping.set(cached.url, cached.media_id);
-      return {
-        media_id: cached.media_id,
-        url: cached.url
-      };
-    }
-    const fileNameFromLocal = path.basename(resolvedPath);
-    const ext = path.extname(fileNameFromLocal);
-    finalName = fileName ?? (ext === "" ? `${fileNameFromLocal}.jpg` : fileNameFromLocal);
-    const fileFromPathResult = await fileFromPath(resolvedPath);
-    fileData = new Blob([await fileFromPathResult.arrayBuffer()], { type: fileFromPathResult.type });
-  }
-  const data = await uploadMaterial("image", fileData, finalName, accessToken);
-  await uploadCacheStore.set(md5, data.media_id, data.url);
-  mediaIdMapping.set(data.url, data.media_id);
-  return data;
-}
-async function uploadImages(content, accessToken, relativePath) {
-  if (!content.includes("<img")) {
-    return { html: content, firstImageId: "" };
-  }
-  const dom = new JSDOM(content);
-  const document = dom.window.document;
-  const images = Array.from(document.querySelectorAll("img"));
-  const uploadPromises = images.map(async (element) => {
-    const dataSrc = element.getAttribute("src");
-    if (dataSrc) {
-      if (!dataSrc.startsWith("https://mmbiz.qpic.cn")) {
-        const resp = await uploadImage(dataSrc, accessToken, void 0, relativePath);
-        element.setAttribute("src", resp.url);
-        return resp.media_id;
-      } else {
-        return dataSrc;
+      return cached;
+    }
+    const result = await this.fetchAccessToken(appId, appSecret);
+    await this.tokenStore.setToken(appId, result.access_token, result.expires_in);
+    return result.access_token;
+  }
+  async uploadImage(file, filename, accessToken) {
+    let hash;
+    if (this.uploadCacheStore) {
+      const arrayBuffer = await file.arrayBuffer();
+      hash = await this.uploadCacheStore.calcHash(arrayBuffer);
+      const cached = await this.uploadCacheStore.get(hash);
+      if (cached) {
+        return {
+          media_id: cached.media_id,
+          url: cached.url
+        };
       }
     }
-    return null;
-  });
-  const mediaIds = (await Promise.all(uploadPromises)).filter(Boolean);
-  const firstImageId = mediaIds[0] || "";
-  const updatedHtml = dom.serialize();
-  return { html: updatedHtml, firstImageId };
-}
-async function publishToWechatDraft(articleOptions, publishOptions = {}) {
-  const { title, content, cover, author, source_url } = articleOptions;
-  const { appId, appSecret, relativePath } = publishOptions;
-  const appIdFinal = appId ?? process.env.WECHAT_APP_ID;
-  const appSecretFinal = appSecret ?? process.env.WECHAT_APP_SECRET;
-  if (!appIdFinal || !appSecretFinal) {
-    throw new Error("请通过参数或环境变量 WECHAT_APP_ID / WECHAT_APP_SECRET 提供公众号凭据");
-  }
-  const accessToken = await getAccessTokenWithCache(appIdFinal, appSecretFinal);
-  const { html, firstImageId } = await uploadImages(content, accessToken, relativePath);
-  let thumbMediaId = "";
-  if (cover) {
-    const cachedThumbMediaId = mediaIdMapping.get(cover);
-    if (cachedThumbMediaId) {
-      thumbMediaId = cachedThumbMediaId;
-    } else {
-      const resp = await uploadImage(cover, accessToken, "cover.jpg", relativePath);
-      thumbMediaId = resp.media_id;
+    const data = await this.uploadMaterial("image", file, filename, accessToken);
+    if (this.uploadCacheStore && hash) {
+      await this.uploadCacheStore.set(hash, data.media_id, data.url);
     }
-  } else {
-    if (firstImageId.startsWith("https://mmbiz.qpic.cn")) {
-      const cachedThumbMediaId = mediaIdMapping.get(firstImageId);
-      if (cachedThumbMediaId) {
-        thumbMediaId = cachedThumbMediaId;
-      } else {
-        const resp = await uploadImage(firstImageId, accessToken, "cover.jpg", relativePath);
-        thumbMediaId = resp.media_id;
-      }
-    } else {
-      thumbMediaId = firstImageId;
-    }
-  }
-  if (!thumbMediaId) {
-    throw new Error("你必须指定一张封面图或者在正文中至少出现一张图片。");
-  }
-  const data = await publishArticle(accessToken, {
-    title,
-    content: html,
-    thumb_media_id: thumbMediaId,
-    author,
-    content_source_url: source_url
-  });
-  if (data.media_id) {
     return data;
   }
-  throw new Error(`上传到公众号草稿失败: ${JSON.stringify(data)}`);
-}
-async function publishToDraft(title, content, cover = "", options = {}) {
-  return publishToWechatDraft({ title, content, cover }, options);
-}
-async function getAccessTokenWithCache(appId, appSecret) {
-  const cached = tokenStore.getToken(appId);
-  if (cached) {
-    return cached;
+  async publishToDraft(accessToken, options) {
+    return await this.publishArticle(accessToken, options);
   }
-  const result = await fetchAccessToken(appId, appSecret);
-  await tokenStore.setToken(appId, result.access_token, result.expires_in);
-  return result.access_token;
 }
 export {
-  RuntimeEnv as R,
-  readFileContent as a,
-  configDir as b,
-  configStore as c,
-  configPath as d,
-  ensureDir as e,
-  md5FromFile as f,
-  getNormalizeFilePath as g,
-  safeWriteJson as h,
-  isAbsolutePath as i,
-  tokenStore as j,
-  md5FromBuffer as m,
-  normalizePath as n,
-  publishToDraft,
-  publishToWechatDraft,
-  readBinaryFile as r,
-  safeReadJson as s,
-  tokenPath as t,
-  uploadCacheStore as u
+  WechatPublisher,
+  defaultTokenCache as d
 };

package/dist/types/node/publish.d.ts

@@ -1,15 +1,10 @@
 import { WechatPublishResponse } from "../wechat.js";
-export interface WechatPublishOptions {
+import { ArticleOptions } from "../publish.js";
+interface PublishOptions {
     appId?: string;
     appSecret?: string;
     relativePath?: string;
 }
-export interface ArticleOptions {
-    title: string;
-    content: string;
-    cover?: string;
-    author?: string;
-    source_url?: string;
-}
-export declare function publishToWechatDraft(articleOptions: ArticleOptions, publishOptions?: WechatPublishOptions): Promise<WechatPublishResponse>;
-export declare function publishToDraft(title: string, content: string, cover?: string, options?: WechatPublishOptions): Promise<WechatPublishResponse>;
+export declare function publishToWechatDraft(articleOptions: ArticleOptions, publishOptions?: PublishOptions): Promise<WechatPublishResponse>;
+export declare function publishToDraft(title: string, content: string, cover?: string, options?: PublishOptions): Promise<WechatPublishResponse>;
+export {};

package/dist/types/node/tokenStoreNodeAdapter.d.ts

@@ -0,0 +1,7 @@
+import { TokenCache, TokenStorageAdapter } from "../tokenStore.js";
+export declare const tokenPath: string;
+export declare class NodeTokenStorageAdapter implements TokenStorageAdapter {
+    loadToken(): Promise<TokenCache | null>;
+    saveToken(cache: TokenCache): Promise<void>;
+    clearToken(): Promise<void>;
+}

package/dist/types/node/uploadCacheNodeAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { CacheData, UploadCacheStorageAdapter } from "../uploadCacheStore.js";
+export declare const cachePath: string;
+export declare class NodeUploadCacheAdapter implements UploadCacheStorageAdapter {
+    loadCache(): Promise<CacheData>;
+    saveCache(cache: CacheData): Promise<void>;
+    clearCache(): Promise<void>;
+    calcHash(buffer: ArrayBuffer): Promise<string>;
+}

package/dist/types/node/wrapper.d.ts

@@ -3,9 +3,8 @@ export declare function getGzhContent(content: string, themeId: string, hlThemeI
 export declare function renderAndPublish(inputContent: string | undefined, options: PublishOptions, getInputContent: GetInputContentFn): Promise<string>;
 export declare function renderAndPublishToServer(inputContent: string | undefined, options: ClientPublishOptions, getInputContent: GetInputContentFn): Promise<string>;
 export * from "./configStore.js";
-export * from "./uploadCacheStore.js";
-export * from "./tokenStore.js";
 export * from "./render.js";
 export * from "./theme.js";
 export * from "./types.js";
 export * from "./utils.js";
+export * from "./publish.js";

package/dist/types/publish.d.ts

@@ -0,0 +1,22 @@
+import { HttpAdapter } from "./http.js";
+import { TokenStorageAdapter } from "./tokenStore.js";
+import { UploadCacheStorageAdapter } from "./uploadCacheStore.js";
+import { WechatPublishOptions, WechatPublishResponse, WechatUploadResponse } from "./wechat.js";
+export interface ArticleOptions {
+    title: string;
+    content: string;
+    cover?: string;
+    author?: string;
+    source_url?: string;
+}
+export declare class WechatPublisher {
+    private tokenStore;
+    private uploadCacheStore;
+    private uploadMaterial;
+    private publishArticle;
+    private fetchAccessToken;
+    constructor(httpAdapter: HttpAdapter, tokenStoreAdapter?: TokenStorageAdapter, uploadCacheStoreAdapter?: UploadCacheStorageAdapter);
+    getAccessTokenWithCache(appId: string, appSecret: string): Promise<string>;
+    uploadImage(file: Blob, filename: string, accessToken: string): Promise<WechatUploadResponse>;
+    publishToDraft(accessToken: string, options: WechatPublishOptions): Promise<WechatPublishResponse>;
+}

package/dist/types/{node/tokenStore.d.ts → tokenStore.d.ts}

@@ -1,19 +1,24 @@
-export declare const tokenPath: string;
 export interface TokenCache {
     appid: string;
     accessToken: string;
     expireAt: number;
 }
-declare class TokenStore {
+export declare const defaultTokenCache: TokenCache;
+export interface TokenStorageAdapter {
+    loadToken(): Promise<TokenCache | null>;
+    saveToken(cache: TokenCache): Promise<void>;
+    clearToken(): Promise<void>;
+}
+export declare class TokenStore {
     private cache;
+    private adapter;
     private initPromise;
-    constructor();
+    constructor(adapter: TokenStorageAdapter);
     private load;
     private save;
+    waitForInit(): Promise<void>;
     isValid(appid: string): boolean;
     getToken(appid: string): string | null;
     setToken(appid: string, accessToken: string, expiresIn: number): Promise<void>;
     clear(): Promise<void>;
 }
-export declare const tokenStore: TokenStore;
-export {};

package/dist/types/uploadCacheStore.d.ts

@@ -0,0 +1,27 @@
+export interface MediaInfo {
+    media_id: string;
+    url: string;
+    updated_at?: number;
+}
+export interface CacheData {
+    [hash: string]: MediaInfo;
+}
+export interface UploadCacheStorageAdapter {
+    loadCache(): Promise<CacheData>;
+    saveCache(cache: CacheData): Promise<void>;
+    clearCache(): Promise<void>;
+    calcHash(buffer: ArrayBuffer): Promise<string>;
+}
+export declare class UploadCacheStore {
+    private cache;
+    private adapter;
+    private initPromise;
+    constructor(adapter: UploadCacheStorageAdapter);
+    private load;
+    private save;
+    waitForInit(): Promise<void>;
+    get(hash: string): Promise<MediaInfo | undefined>;
+    set(hash: string, mediaId: string, url: string): Promise<void>;
+    clear(): Promise<void>;
+    calcHash(buffer: ArrayBuffer): Promise<string>;
+}

package/dist/types/wechat.d.ts

@@ -21,7 +21,7 @@ export interface WechatTokenResponse {
 export interface WechatPublishResponse {
     media_id: string;
 }
-export declare function createWechatClient(adapter: HttpAdapter): {
+export declare function createWechatClient(httpAdapter: HttpAdapter): {
     fetchAccessToken(appId: string, appSecret: string): Promise<WechatTokenResponse>;
     uploadMaterial(type: string, file: Blob, filename: string, accessToken: string): Promise<WechatUploadResponse>;
     publishArticle(accessToken: string, options: WechatPublishOptions): Promise<WechatPublishResponse>;

package/dist/wechat.js

@@ -1,10 +1,10 @@
 const tokenUrl = "https://api.weixin.qq.com/cgi-bin/token";
 const publishUrl = "https://api.weixin.qq.com/cgi-bin/draft/add";
 const uploadUrl = "https://api.weixin.qq.com/cgi-bin/material/add_material";
-function createWechatClient(adapter) {
+function createWechatClient(httpAdapter) {
   return {
     async fetchAccessToken(appId, appSecret) {
-      const res = await adapter.fetch(
+      const res = await httpAdapter.fetch(
         `${tokenUrl}?grant_type=client_credential&appid=${appId}&secret=${appSecret}`
       );
       if (!res.ok) throw new Error(await res.text());
@@ -13,8 +13,8 @@ function createWechatClient(adapter) {
       return data;
     },
     async uploadMaterial(type, file, filename, accessToken) {
-      const multipart = adapter.createMultipart("media", file, filename);
-      const res = await adapter.fetch(`${uploadUrl}?access_token=${accessToken}&type=${type}`, {
+      const multipart = httpAdapter.createMultipart("media", file, filename);
+      const res = await httpAdapter.fetch(`${uploadUrl}?access_token=${accessToken}&type=${type}`, {
         ...multipart,
         method: "POST"
       });
@@ -27,7 +27,7 @@ function createWechatClient(adapter) {
       return data;
     },
     async publishArticle(accessToken, options) {
-      const res = await adapter.fetch(`${publishUrl}?access_token=${accessToken}`, {
+      const res = await httpAdapter.fetch(`${publishUrl}?access_token=${accessToken}`, {
         method: "POST",
         body: JSON.stringify({
           articles: [options]

package/dist/wrapper.js

@@ -3,9 +3,110 @@ import { Readable } from "node:stream";
 import { FormData, File } from "formdata-node";
 import { FormDataEncoder } from "form-data-encoder";
 import { JSDOM } from "jsdom";
-import { R as RuntimeEnv, r as readBinaryFile, g as getNormalizeFilePath, a as readFileContent, c as configStore, publishToWechatDraft } from "./publish.js";
-import { b, d, e, i, m, f, n, s, h, t, j, u } from "./publish.js";
+import fs, { stat } from "node:fs/promises";
+import crypto from "node:crypto";
+import { fileFromPath } from "formdata-node/file-from-path";
+import os from "node:os";
+import { d as defaultTokenCache, WechatPublisher } from "./publish.js";
 import { createWenyanCore, getAllGzhThemes } from "./core.js";
+async function readFileContent(filePath) {
+  return await fs.readFile(filePath, "utf-8");
+}
+async function readBinaryFile(filePath) {
+  return await fs.readFile(filePath);
+}
+async function safeReadJson(file, fallback) {
+  try {
+    const content = await fs.readFile(file, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return fallback;
+  }
+}
+async function safeWriteJson(file, data) {
+  const tmp = file + ".tmp";
+  await fs.writeFile(tmp, JSON.stringify(data ?? {}, null, 2), "utf-8");
+  await fs.rename(tmp, file);
+}
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+function md5FromBuffer(buf) {
+  return crypto.createHash("md5").update(buf).digest("hex");
+}
+async function md5FromFile(filePath) {
+  const buf = await fs.readFile(filePath);
+  return md5FromBuffer(buf);
+}
+function normalizePath(p) {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function isAbsolutePath(path2) {
+  if (!path2) return false;
+  const winAbsPattern = /^[a-zA-Z]:\//;
+  const linuxAbsPattern = /^\//;
+  return winAbsPattern.test(path2) || linuxAbsPattern.test(path2);
+}
+function getNormalizeFilePath(inputPath) {
+  const isContainer = !!process.env.CONTAINERIZED;
+  const hostFilePath = normalizePath(process.env.HOST_FILE_PATH || "");
+  if (isContainer && hostFilePath) {
+    const containerFilePath = normalizePath(process.env.CONTAINER_FILE_PATH || "/mnt/host-downloads");
+    let relativePart = normalizePath(inputPath);
+    if (relativePart.startsWith(hostFilePath)) {
+      relativePart = relativePart.slice(hostFilePath.length);
+    }
+    if (!relativePart.startsWith("/")) {
+      relativePart = "/" + relativePart;
+    }
+    return containerFilePath + relativePart;
+  } else {
+    return path.resolve(inputPath);
+  }
+}
+const RuntimeEnv = {
+  isContainer: !!process.env.CONTAINERIZED,
+  hostFilePath: normalizePath(process.env.HOST_FILE_PATH || ""),
+  containerFilePath: normalizePath(process.env.CONTAINER_FILE_PATH || "/mnt/host-downloads"),
+  resolveLocalPath(inputPath, relativeBase) {
+    if (!this.isContainer) {
+      if (relativeBase) {
+        return path.resolve(relativeBase, inputPath);
+      } else {
+        if (!path.isAbsolute(inputPath)) {
+          throw new Error(
+            `Invalid input: '${inputPath}'. InputPath must be an absolute path.`
+          );
+        }
+        return path.normalize(inputPath);
+      }
+    }
+    let normalizedInput = normalizePath(inputPath);
+    relativeBase = normalizePath(relativeBase || "");
+    if (relativeBase) {
+      if (!isAbsolutePath(normalizedInput)) {
+        normalizedInput = relativeBase + (normalizedInput.startsWith("/") ? "" : "/") + normalizedInput;
+      }
+    } else {
+      if (!isAbsolutePath(normalizedInput)) {
+        throw new Error(
+          `Invalid input: '${inputPath}'. InputPath must be an absolute path.`
+        );
+      }
+    }
+    if (this.hostFilePath && normalizedInput.startsWith(this.hostFilePath)) {
+      let relativePart = normalizedInput.slice(this.hostFilePath.length);
+      if (relativePart && !relativePart.startsWith("/")) {
+        return normalizedInput;
+      }
+      if (!relativePart.startsWith("/")) {
+        relativePart = "/" + relativePart;
+      }
+      return this.containerFilePath + relativePart;
+    }
+    return normalizedInput;
+  }
+};
 function getServerUrl(options) {
   let serverUrl = options.server || "http://localhost:3000";
   serverUrl = serverUrl.replace(/\/$/, "");
@@ -168,6 +269,246 @@ async function uploadCover(serverUrl, headers, cover, relativePath) {
   }
   return cover;
 }
+const nodeHttpAdapter = {
+  fetch,
+  createMultipart(field, file, filename) {
+    const form = new FormData();
+    form.append(field, file, filename);
+    const encoder = new FormDataEncoder(form);
+    return {
+      body: Readable.from(encoder),
+      headers: encoder.headers,
+      duplex: "half"
+    };
+  }
+};
+const defaultConfig = {};
+const configDir = process.env.APPDATA ? path.join(process.env.APPDATA, "wenyan-md") : path.join(os.homedir(), ".config", "wenyan-md");
+const configPath = path.join(configDir, "config.json");
+class ConfigStore {
+  config = { ...defaultConfig };
+  initPromise;
+  constructor() {
+    this.initPromise = this.load();
+  }
+  async load() {
+    await ensureDir(configDir);
+    this.config = await safeReadJson(configPath, defaultConfig);
+  }
+  async save() {
+    try {
+      await ensureDir(configDir);
+      await safeWriteJson(configPath, this.config);
+    } catch (error) {
+      throw new Error(`无法保存配置文件: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async getConfig() {
+    await this.initPromise;
+    return this.config;
+  }
+  async getThemes() {
+    await this.initPromise;
+    return Object.values(this.config.themes ?? {});
+  }
+  async getThemeById(themeId) {
+    await this.initPromise;
+    const themeOption = this.config.themes?.[themeId];
+    if (!themeOption) return void 0;
+    const absoluteFilePath = path.join(configDir, themeOption.path);
+    try {
+      return await fs.readFile(absoluteFilePath, "utf-8");
+    } catch {
+      return void 0;
+    }
+  }
+  async addThemeToConfig(name, content) {
+    await this.initPromise;
+    const savedPath = await this.addThemeFile(name, content);
+    this.config.themes ??= {};
+    this.config.themes[name] = {
+      id: name,
+      name,
+      path: savedPath
+    };
+    await this.save();
+  }
+  async addThemeFile(themeId, themeContent) {
+    const filePath = `themes/${themeId}.css`;
+    const absoluteFilePath = path.join(configDir, filePath);
+    await ensureDir(path.dirname(absoluteFilePath));
+    await fs.writeFile(absoluteFilePath, themeContent, "utf-8");
+    return filePath;
+  }
+  async deleteThemeFromConfig(themeId) {
+    await this.initPromise;
+    const theme = this.config.themes?.[themeId];
+    if (!theme) return;
+    await this.deleteThemeFile(theme.path);
+    delete this.config.themes[themeId];
+    await this.save();
+  }
+  async deleteThemeFile(filePath) {
+    try {
+      await fs.unlink(path.join(configDir, filePath));
+    } catch {
+    }
+  }
+}
+const configStore = new ConfigStore();
+const tokenPath = path.join(configDir, "token.json");
+class NodeTokenStorageAdapter {
+  async loadToken() {
+    await ensureDir(configDir);
+    return await safeReadJson(tokenPath, defaultTokenCache);
+  }
+  async saveToken(cache) {
+    await ensureDir(configDir);
+    await safeWriteJson(tokenPath, cache);
+  }
+  async clearToken() {
+    try {
+      await fs.unlink(tokenPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+}
+const cachePath = path.join(configDir, "upload-cache.json");
+class NodeUploadCacheAdapter {
+  async loadCache() {
+    await ensureDir(configDir);
+    return await safeReadJson(cachePath, {});
+  }
+  async saveCache(cache) {
+    await ensureDir(configDir);
+    await safeWriteJson(cachePath, cache);
+  }
+  async clearCache() {
+    try {
+      await fs.unlink(cachePath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  async calcHash(buffer) {
+    return crypto.createHash("md5").update(Buffer.from(buffer)).digest("hex");
+  }
+}
+const mediaIdMapping = /* @__PURE__ */ new Map();
+const wechatPublisher = new WechatPublisher(nodeHttpAdapter, new NodeTokenStorageAdapter(), new NodeUploadCacheAdapter());
+async function uploadImage(imageUrl, accessToken, fileName, relativePath) {
+  let fileData;
+  let finalName;
+  if (imageUrl.startsWith("http")) {
+    const response = await fetch(imageUrl);
+    if (!response.ok || !response.body) {
+      throw new Error(`下载图片失败 URL: ${imageUrl}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    if (arrayBuffer.byteLength === 0) {
+      throw new Error(`远程图片大小为0，无法上传: ${imageUrl}`);
+    }
+    const fileNameFromUrl = path.basename(imageUrl.split("?")[0]);
+    const ext = path.extname(fileNameFromUrl);
+    finalName = fileName ?? (ext === "" ? `${fileNameFromUrl}.jpg` : fileNameFromUrl);
+    const contentType = response.headers.get("content-type") || "image/jpeg";
+    fileData = new Blob([arrayBuffer], { type: contentType });
+  } else {
+    const resolvedPath = RuntimeEnv.resolveLocalPath(imageUrl, relativePath);
+    const stats = await stat(resolvedPath);
+    if (stats.size === 0) {
+      throw new Error(`本地图片大小为0，无法上传: ${resolvedPath}`);
+    }
+    const fileNameFromLocal = path.basename(resolvedPath);
+    const ext = path.extname(fileNameFromLocal);
+    finalName = fileName ?? (ext === "" ? `${fileNameFromLocal}.jpg` : fileNameFromLocal);
+    const fileFromPathResult = await fileFromPath(resolvedPath);
+    fileData = new Blob([await fileFromPathResult.arrayBuffer()], { type: fileFromPathResult.type });
+  }
+  const data = await wechatPublisher.uploadImage(fileData, finalName, accessToken);
+  mediaIdMapping.set(data.url, data.media_id);
+  return data;
+}
+async function uploadImages(content, accessToken, relativePath) {
+  if (!content.includes("<img")) {
+    return { html: content, firstImageId: "" };
+  }
+  const dom = new JSDOM(content);
+  const document = dom.window.document;
+  const images = Array.from(document.querySelectorAll("img"));
+  const uploadPromises = images.map(async (element) => {
+    const dataSrc = element.getAttribute("src");
+    if (dataSrc) {
+      if (!dataSrc.startsWith("https://mmbiz.qpic.cn")) {
+        const resp = await uploadImage(dataSrc, accessToken, void 0, relativePath);
+        element.setAttribute("src", resp.url);
+        return resp.media_id;
+      } else {
+        return dataSrc;
+      }
+    }
+    return null;
+  });
+  const mediaIds = (await Promise.all(uploadPromises)).filter(Boolean);
+  const firstImageId = mediaIds[0] || "";
+  const updatedHtml = dom.serialize();
+  return { html: updatedHtml, firstImageId };
+}
+async function publishToWechatDraft(articleOptions, publishOptions = {}) {
+  const { title, content, cover, author, source_url } = articleOptions;
+  const { appId, appSecret, relativePath } = publishOptions;
+  const appIdFinal = appId ?? process.env.WECHAT_APP_ID;
+  const appSecretFinal = appSecret ?? process.env.WECHAT_APP_SECRET;
+  if (!appIdFinal || !appSecretFinal) {
+    throw new Error("请通过参数或环境变量 WECHAT_APP_ID / WECHAT_APP_SECRET 提供公众号凭据");
+  }
+  const accessToken = await wechatPublisher.getAccessTokenWithCache(appIdFinal, appSecretFinal);
+  const { html, firstImageId } = await uploadImages(content, accessToken, relativePath);
+  let thumbMediaId = "";
+  if (cover) {
+    const cachedThumbMediaId = mediaIdMapping.get(cover);
+    if (cachedThumbMediaId) {
+      thumbMediaId = cachedThumbMediaId;
+    } else {
+      const resp = await uploadImage(cover, accessToken, "cover.jpg", relativePath);
+      thumbMediaId = resp.media_id;
+    }
+  } else {
+    if (firstImageId.startsWith("https://mmbiz.qpic.cn")) {
+      const cachedThumbMediaId = mediaIdMapping.get(firstImageId);
+      if (cachedThumbMediaId) {
+        thumbMediaId = cachedThumbMediaId;
+      } else {
+        const resp = await uploadImage(firstImageId, accessToken, "cover.jpg", relativePath);
+        thumbMediaId = resp.media_id;
+      }
+    } else {
+      thumbMediaId = firstImageId;
+    }
+  }
+  if (!thumbMediaId) {
+    throw new Error("你必须指定一张封面图或者在正文中至少出现一张图片。");
+  }
+  const data = await wechatPublisher.publishToDraft(accessToken, {
+    title,
+    content: html,
+    thumb_media_id: thumbMediaId,
+    author,
+    content_source_url: source_url
+  });
+  if (data.media_id) {
+    return data;
+  }
+  throw new Error(`上传到公众号草稿失败: ${JSON.stringify(data)}`);
+}
+async function publishToDraft(title, content, cover = "", options = {}) {
+  return publishToWechatDraft({ title, content, cover }, options);
+}
 const wenyanCoreInstance = await createWenyanCore();
 async function renderWithTheme(markdownContent, options) {
   if (!markdownContent) {
@@ -176,8 +517,8 @@ async function renderWithTheme(markdownContent, options) {
   const { theme, customTheme, highlight, macStyle, footnote } = options;
   let handledCustomTheme = customTheme;
   if (customTheme) {
-    const normalizePath = getNormalizeFilePath(customTheme);
-    handledCustomTheme = await readFileContent(normalizePath);
+    const normalizePath2 = getNormalizeFilePath(customTheme);
+    handledCustomTheme = await readFileContent(normalizePath2);
   } else if (theme) {
     handledCustomTheme = await configStore.getThemeById(theme);
   }
@@ -252,8 +593,8 @@ async function addTheme(name, path2) {
     const content = await response.text();
     await configStore.addThemeToConfig(name, content);
   } else {
-    const normalizePath = getNormalizeFilePath(path2);
-    const content = await readFileContent(normalizePath);
+    const normalizePath2 = getNormalizeFilePath(path2);
+    const content = await readFileContent(normalizePath2);
     await configStore.addThemeToConfig(name, content);
   }
 }
@@ -318,18 +659,20 @@ async function renderAndPublishToServer(inputContent, options, getInputContent)
 }
 export {
   addTheme,
-  b as configDir,
-  d as configPath,
+  configDir,
+  configPath,
   configStore,
-  e as ensureDir,
+  ensureDir,
   getGzhContent,
   getNormalizeFilePath,
-  i as isAbsolutePath,
+  isAbsolutePath,
   listThemes,
-  m as md5FromBuffer,
-  f as md5FromFile,
-  n as normalizePath,
+  md5FromBuffer,
+  md5FromFile,
+  normalizePath,
   prepareRenderContext,
+  publishToDraft,
+  publishToWechatDraft,
   readBinaryFile,
   readFileContent,
   removeTheme,
@@ -337,9 +680,6 @@ export {
   renderAndPublishToServer,
   renderStyledContent,
   renderWithTheme,
-  s as safeReadJson,
-  h as safeWriteJson,
-  t as tokenPath,
-  j as tokenStore,
-  u as uploadCacheStore
+  safeReadJson,
+  safeWriteJson
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenyan-md/core",
-  "version": "2.0.8",
+  "version": "3.0.0",
   "description": "Core library for Wenyan markdown rendering & publishing",
   "author": "Lei <caol64@gmail.com> (https://github.com/caol64)",
   "license": "Apache-2.0",
@@ -32,7 +32,7 @@
     },
     "./publish": {
       "import": "./dist/publish.js",
-      "types": "./dist/types/node/publish.d.ts"
+      "types": "./dist/types/publish.d.ts"
     },
     "./wrapper": {
       "import": "./dist/wrapper.js",

package/dist/types/node/uploadCacheStore.d.ts

@@ -1,16 +0,0 @@
-export interface MediaInfo {
-    media_id: string;
-    url: string;
-    updated_at?: number;
-}
-declare class UploadCacheStore {
-    private cache;
-    private initPromise;
-    constructor();
-    private load;
-    private save;
-    get(md5: string): Promise<MediaInfo | undefined>;
-    set(md5: string, mediaId: string, url: string): Promise<void>;
-}
-export declare const uploadCacheStore: UploadCacheStore;
-export {};