@wenyan-md/core 2.0.6 → 2.0.8

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-    <img alt="logo" src="https://raw.githubusercontent.com/caol64/wenyan/main/Data/256-mac.png" />
+    <img alt="logo" src="https://raw.githubusercontent.com/caol64/wenyan/main/Data/256-mac.png" width="128" />
 </div>
 
 # 文颜 CORE
@@ -11,7 +11,7 @@
 
 ## 简介
 
-**文颜（Wenyan）** 是一套多平台 Markdown 排版与发布工具链，  **文颜 CORE** 是其核心库，专注于：
+**[文颜（Wenyan）](https://wenyan.yuzhi.tech/)** 是一套多平台 Markdown 排版与发布工具链，  **文颜 CORE** 是其核心库，专注于：
 
 - Markdown → HTML 渲染
 - 主题排版（公众号 / Web）

package/dist/publish.js

@@ -1,13 +1,42 @@
 import { JSDOM } from "jsdom";
 import { fileFromPath } from "formdata-node/file-from-path";
 import path from "node:path";
-import { stat } from "node:fs/promises";
+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 fs from "node:fs";
-import { c as configDir, e as ensureDir, s as safeReadJson, d as safeWriteJson, m as md5FromBuffer, f as md5FromFile } from "./configStore-lZ5bhrcC.js";
+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(/\/+$/, "");
 }
@@ -17,6 +46,23 @@ function isAbsolutePath(path2) {
   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 || ""),
@@ -28,7 +74,7 @@ const RuntimeEnv = {
       } else {
         if (!path.isAbsolute(inputPath)) {
           throw new Error(
-            `Invalid input: '${inputPath}'. When relativeBase is not provided, inputPath must be an absolute path.`
+            `Invalid input: '${inputPath}'. InputPath must be an absolute path.`
           );
         }
         return path.normalize(inputPath);
@@ -43,11 +89,11 @@ const RuntimeEnv = {
     } else {
       if (!isAbsolutePath(normalizedInput)) {
         throw new Error(
-          `Invalid input: '${inputPath}'. When relativeBase is not provided, inputPath must be an absolute path.`
+          `Invalid input: '${inputPath}'. InputPath must be an absolute path.`
         );
       }
     }
-    if (normalizedInput.startsWith(this.hostFilePath)) {
+    if (this.hostFilePath && normalizedInput.startsWith(this.hostFilePath)) {
       let relativePart = normalizedInput.slice(this.hostFilePath.length);
       if (relativePart && !relativePart.startsWith("/")) {
         return normalizedInput;
@@ -73,6 +119,80 @@ const nodeHttpAdapter = {
     };
   }
 };
+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 = {
   appid: "",
@@ -80,46 +200,49 @@ const defaultCache = {
   expireAt: 0
 };
 class TokenStore {
-  cache = defaultCache;
+  cache = { ...defaultCache };
+  initPromise;
   constructor() {
-    this.load();
+    this.initPromise = this.load();
   }
-  load() {
-    ensureDir(configDir);
-    if (fs.existsSync(tokenPath)) {
-      this.cache = safeReadJson(tokenPath, defaultCache);
-    }
+  async load() {
+    await ensureDir(configDir);
+    this.cache = await safeReadJson(tokenPath, defaultCache);
   }
-  save() {
+  async save() {
     try {
-      ensureDir(configDir);
-      safeWriteJson(tokenPath, this.cache);
+      await ensureDir(configDir);
+      await safeWriteJson(tokenPath, this.cache);
     } catch (error) {
-      console.error("❌ 无法保存 token:", error);
+      throw new Error(`无法保存 token: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   isValid(appid) {
-    if (!this.cache) return false;
-    return this.cache.appid === appid && this.cache.expireAt > Date.now() / 1e3 + 600;
+    const currentTime = Math.floor(Date.now() / 1e3);
+    const bufferTime = 600;
+    const isAppidMatch = this.cache.appid === appid;
+    const isNotExpired = this.cache.expireAt > currentTime + bufferTime;
+    return isAppidMatch && isNotExpired;
   }
   getToken(appid) {
     return this.isValid(appid) ? this.cache.accessToken : null;
   }
-  setToken(appid, accessToken, expiresIn) {
+  async setToken(appid, accessToken, expiresIn) {
+    await this.initPromise;
     this.cache = {
       appid,
       accessToken,
       expireAt: Math.floor(Date.now() / 1e3) + expiresIn
     };
-    this.save();
+    await this.save();
   }
-  clear() {
-    this.cache = defaultCache;
+  async clear() {
+    await this.initPromise;
+    this.cache = { ...defaultCache };
     try {
-      if (fs.existsSync(tokenPath)) {
-        fs.unlinkSync(tokenPath);
-      }
+      await fs.unlink(tokenPath);
     } catch {
+      await this.save();
     }
   }
 }
@@ -127,29 +250,30 @@ const tokenStore = new TokenStore();
 const cachePath = path.join(configDir, "upload-cache.json");
 class UploadCacheStore {
   cache = {};
+  initPromise;
   constructor() {
-    this.load();
+    this.initPromise = this.load();
   }
-  load() {
-    ensureDir(configDir);
-    if (fs.existsSync(cachePath)) {
-      this.cache = safeReadJson(cachePath, {});
-    }
+  async load() {
+    await ensureDir(configDir);
+    this.cache = await safeReadJson(cachePath, {});
   }
-  save() {
+  async save() {
     try {
-      ensureDir(configDir);
-      safeWriteJson(cachePath, this.cache);
+      await ensureDir(configDir);
+      await safeWriteJson(cachePath, this.cache);
     } catch (error) {
-      console.error("❌ 无法保存上传缓存:", error);
+      throw new Error(`无法保存上传缓存: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  get(md5) {
+  async get(md5) {
+    await this.initPromise;
     return this.cache[md5];
   }
-  set(md5, mediaId, url) {
+  async set(md5, mediaId, url) {
+    await this.initPromise;
     this.cache[md5] = { media_id: mediaId, url, updated_at: Date.now() };
-    this.save();
+    await this.save();
   }
 }
 const uploadCacheStore = new UploadCacheStore();
@@ -162,7 +286,7 @@ async function uploadImage(imageUrl, accessToken, fileName, relativePath) {
   if (imageUrl.startsWith("http")) {
     const response = await fetch(imageUrl);
     if (!response.ok || !response.body) {
-      throw new Error(`Failed to download image from URL: ${imageUrl}`);
+      throw new Error(`下载图片失败 URL: ${imageUrl}`);
     }
     const arrayBuffer = await response.arrayBuffer();
     if (arrayBuffer.byteLength === 0) {
@@ -170,7 +294,7 @@ async function uploadImage(imageUrl, accessToken, fileName, relativePath) {
     }
     const buffer = Buffer.from(arrayBuffer);
     md5 = md5FromBuffer(buffer);
-    const cached = uploadCacheStore.get(md5);
+    const cached = await uploadCacheStore.get(md5);
     if (cached) {
       mediaIdMapping.set(cached.url, cached.media_id);
       return {
@@ -189,8 +313,8 @@ async function uploadImage(imageUrl, accessToken, fileName, relativePath) {
     if (stats.size === 0) {
       throw new Error(`本地图片大小为0，无法上传: ${resolvedPath}`);
     }
-    md5 = md5FromFile(resolvedPath);
-    const cached = uploadCacheStore.get(md5);
+    md5 = await md5FromFile(resolvedPath);
+    const cached = await uploadCacheStore.get(md5);
     if (cached) {
       mediaIdMapping.set(cached.url, cached.media_id);
       return {
@@ -205,7 +329,7 @@ async function uploadImage(imageUrl, accessToken, fileName, relativePath) {
     fileData = new Blob([await fileFromPathResult.arrayBuffer()], { type: fileFromPathResult.type });
   }
   const data = await uploadMaterial("image", fileData, finalName, accessToken);
-  uploadCacheStore.set(md5, data.media_id, data.url);
+  await uploadCacheStore.set(md5, data.media_id, data.url);
   mediaIdMapping.set(data.url, data.media_id);
   return data;
 }
@@ -252,7 +376,6 @@ async function publishToWechatDraft(articleOptions, publishOptions = {}) {
     } else {
       const resp = await uploadImage(cover, accessToken, "cover.jpg", relativePath);
       thumbMediaId = resp.media_id;
-      mediaIdMapping.set(resp.url, resp.media_id);
     }
   } else {
     if (firstImageId.startsWith("https://mmbiz.qpic.cn")) {
@@ -262,7 +385,6 @@ async function publishToWechatDraft(articleOptions, publishOptions = {}) {
       } else {
         const resp = await uploadImage(firstImageId, accessToken, "cover.jpg", relativePath);
         thumbMediaId = resp.media_id;
-        mediaIdMapping.set(resp.url, resp.media_id);
       }
     } else {
       thumbMediaId = firstImageId;
@@ -292,10 +414,27 @@ async function getAccessTokenWithCache(appId, appSecret) {
     return cached;
   }
   const result = await fetchAccessToken(appId, appSecret);
-  tokenStore.setToken(appId, result.access_token, result.expires_in);
+  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
+  publishToWechatDraft,
+  readBinaryFile as r,
+  safeReadJson as s,
+  tokenPath as t,
+  uploadCacheStore as u
 };

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

@@ -0,0 +1,15 @@
+import { ClientPublishOptions, StyledContent } from "./types.js";
+export declare function getServerUrl(options: ClientPublishOptions): string;
+export declare function getHeaders(options: ClientPublishOptions): Record<string, string>;
+/**
+ * 物理连通性测试
+ */
+export declare function healthCheck(serverUrl: string): Promise<string>;
+/**
+ * 鉴权探针测试
+ */
+export declare function verifyAuth(serverUrl: string, headers: Record<string, string>): Promise<void>;
+export declare function uploadStyledContent(gzhContent: StyledContent, serverUrl: string, headers: Record<string, string>): Promise<string>;
+export declare function requestServerPublish(mdFileId: string, serverUrl: string, headers: Record<string, string>, options: ClientPublishOptions): Promise<string>;
+export declare function uploadLocalImages(content: string, serverUrl: string, headers: Record<string, string>, relativePath?: string): Promise<string>;
+export declare function uploadCover(serverUrl: string, headers: Record<string, string>, cover?: string, relativePath?: string): Promise<string | undefined>;

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

@@ -11,16 +11,17 @@ export declare const configDir: string;
 export declare const configPath: string;
 declare class ConfigStore {
     private config;
+    private initPromise;
     constructor();
     private load;
     private save;
-    getConfig(): WenyanConfig;
-    getThemes(): ThemeConfigOptions[];
-    getThemeById(themeId: string): string | undefined;
-    addThemeToConfig(name: string, content: string): void;
-    addThemeFile(themeId: string, themeContent: string): string;
-    deleteThemeFromConfig(themeId: string): void;
-    deleteThemeFile(filePath: string): void;
+    getConfig(): Promise<WenyanConfig>;
+    getThemes(): Promise<ThemeConfigOptions[]>;
+    getThemeById(themeId: string): Promise<string | undefined>;
+    addThemeToConfig(name: string, content: string): Promise<void>;
+    addThemeFile(themeId: string, themeContent: string): Promise<string>;
+    deleteThemeFromConfig(themeId: string): Promise<void>;
+    deleteThemeFile(filePath: string): Promise<void>;
 }
 export declare const configStore: ConfigStore;
 export {};

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

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

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

@@ -0,0 +1,5 @@
+import { ApplyStylesOptions } from "../core/index.js";
+import { GetInputContentFn, RenderContext, RenderOptions, StyledContent } from "./types.js";
+export declare function renderWithTheme(markdownContent: string, options: RenderOptions): Promise<StyledContent>;
+export declare function renderStyledContent(content: string, options?: ApplyStylesOptions): Promise<StyledContent>;
+export declare function prepareRenderContext(inputContent: string | undefined, options: RenderOptions, getInputContent: GetInputContentFn): Promise<RenderContext>;

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

@@ -0,0 +1,16 @@
+export interface ThemeOptions {
+    list?: boolean;
+    add?: boolean;
+    name?: string;
+    path?: string;
+    rm?: string;
+}
+export interface ThemeInfo {
+    id: string;
+    name: string;
+    description?: string;
+    isBuiltin: boolean;
+}
+export declare function listThemes(): Promise<ThemeInfo[]>;
+export declare function addTheme(name?: string, path?: string): Promise<void>;
+export declare function removeTheme(name: string): Promise<void>;

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

@@ -6,13 +6,14 @@ export interface TokenCache {
 }
 declare class TokenStore {
     private cache;
+    private initPromise;
     constructor();
     private load;
     private save;
     isValid(appid: string): boolean;
     getToken(appid: string): string | null;
-    setToken(appid: string, accessToken: string, expiresIn: number): void;
-    clear(): void;
+    setToken(appid: string, accessToken: string, expiresIn: number): Promise<void>;
+    clear(): Promise<void>;
 }
 export declare const tokenStore: TokenStore;
 export {};

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

@@ -0,0 +1,31 @@
+export interface RenderOptions {
+    file?: string;
+    theme?: string;
+    customTheme?: string;
+    highlight: string;
+    macStyle: boolean;
+    footnote: boolean;
+}
+export interface PublishOptions extends RenderOptions {
+}
+export interface ClientPublishOptions extends RenderOptions {
+    server?: string;
+    apiKey?: string;
+    clientVersion?: string;
+}
+export interface RenderContext {
+    gzhContent: StyledContent;
+    absoluteDirPath: string | undefined;
+}
+export interface StyledContent {
+    content: string;
+    title?: string;
+    cover?: string;
+    description?: string;
+    author?: string;
+    source_url?: string;
+}
+export type GetInputContentFn = (inputContent?: string, filePath?: string) => Promise<{
+    content: string;
+    absoluteDirPath?: string;
+}>;

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

@@ -5,11 +5,12 @@ export interface MediaInfo {
 }
 declare class UploadCacheStore {
     private cache;
+    private initPromise;
     constructor();
     private load;
     private save;
-    get(md5: string): MediaInfo;
-    set(md5: string, mediaId: string, url: string): void;
+    get(md5: string): Promise<MediaInfo | undefined>;
+    set(md5: string, mediaId: string, url: string): Promise<void>;
 }
 export declare const uploadCacheStore: UploadCacheStore;
 export {};

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

@@ -1,6 +1,16 @@
 import crypto from "node:crypto";
-export declare function safeReadJson<T>(file: string, fallback: T): T;
-export declare function safeWriteJson(file: string, data: unknown): void;
-export declare function ensureDir(dir: string): void;
+export declare function readFileContent(filePath: string): Promise<string>;
+export declare function readBinaryFile(filePath: string): Promise<Buffer>;
+export declare function safeReadJson<T>(file: string, fallback: T): Promise<T>;
+export declare function safeWriteJson(file: string, data: unknown): Promise<void>;
+export declare function ensureDir(dir: string): Promise<void>;
 export declare function md5FromBuffer(buf: crypto.BinaryLike): string;
-export declare function md5FromFile(filePath: string): string;
+export declare function md5FromFile(filePath: string): Promise<string>;
+/**
+ * 路径标准化工具函数
+ * 将 Windows 的反斜杠 \ 转换为正斜杠 /，并去除末尾斜杠
+ * 目的：在 Linux 容器内也能正确处理 Windows 路径字符串
+ */
+export declare function normalizePath(p: string): string;
+export declare function isAbsolutePath(path: string): boolean;
+export declare function getNormalizeFilePath(inputPath: string): string;

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

@@ -1,12 +1,11 @@
-import { ApplyStylesOptions } from "../core/index.js";
-export interface StyledContent {
-    content: string;
-    title?: string;
-    cover?: string;
-    description?: string;
-    author?: string;
-    source_url?: string;
-}
-export declare function renderStyledContent(content: string, options?: ApplyStylesOptions): Promise<StyledContent>;
+import { ClientPublishOptions, GetInputContentFn, PublishOptions, StyledContent } from "./types.js";
 export declare function getGzhContent(content: string, themeId: string, hlThemeId: string, isMacStyle?: boolean, isAddFootnote?: boolean): Promise<StyledContent>;
+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";

package/dist/wrapper.js

@@ -1,7 +1,198 @@
+import path from "node:path";
+import { Readable } from "node:stream";
+import { FormData, File } from "formdata-node";
+import { FormDataEncoder } from "form-data-encoder";
 import { JSDOM } from "jsdom";
-import { createWenyanCore } from "./core.js";
-import { c, a, b } from "./configStore-lZ5bhrcC.js";
+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 { createWenyanCore, getAllGzhThemes } from "./core.js";
+function getServerUrl(options) {
+  let serverUrl = options.server || "http://localhost:3000";
+  serverUrl = serverUrl.replace(/\/$/, "");
+  return serverUrl;
+}
+function getHeaders(options) {
+  const headers = {};
+  if (options.clientVersion) {
+    headers["x-client-version"] = options.clientVersion;
+  }
+  if (options.apiKey) {
+    headers["x-api-key"] = options.apiKey;
+  }
+  return headers;
+}
+async function healthCheck(serverUrl) {
+  try {
+    const healthRes = await fetch(`${serverUrl}/health`, { method: "GET" });
+    if (!healthRes.ok) {
+      throw new Error(`HTTP Error: ${healthRes.status} ${healthRes.statusText}`);
+    }
+    const healthData = await healthRes.json();
+    if (healthData.status !== "ok" || healthData.service !== "wenyan-cli") {
+      throw new Error(`Invalid server response. Make sure the server URL is correct.`);
+    }
+    return healthData.version;
+  } catch (error) {
+    throw new Error(
+      `Failed to connect to server (${serverUrl}). 
+Please check if the server is running and the network is accessible. 
+Details: ${error.message}`
+    );
+  }
+}
+async function verifyAuth(serverUrl, headers) {
+  const verifyRes = await fetch(`${serverUrl}/verify`, {
+    method: "GET",
+    headers
+    // 携带 x-api-key 和 x-client-version
+  });
+  if (verifyRes.status === 401) {
+    throw new Error("鉴权失败 (401)：Server 拒绝访问，请检查传入的 --api-key 是否正确。");
+  }
+  if (!verifyRes.ok) {
+    throw new Error(`Verify Error: ${verifyRes.status} ${verifyRes.statusText}`);
+  }
+}
+async function uploadStyledContent(gzhContent, serverUrl, headers) {
+  const mdFilename = "publish_target.json";
+  const mdForm = new FormData();
+  mdForm.append(
+    "file",
+    new File([Buffer.from(JSON.stringify(gzhContent), "utf-8")], mdFilename, { type: "application/json" })
+  );
+  const mdEncoder = new FormDataEncoder(mdForm);
+  const mdUploadRes = await fetch(`${serverUrl}/upload`, {
+    method: "POST",
+    headers: { ...headers, ...mdEncoder.headers },
+    body: Readable.from(mdEncoder),
+    duplex: "half"
+  });
+  const mdUploadData = await mdUploadRes.json();
+  if (!mdUploadRes.ok || !mdUploadData.success) {
+    throw new Error(`Upload Document Failed: ${mdUploadData.error || mdUploadData.desc || mdUploadRes.statusText}`);
+  }
+  const mdFileId = mdUploadData.data.fileId;
+  return mdFileId;
+}
+async function requestServerPublish(mdFileId, serverUrl, headers, options) {
+  const { theme, customTheme, highlight, macStyle, footnote } = options;
+  const publishRes = await fetch(`${serverUrl}/publish`, {
+    method: "POST",
+    headers: {
+      ...headers,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      fileId: mdFileId,
+      theme,
+      highlight,
+      customTheme,
+      macStyle,
+      footnote
+    })
+  });
+  const publishData = await publishRes.json();
+  if (!publishRes.ok || publishData.code === -1) {
+    throw new Error(`Remote Publish Failed: ${publishData.desc || publishRes.statusText}`);
+  }
+  return publishData.media_id;
+}
+function needUpload(url) {
+  return !/^(https?:\/\/|data:|asset:\/\/)/i.test(url);
+}
+async function uploadLocalImage(originalUrl, serverUrl, headers, relativePath) {
+  const imagePath = RuntimeEnv.resolveLocalPath(originalUrl, relativePath);
+  let fileBuffer;
+  try {
+    fileBuffer = await readBinaryFile(imagePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      console.error(`[Client] Warning: Local image not found: ${imagePath}`);
+      return null;
+    }
+    throw new Error(`Failed to read local image (${imagePath}): ${error.message}`);
+  }
+  const filename = path.basename(imagePath);
+  const ext = path.extname(filename).toLowerCase();
+  const mimeTypes = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml"
+  };
+  const type = mimeTypes[ext] || "application/octet-stream";
+  const form = new FormData();
+  form.append("file", new File([fileBuffer], filename, { type }));
+  const encoder = new FormDataEncoder(form);
+  const uploadRes = await fetch(`${serverUrl}/upload`, {
+    method: "POST",
+    headers: { ...headers, ...encoder.headers },
+    body: Readable.from(encoder),
+    duplex: "half"
+  });
+  const uploadData = await uploadRes.json();
+  if (uploadRes.ok && uploadData.success) {
+    return `asset://${uploadData.data.fileId}`;
+  } else {
+    console.error(`[Client] Warning: Failed to upload ${filename}: ${uploadData.error || uploadData.desc}`);
+    return null;
+  }
+}
+async function uploadLocalImages(content, serverUrl, headers, relativePath) {
+  if (content.includes("<img")) {
+    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 && needUpload(dataSrc)) {
+        const newUrl = await uploadLocalImage(dataSrc, serverUrl, headers, relativePath);
+        if (newUrl) {
+          element.setAttribute("src", newUrl);
+        }
+      }
+    });
+    await Promise.all(uploadPromises);
+    return document.body.innerHTML;
+  }
+  return content;
+}
+async function uploadCover(serverUrl, headers, cover, relativePath) {
+  if (cover && needUpload(cover)) {
+    const newCoverUrl = await uploadLocalImage(cover, serverUrl, headers, relativePath);
+    if (newCoverUrl) {
+      return newCoverUrl;
+    }
+  }
+  return cover;
+}
 const wenyanCoreInstance = await createWenyanCore();
+async function renderWithTheme(markdownContent, options) {
+  if (!markdownContent) {
+    throw new Error("No content provided for rendering.");
+  }
+  const { theme, customTheme, highlight, macStyle, footnote } = options;
+  let handledCustomTheme = customTheme;
+  if (customTheme) {
+    const normalizePath = getNormalizeFilePath(customTheme);
+    handledCustomTheme = await readFileContent(normalizePath);
+  } else if (theme) {
+    handledCustomTheme = await configStore.getThemeById(theme);
+  }
+  if (!handledCustomTheme && !theme) {
+    throw new Error(`theme "${theme}" not found.`);
+  }
+  const gzhContent = await renderStyledContent(markdownContent, {
+    themeId: theme,
+    hlThemeId: highlight,
+    isMacStyle: macStyle,
+    isAddFootnote: footnote,
+    themeCss: handledCustomTheme
+  });
+  return gzhContent;
+}
 async function renderStyledContent(content, options = {}) {
   const preHandlerContent = await wenyanCoreInstance.handleFrontMatter(content);
   const html = await wenyanCoreInstance.renderMarkdown(preHandlerContent.body);
@@ -18,6 +209,71 @@ async function renderStyledContent(content, options = {}) {
     source_url: preHandlerContent.source_url
   };
 }
+async function prepareRenderContext(inputContent, options, getInputContent) {
+  const { content, absoluteDirPath } = await getInputContent(inputContent, options.file);
+  const gzhContent = await renderWithTheme(content, options);
+  return { gzhContent, absoluteDirPath };
+}
+async function listThemes() {
+  const themes = getAllGzhThemes();
+  const themeList = themes.map((theme) => {
+    return {
+      id: theme.meta.id,
+      name: theme.meta.name,
+      description: theme.meta.description,
+      isBuiltin: true
+    };
+  });
+  const customThemes = await configStore.getThemes();
+  if (customThemes.length > 0) {
+    customThemes.forEach((theme) => {
+      themeList.push({
+        id: theme.id,
+        name: theme.id,
+        description: theme.description,
+        isBuiltin: false
+      });
+    });
+  }
+  return themeList;
+}
+async function addTheme(name, path2) {
+  if (!name || !path2) {
+    throw new Error("添加主题时必须提供名称(name)和路径(path)");
+  }
+  if (checkThemeExists(name) || await checkCustomThemeExists(name)) {
+    throw new Error(`主题 "${name}" 已存在`);
+  }
+  if (path2.startsWith("http")) {
+    const response = await fetch(path2);
+    if (!response.ok) {
+      throw new Error(`无法从远程获取主题: ${response.statusText}`);
+    }
+    const content = await response.text();
+    await configStore.addThemeToConfig(name, content);
+  } else {
+    const normalizePath = getNormalizeFilePath(path2);
+    const content = await readFileContent(normalizePath);
+    await configStore.addThemeToConfig(name, content);
+  }
+}
+async function removeTheme(name) {
+  if (checkThemeExists(name)) {
+    throw new Error(`默认主题 "${name}" 不能删除`);
+  }
+  if (!await checkCustomThemeExists(name)) {
+    throw new Error(`自定义主题 "${name}" 不存在`);
+  }
+  await configStore.deleteThemeFromConfig(name);
+}
+function checkThemeExists(themeId) {
+  const themes = getAllGzhThemes();
+  return themes.some((theme) => theme.meta.id === themeId);
+}
+async function checkCustomThemeExists(themeId) {
+  const customThemes = await configStore.getThemes();
+  return customThemes.some((theme) => theme.id === themeId);
+}
 async function getGzhContent(content, themeId, hlThemeId, isMacStyle = true, isAddFootnote = true) {
   return await renderStyledContent(content, {
     themeId,
@@ -26,10 +282,64 @@ async function getGzhContent(content, themeId, hlThemeId, isMacStyle = true, isA
     isAddFootnote
   });
 }
+async function renderAndPublish(inputContent, options, getInputContent) {
+  const { gzhContent, absoluteDirPath } = await prepareRenderContext(inputContent, options, getInputContent);
+  if (!gzhContent.title) throw new Error("未能找到文章标题");
+  const data = await publishToWechatDraft(
+    {
+      title: gzhContent.title,
+      content: gzhContent.content,
+      cover: gzhContent.cover,
+      author: gzhContent.author,
+      source_url: gzhContent.source_url
+    },
+    {
+      relativePath: absoluteDirPath
+    }
+  );
+  if (data.media_id) {
+    return data.media_id;
+  } else {
+    throw new Error(`发布到微信公众号失败，
+${data}`);
+  }
+}
+async function renderAndPublishToServer(inputContent, options, getInputContent) {
+  const serverUrl = getServerUrl(options);
+  const headers = getHeaders(options);
+  await healthCheck(serverUrl);
+  await verifyAuth(serverUrl, headers);
+  const { gzhContent, absoluteDirPath } = await prepareRenderContext(inputContent, options, getInputContent);
+  if (!gzhContent.title) throw new Error("未能找到文章标题");
+  gzhContent.content = await uploadLocalImages(gzhContent.content, serverUrl, headers, absoluteDirPath);
+  gzhContent.cover = await uploadCover(serverUrl, headers, gzhContent.cover, absoluteDirPath);
+  const mdFileId = await uploadStyledContent(gzhContent, serverUrl, headers);
+  return await requestServerPublish(mdFileId, serverUrl, headers, options);
+}
 export {
-  c as configDir,
-  a as configPath,
-  b as configStore,
+  addTheme,
+  b as configDir,
+  d as configPath,
+  configStore,
+  e as ensureDir,
   getGzhContent,
-  renderStyledContent
+  getNormalizeFilePath,
+  i as isAbsolutePath,
+  listThemes,
+  m as md5FromBuffer,
+  f as md5FromFile,
+  n as normalizePath,
+  prepareRenderContext,
+  readBinaryFile,
+  readFileContent,
+  removeTheme,
+  renderAndPublish,
+  renderAndPublishToServer,
+  renderStyledContent,
+  renderWithTheme,
+  s as safeReadJson,
+  h as safeWriteJson,
+  t as tokenPath,
+  j as tokenStore,
+  u as uploadCacheStore
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenyan-md/core",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "Core library for Wenyan markdown rendering & publishing",
   "author": "Lei <caol64@gmail.com> (https://github.com/caol64)",
   "license": "Apache-2.0",
@@ -43,7 +43,6 @@
       "types": "./dist/types/wechat.d.ts"
     },
     "./http": {
-      "import": "./dist/http.js",
       "types": "./dist/types/http.d.ts"
     }
   },
@@ -80,17 +79,12 @@
     }
   },
   "scripts": {
-    "dev": "vite build --watch",
     "check": "tsc --noEmit",
     "build": "vite build && tsc",
-    "build:browser": "vite build --config vite.config.browser.ts",
-    "build:styles": "vite build --config vite.config.styles.ts",
-    "build:math": "vite build --config vite.config.math.ts",
-    "build:all": "pnpm build && pnpm build:styles && pnpm build:math && pnpm build:browser",
     "test": "pnpm build && vitest",
-    "test:wrapper": "vitest run test/wrapper.test.ts",
-    "test:publish": "vitest run test/publish.test.ts",
-    "test:realPublish": "vitest run test/realPublish.test.ts",
-    "test:runtimeEnv": "vitest run test/runtimeEnv.test.ts"
+    "test:wrapper": "vitest run tests/wrapper.test.ts",
+    "test:publish": "vitest run tests/publish.test.ts",
+    "test:realPublish": "vitest run tests/realPublish.test.ts",
+    "test:runtimeEnv": "vitest run tests/runtimeEnv.test.ts"
   }
 }

package/dist/configStore-lZ5bhrcC.js

@@ -1,111 +0,0 @@
-import path from "node:path";
-import os from "node:os";
-import fs from "node:fs";
-import crypto from "node:crypto";
-function safeReadJson(file, fallback) {
-  try {
-    return JSON.parse(fs.readFileSync(file, "utf-8"));
-  } catch {
-    return fallback;
-  }
-}
-function safeWriteJson(file, data) {
-  const tmp = file + ".tmp";
-  fs.writeFileSync(tmp, JSON.stringify(data ?? {}, null, 2), "utf-8");
-  fs.renameSync(tmp, file);
-}
-function ensureDir(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-function md5FromBuffer(buf) {
-  return crypto.createHash("md5").update(buf).digest("hex");
-}
-function md5FromFile(filePath) {
-  const buf = fs.readFileSync(filePath);
-  return md5FromBuffer(buf);
-}
-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 };
-  constructor() {
-    this.load();
-  }
-  load() {
-    ensureDir(configDir);
-    if (fs.existsSync(configPath)) {
-      this.config = {
-        ...defaultConfig,
-        ...safeReadJson(configPath, defaultConfig)
-      };
-    }
-  }
-  save() {
-    try {
-      ensureDir(configDir);
-      safeWriteJson(configPath, this.config);
-    } catch (error) {
-      console.error("❌ 无法保存配置文件:", error);
-    }
-  }
-  getConfig() {
-    return this.config;
-  }
-  getThemes() {
-    return Object.values(this.config.themes ?? {});
-  }
-  getThemeById(themeId) {
-    const themeOption = this.config.themes?.[themeId];
-    if (!themeOption) return;
-    const absoluteFilePath = path.join(configDir, themeOption.path);
-    try {
-      return fs.readFileSync(absoluteFilePath, "utf-8");
-    } catch {
-      return void 0;
-    }
-  }
-  addThemeToConfig(name, content) {
-    const savedPath = this.addThemeFile(name, content);
-    this.config.themes ??= {};
-    this.config.themes[name] = {
-      id: name,
-      name,
-      path: savedPath
-    };
-    this.save();
-  }
-  addThemeFile(themeId, themeContent) {
-    const filePath = `themes/${themeId}.css`;
-    const absoluteFilePath = path.join(configDir, filePath);
-    ensureDir(path.dirname(absoluteFilePath));
-    fs.writeFileSync(absoluteFilePath, themeContent, "utf-8");
-    return filePath;
-  }
-  deleteThemeFromConfig(themeId) {
-    const theme = this.config.themes?.[themeId];
-    if (!theme) return;
-    this.deleteThemeFile(theme.path);
-    delete this.config.themes[themeId];
-    this.save();
-  }
-  deleteThemeFile(filePath) {
-    try {
-      fs.unlinkSync(path.join(configDir, filePath));
-    } catch {
-    }
-  }
-}
-const configStore = new ConfigStore();
-export {
-  configPath as a,
-  configStore as b,
-  configDir as c,
-  safeWriteJson as d,
-  ensureDir as e,
-  md5FromFile as f,
-  md5FromBuffer as m,
-  safeReadJson as s
-};

package/dist/http.js

@@ -1 +0,0 @@
-