@skrillex1224/chrome-article-publish-extension 1.0.0

package/dist/adapters/index.js

@@ -0,0 +1,1900 @@
+import {
+  BaijiahaoAdapter,
+  BilibiliAdapter,
+  CSDNAdapter,
+  CnblogsAdapter,
+  CodeAdapter,
+  Cto51Adapter,
+  DouyinAdapter,
+  JuejinAdapter,
+  NeteaseAdapter,
+  SohuAdapter,
+  TencentAdapter,
+  ToutiaoAdapter,
+  WeixinAdapter
+} from "../chunk-QM2T4VGM.js";
+import {
+  markdownToDraft
+} from "../chunk-IUAZAMKF.js";
+import {
+  createLogger,
+  htmlToMarkdown,
+  parseMarkdownImages
+} from "../chunk-7Q3KKWUB.js";
+
+// src/adapters/types.ts
+var DEFAULT_PREPROCESS_CONFIG = {
+  outputFormat: "html",
+  removeIframes: true,
+  removeComments: true,
+  removeSpecialTags: true,
+  removeSvgImages: true,
+  processCodeBlocks: true,
+  processLazyImages: true,
+  removeEmptyElements: true,
+  removeDataAttributes: true,
+  removeSrcset: true,
+  removeSizes: true
+};
+
+// src/adapters/base.ts
+var BaseAdapter = class {
+  runtime;
+  context = {};
+  async init(runtime) {
+    this.runtime = runtime;
+  }
+  /**
+   * 发送请求
+   */
+  async request(url, options = {}) {
+    const response = await this.runtime.fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      return response.json();
+    }
+    return response.text();
+  }
+  /**
+   * 带重试的请求
+   */
+  async requestWithRetry(url, options = {}, maxRetries = 3) {
+    let lastError = null;
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        return await this.request(url, options);
+      } catch (error) {
+        lastError = error;
+        if (i < maxRetries - 1) {
+          await this.delay(1e3 * (i + 1));
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * 延迟
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 创建同步结果
+   */
+  createResult(success, data) {
+    return {
+      platform: this.meta.id,
+      success,
+      timestamp: Date.now(),
+      ...data
+    };
+  }
+};
+
+// src/adapters/registry.ts
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  runtime;
+  /**
+   * 设置运行时
+   */
+  setRuntime(runtime) {
+    this.runtime = runtime;
+    this.instances.clear();
+  }
+  /**
+   * 注册适配器
+   */
+  register(entry) {
+    this.adapters.set(entry.meta.id, entry);
+  }
+  /**
+   * 批量注册
+   */
+  registerAll(entries) {
+    entries.forEach((entry) => this.register(entry));
+  }
+  /**
+   * 获取适配器实例
+   */
+  async get(platformId) {
+    if (this.instances.has(platformId)) {
+      return this.instances.get(platformId);
+    }
+    const entry = this.adapters.get(platformId);
+    if (!entry) {
+      return null;
+    }
+    if (!this.runtime) {
+      throw new Error("Runtime not set. Call setRuntime() first.");
+    }
+    const adapter = entry.factory(this.runtime);
+    await adapter.init(this.runtime);
+    this.instances.set(platformId, adapter);
+    return adapter;
+  }
+  /**
+   * 获取所有平台元信息
+   */
+  getAllMeta() {
+    return Array.from(this.adapters.values()).map((entry) => entry.meta);
+  }
+  /**
+   * 检查平台是否已注册
+   */
+  has(platformId) {
+    return this.adapters.has(platformId);
+  }
+  /**
+   * 获取已注册的平台 ID 列表
+   */
+  getRegisteredIds() {
+    return Array.from(this.adapters.keys());
+  }
+  /**
+   * 清空注册
+   */
+  clear() {
+    this.adapters.clear();
+    this.instances.clear();
+  }
+  /**
+   * 获取平台的预处理配置
+   */
+  getPreprocessConfig(platformId) {
+    const entry = this.adapters.get(platformId);
+    return {
+      ...DEFAULT_PREPROCESS_CONFIG,
+      ...entry?.preprocessConfig || {}
+    };
+  }
+  /**
+   * 获取多个平台的预处理配置
+   */
+  getPreprocessConfigs(platformIds) {
+    const configs = {};
+    for (const id of platformIds) {
+      configs[id] = this.getPreprocessConfig(id);
+    }
+    return configs;
+  }
+};
+var adapterRegistry = new AdapterRegistry();
+function registerAdapter(entry) {
+  adapterRegistry.register(entry);
+}
+async function getAdapter(platformId) {
+  return adapterRegistry.get(platformId);
+}
+function getPreprocessConfig(platformId) {
+  return adapterRegistry.getPreprocessConfig(platformId);
+}
+function getPreprocessConfigs(platformIds) {
+  return adapterRegistry.getPreprocessConfigs(platformIds);
+}
+
+// src/adapters/platforms/douban.ts
+var logger = createLogger("Douban");
+var DoubanAdapter = class extends CodeAdapter {
+  meta = {
+    id: "douban",
+    name: "\u8C46\u74E3",
+    icon: "https://www.douban.com/favicon.ico",
+    homepage: "https://www.douban.com/note/create",
+    capabilities: ["article", "draft", "image_upload"]
+  };
+  /** 预处理配置: 豆瓣使用 Markdown 格式 (转换为 Draft.js) */
+  preprocessConfig = {
+    outputFormat: "markdown"
+  };
+  username = "";
+  avatar = "";
+  formData = null;
+  postParams = null;
+  /** 豆瓣 API 需要的 Header 规则 */
+  HEADER_RULES = [
+    {
+      urlFilter: "*://www.douban.com/*",
+      headers: {
+        "Origin": "https://www.douban.com",
+        "Referer": "https://www.douban.com"
+      },
+      resourceTypes: ["xmlhttprequest"]
+    }
+  ];
+  async checkAuth() {
+    try {
+      const response = await this.runtime.fetch(
+        "https://www.douban.com/note/create",
+        {
+          method: "GET",
+          credentials: "include"
+        }
+      );
+      const html = await response.text();
+      const userNameMatch = html.match(/_USER_NAME\s*=\s*['"]([^'"]+)['"]/);
+      const userAvatarMatch = html.match(/_USER_AVATAR\s*=\s*['"]([^'"]+)['"]/);
+      const noteIdMatch = html.match(/name="note_id"\s+value="(\d+)"/);
+      const ckMatch = html.match(/name="ck"\s+value="([^"]+)"/);
+      const postParamsMatch = html.match(/_POST_PARAMS\s*=\s*(\{[\s\S]*?\});/);
+      if (!userNameMatch || !noteIdMatch || !ckMatch) {
+        return { isAuthenticated: false };
+      }
+      this.username = userNameMatch[1];
+      this.avatar = userAvatarMatch ? userAvatarMatch[1] : "";
+      this.formData = {
+        note_id: noteIdMatch[1],
+        ck: ckMatch[1]
+      };
+      if (postParamsMatch) {
+        try {
+          const siteCookieMatch = postParamsMatch[1].match(/siteCookie[^}]*value\s*:\s*['"]([^'"]+)['"]/);
+          if (siteCookieMatch) {
+            this.postParams = {
+              siteCookie: { value: siteCookieMatch[1] }
+            };
+          }
+        } catch (e) {
+          logger.warn("Failed to parse _POST_PARAMS:", e);
+        }
+      }
+      logger.debug("Auth info:", {
+        username: this.username,
+        noteId: this.formData.note_id,
+        hasPostParams: !!this.postParams
+      });
+      return {
+        isAuthenticated: true,
+        userId: this.username,
+        username: this.username,
+        avatar: this.avatar
+      };
+    } catch (error) {
+      logger.debug("checkAuth: not logged in -", error);
+      return { isAuthenticated: false, error: error.message };
+    }
+  }
+  async publish(article, options) {
+    return this.withHeaderRules(this.HEADER_RULES, async () => {
+      logger.info("Starting publish...");
+      if (!this.formData) {
+        const auth = await this.checkAuth();
+        if (!auth.isAuthenticated) {
+          throw new Error("\u8BF7\u5148\u767B\u5F55\u8C46\u74E3");
+        }
+      }
+      let content = article.markdown || "";
+      const imageDataMap = /* @__PURE__ */ new Map();
+      content = await this.processImages(
+        content,
+        async (src) => {
+          const result = await this.uploadImageWithFullData(src);
+          imageDataMap.set(result.url, result.imageData);
+          return result;
+        },
+        {
+          skipPatterns: ["doubanio.com", "douban.com"],
+          onProgress: options?.onImageProgress
+        }
+      );
+      const draftContent = markdownToDraft(content, imageDataMap);
+      const response = await this.runtime.fetch(
+        "https://www.douban.com/j/note/autosave",
+        {
+          method: "POST",
+          credentials: "include",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded"
+          },
+          body: new URLSearchParams({
+            is_rich: "1",
+            note_id: this.formData.note_id,
+            note_title: article.title,
+            note_text: draftContent,
+            introduction: "",
+            note_privacy: "P",
+            cannot_reply: "",
+            author_tags: "",
+            accept_donation: "",
+            donation_notice: "",
+            is_original: "",
+            ck: this.formData.ck
+          })
+        }
+      );
+      const res = await response.json();
+      logger.debug("Save response:", res);
+      const draftUrl = "https://www.douban.com/note/create";
+      return this.createResult(true, {
+        postId: this.formData.note_id,
+        postUrl: draftUrl
+      });
+    }).catch((error) => this.createResult(false, {
+      error: error.message
+    }));
+  }
+  /**
+   * 上传图片并返回完整数据
+   */
+  async uploadImageWithFullData(src) {
+    if (!this.formData || !this.postParams) {
+      throw new Error("\u672A\u83B7\u53D6\u4E0A\u4F20\u51ED\u8BC1");
+    }
+    const imageResponse = await fetch(src);
+    if (!imageResponse.ok) {
+      throw new Error("\u56FE\u7247\u4E0B\u8F7D\u5931\u8D25: " + src);
+    }
+    const imageBlob = await imageResponse.blob();
+    const formData = new FormData();
+    formData.append("note_id", this.formData.note_id);
+    formData.append("image_file", imageBlob, "image.jpg");
+    formData.append("ck", this.formData.ck);
+    formData.append("upload_auth_token", this.postParams.siteCookie.value);
+    const uploadResponse = await this.runtime.fetch(
+      "https://www.douban.com/j/note/add_photo",
+      {
+        method: "POST",
+        credentials: "include",
+        body: formData
+      }
+    );
+    const res = await uploadResponse.json();
+    logger.debug("Image upload response:", res);
+    if (!res.photo?.url) {
+      throw new Error("\u56FE\u7247\u4E0A\u4F20\u5931\u8D25");
+    }
+    const photo = res.photo;
+    return {
+      url: photo.url,
+      imageData: {
+        id: photo.id,
+        url: photo.url,
+        thumb: photo.thumb,
+        width: photo.width,
+        height: photo.height,
+        file_name: photo.file_name,
+        file_size: photo.file_size
+      }
+    };
+  }
+};
+
+// src/adapters/platforms/xueqiu.ts
+import { Remarkable } from "remarkable";
+var logger2 = createLogger("Xueqiu");
+var XueqiuAdapter = class extends CodeAdapter {
+  meta = {
+    id: "xueqiu",
+    name: "\u96EA\u7403",
+    icon: "https://xqdoc.imedao.com/17aebcfb84a145d33fc18679.ico",
+    homepage: "https://mp.xueqiu.com/writeV2",
+    capabilities: ["article", "draft", "image_upload"]
+  };
+  /** 预处理配置: 雪球使用 Markdown 格式 */
+  preprocessConfig = {
+    outputFormat: "markdown",
+    // doPreFilter + processDocCode (旧版)
+    removeSpecialTags: true,
+    removeSpecialTagsWithParent: true,
+    processCodeBlocks: true
+  };
+  currentUser = null;
+  /** 雪球 API 需要的 Header 规则 */
+  HEADER_RULES = [
+    {
+      urlFilter: "*://mp.xueqiu.com/xq/*",
+      headers: {
+        "Origin": "https://mp.xueqiu.com",
+        "Referer": "https://mp.xueqiu.com/"
+      },
+      resourceTypes: ["xmlhttprequest"]
+    }
+  ];
+  async checkAuth() {
+    try {
+      const response = await this.runtime.fetch(
+        "https://mp.xueqiu.com/writeV2",
+        {
+          method: "GET",
+          credentials: "include"
+        }
+      );
+      const html = await response.text();
+      const userMatch = html.match(/window\.UOM_CURRENTUSER\s*=\s*(\{[\s\S]*?\})\s*<\/script>/);
+      if (!userMatch) {
+        return { isAuthenticated: false };
+      }
+      try {
+        const state = JSON.parse(userMatch[1]);
+        const { currentUser } = state;
+        if (!currentUser?.id) {
+          return { isAuthenticated: false };
+        }
+        this.currentUser = currentUser;
+        const avatar = currentUser.photo_domain && currentUser.profile_image_url ? `https:${currentUser.photo_domain}${currentUser.profile_image_url.split(",")[0]}` : "";
+        return {
+          isAuthenticated: true,
+          userId: String(currentUser.id),
+          username: currentUser.screen_name,
+          avatar
+        };
+      } catch (e) {
+        logger2.error(" Failed to parse user data:", e);
+        return { isAuthenticated: false };
+      }
+    } catch (error) {
+      logger2.debug("checkAuth: not logged in -", error);
+      return { isAuthenticated: false, error: error.message };
+    }
+  }
+  async publish(article, options) {
+    return this.withHeaderRules(this.HEADER_RULES, async () => {
+      logger2.info("Starting publish...");
+      if (!this.currentUser) {
+        const auth = await this.checkAuth();
+        if (!auth.isAuthenticated) {
+          throw new Error("\u8BF7\u5148\u767B\u5F55\u96EA\u7403");
+        }
+      }
+      let markdown = article.markdown || "";
+      markdown = await this.processImages(
+        markdown,
+        (src) => this.uploadImageByUrl(src),
+        {
+          skipPatterns: ["xueqiu.com", "imedao.com"],
+          onProgress: options?.onImageProgress
+        }
+      );
+      const md = new Remarkable({
+        html: true,
+        breaks: true
+      });
+      md.renderer.rules.heading_open = () => "<h4>";
+      md.renderer.rules.heading_close = () => "</h4>";
+      md.renderer.rules.strong_open = () => "<b>";
+      md.renderer.rules.strong_close = () => "</b>";
+      md.renderer.rules.em_open = () => "<i>";
+      md.renderer.rules.em_close = () => "</i>";
+      md.renderer.rules.bullet_list_open = () => "";
+      md.renderer.rules.bullet_list_close = () => "";
+      md.renderer.rules.ordered_list_open = () => "";
+      md.renderer.rules.ordered_list_close = () => "";
+      md.renderer.rules.list_item_open = () => "";
+      md.renderer.rules.list_item_close = () => "";
+      md.renderer.rules.hr = () => "";
+      md.renderer.rules.image = (tokens, idx) => {
+        const src = tokens[idx].src || "";
+        const alt = tokens[idx].alt || "";
+        return `<img src="${src}" alt="${alt}" class="ke_img">`;
+      };
+      let rendered = md.render(markdown);
+      rendered = rendered.replace(/<p>\s*<\/p>/g, "").replace(/\n{3,}/g, "\n\n").trim();
+      const content = rendered;
+      const formData = new URLSearchParams({
+        text: content,
+        title: article.title,
+        cover_pic: "",
+        flags: "false",
+        original_event: "",
+        status_id: "",
+        legal_user_visible: "false",
+        is_private: "false"
+      });
+      const response = await this.runtime.fetch(
+        "https://mp.xueqiu.com/xq/statuses/draft/save.json",
+        {
+          method: "POST",
+          credentials: "include",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded"
+          },
+          body: formData
+        }
+      );
+      const res = await response.json();
+      logger2.debug(" Save response:", res);
+      if (!res.id) {
+        throw new Error(res.error_description || "\u4FDD\u5B58\u5931\u8D25");
+      }
+      const postId = res.id;
+      const draftUrl = `https://mp.xueqiu.com/write/draft/${postId}`;
+      return this.createResult(true, {
+        postId: String(postId),
+        postUrl: draftUrl
+      });
+    }).catch((error) => this.createResult(false, {
+      error: error.message
+    }));
+  }
+  /**
+   * 通过 URL 上传图片
+   */
+  async uploadImageByUrl(src) {
+    const imageResponse = await fetch(src);
+    if (!imageResponse.ok) {
+      throw new Error("\u56FE\u7247\u4E0B\u8F7D\u5931\u8D25: " + src);
+    }
+    const imageBlob = await imageResponse.blob();
+    const formData = new FormData();
+    formData.append("file", imageBlob, "image.jpg");
+    const uploadResponse = await this.runtime.fetch(
+      "https://mp.xueqiu.com/xq/photo/upload.json",
+      {
+        method: "POST",
+        credentials: "include",
+        body: formData
+      }
+    );
+    const res = await uploadResponse.json();
+    logger2.debug(" Image upload response:", res);
+    if (!res.url || !res.filename) {
+      throw new Error("\u56FE\u7247\u4E0A\u4F20\u5931\u8D25");
+    }
+    const fullUrl = res.url.startsWith("//") ? `https:${res.url}/${res.filename}` : `${res.url}/${res.filename}`;
+    return {
+      url: fullUrl
+    };
+  }
+};
+
+// src/adapters/platforms/woshipm.ts
+var logger3 = createLogger("Woshipm");
+var WoshipmAdapter = class extends CodeAdapter {
+  meta = {
+    id: "woshipm",
+    name: "\u4EBA\u4EBA\u90FD\u662F\u4EA7\u54C1\u7ECF\u7406",
+    icon: "https://www.woshipm.com/favicon.ico",
+    homepage: "https://www.woshipm.com",
+    capabilities: ["article", "draft", "image_upload"]
+  };
+  /** 预处理配置: 人人都是产品经理使用 HTML 格式 */
+  preprocessConfig = {
+    outputFormat: "html",
+    removeEmptyLines: true
+  };
+  jltoken = "";
+  /** 人人都是产品经理 API 需要的 Header 规则 */
+  HEADER_RULES = [
+    {
+      urlFilter: "*://woshipm.com/wp-admin/admin-ajax.php*",
+      headers: { "X-Requested-With": "XMLHttpRequest" },
+      resourceTypes: ["xmlhttprequest"]
+    },
+    {
+      urlFilter: "*://woshipm.com/api2/*",
+      headers: { "X-Requested-With": "XMLHttpRequest" },
+      resourceTypes: ["xmlhttprequest"]
+    },
+    {
+      urlFilter: "*://woshipm.com/tensorflow/upyun/upload*",
+      headers: { "X-Requested-With": "XMLHttpRequest" },
+      resourceTypes: ["xmlhttprequest"]
+    }
+  ];
+  async checkAuth() {
+    try {
+      const pageResponse = await this.runtime.fetch("https://www.woshipm.com/writing", {
+        method: "GET",
+        credentials: "include"
+      });
+      const pageText = await pageResponse.text();
+      const jltokenMatch = pageText.match(/"jltoken"\s*:\s*"([^"]+)"/);
+      if (jltokenMatch) {
+        this.jltoken = jltokenMatch[1];
+        logger3.debug("Found jltoken");
+      }
+      const uidMatch = pageText.match(/var\s+userSettings\s*=\s*\{[^}]*"uid"\s*:\s*"(\d+)"/);
+      if (!uidMatch) {
+        return { isAuthenticated: false };
+      }
+      const uid = uidMatch[1];
+      const response = await this.runtime.fetch(
+        `https://www.woshipm.com/api2/user/profile?uid=${uid}`,
+        {
+          method: "GET",
+          credentials: "include",
+          headers: {
+            "X-Requested-With": "XMLHttpRequest"
+          }
+        }
+      );
+      const data = await response.json();
+      if (data.CODE === 200 && data.RESULT?.userInfoVo?.uid) {
+        return {
+          isAuthenticated: true,
+          userId: String(data.RESULT.userInfoVo.uid),
+          username: data.RESULT.userInfoVo.nickName,
+          avatar: data.RESULT.userInfoVo.avartar
+        };
+      }
+      return { isAuthenticated: false };
+    } catch (error) {
+      logger3.debug("checkAuth: not logged in -", error);
+      return { isAuthenticated: false, error: error.message };
+    }
+  }
+  async publish(article, options) {
+    return this.withHeaderRules(this.HEADER_RULES, async () => {
+      logger3.info("Starting publish...");
+      let content = article.html || "";
+      content = await this.processImages(
+        content,
+        (src) => this.uploadImageByUrl(src),
+        {
+          skipPatterns: ["woshipm.com", "image.woshipm.com"],
+          onProgress: options?.onImageProgress
+        }
+      );
+      const createResponse = await this.runtime.fetch(
+        "https://www.woshipm.com/wp-admin/admin-ajax.php",
+        {
+          method: "POST",
+          credentials: "include",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "X-Requested-With": "XMLHttpRequest"
+          },
+          body: new URLSearchParams({
+            action: "add_draft",
+            post_title: article.title,
+            post_content: content
+          })
+        }
+      );
+      const responseText = await createResponse.text();
+      logger3.debug("Create draft response:", createResponse.status, responseText.substring(0, 300));
+      if (!createResponse.ok) {
+        throw new Error(`\u521B\u5EFA\u8349\u7A3F\u5931\u8D25: ${createResponse.status} - ${responseText}`);
+      }
+      let createData;
+      try {
+        createData = JSON.parse(responseText);
+      } catch {
+        throw new Error(`\u521B\u5EFA\u8349\u7A3F\u5931\u8D25: \u54CD\u5E94\u4E0D\u662F\u6709\u6548 JSON - ${responseText.substring(0, 100)}`);
+      }
+      if (!createData.post_id) {
+        throw new Error(createData.error || "\u521B\u5EFA\u8349\u7A3F\u5931\u8D25: \u65E0\u6548\u54CD\u5E94");
+      }
+      const draftId = String(createData.post_id);
+      const draftUrl = createData.url || `https://www.woshipm.com/writing?pid=${draftId}`;
+      logger3.debug("Draft created:", draftId);
+      return this.createResult(true, {
+        postId: draftId,
+        postUrl: draftUrl
+      });
+    }).catch((error) => this.createResult(false, {
+      error: error.message
+    }));
+  }
+  /**
+   * 通过 Blob 上传图片（覆盖基类方法）
+   */
+  async uploadImage(file, filename) {
+    return this.uploadImageBinaryInternal(file, filename || "image.png");
+  }
+  /**
+   * 通过 URL 上传图片
+   */
+  async uploadImageByUrl(src) {
+    try {
+      const imageResponse = await this.runtime.fetch(src, {
+        credentials: "omit"
+      });
+      if (!imageResponse.ok) {
+        throw new Error(`Failed to fetch image: ${imageResponse.status}`);
+      }
+      const blob = await imageResponse.blob();
+      const url = await this.uploadImageBinaryInternal(blob, this.getFilenameFromUrl(src));
+      return { url };
+    } catch (error) {
+      logger3.warn("Failed to upload image by URL:", src, error);
+      return { url: src };
+    }
+  }
+  /**
+   * 上传图片 (二进制方式) - 内部使用
+   */
+  async uploadImageBinaryInternal(file, filename) {
+    const formData = new FormData();
+    formData.append("action", "wpuf_insert_image");
+    formData.append("name", filename);
+    formData.append("files", file, filename);
+    const headers = {
+      "Origin": "https://www.woshipm.com",
+      "Referer": "https://www.woshipm.com/writing"
+    };
+    if (this.jltoken) {
+      headers["jlstar"] = `Bearer ${this.jltoken}`;
+    }
+    const response = await this.runtime.fetch("https://www.woshipm.com/tensorflow/upyun/upload", {
+      method: "POST",
+      credentials: "include",
+      headers,
+      body: formData
+    });
+    const data = await response.json();
+    if (data.data && data.data.length > 0 && data.data[0].url) {
+      logger3.debug("Uploaded image:", filename, "->", data.data[0].url);
+      return data.data[0].url;
+    }
+    throw new Error(data.error || "Failed to upload image");
+  }
+  /**
+   * 从 URL 提取文件名
+   */
+  getFilenameFromUrl(url) {
+    try {
+      const pathname = new URL(url).pathname;
+      const filename = pathname.split("/").pop() || "image.png";
+      return filename;
+    } catch {
+      return "image.png";
+    }
+  }
+};
+
+// src/adapters/platforms/yuque.ts
+var logger4 = createLogger("Yuque");
+var YuqueAdapter = class extends CodeAdapter {
+  meta = {
+    id: "yuque",
+    name: "\u8BED\u96C0",
+    icon: "https://gw.alipayobjects.com/zos/rmsportal/UTjFYEzMSYVwzxIGVhMu.png",
+    homepage: "https://www.yuque.com/dashboard",
+    capabilities: ["article", "draft", "image_upload"]
+  };
+  /** 预处理配置: 语雀使用 Markdown 格式 (转换为 lake) */
+  preprocessConfig = {
+    outputFormat: "markdown",
+    // doPreFilter + processDocCode (旧版)
+    removeSpecialTags: true,
+    removeSpecialTagsWithParent: true,
+    processCodeBlocks: true
+  };
+  userInfo = null;
+  bookId = null;
+  csrfToken = "";
+  currentPostId = null;
+  /** 语雀 API 需要的 Header 规则 */
+  HEADER_RULES = [
+    {
+      urlFilter: "*://www.yuque.com/api/*",
+      headers: {
+        "Origin": "https://www.yuque.com",
+        "Referer": "https://www.yuque.com/dashboard"
+      },
+      resourceTypes: ["xmlhttprequest"]
+    }
+  ];
+  async getCsrfToken() {
+    if (this.runtime.getCookie) {
+      const value = await this.runtime.getCookie(".yuque.com", "yuque_ctoken");
+      if (!value) {
+        throw new Error("\u8BF7\u5148\u767B\u5F55\u8BED\u96C0");
+      }
+      return value;
+    }
+    throw new Error("\u8BF7\u5148\u767B\u5F55\u8BED\u96C0");
+  }
+  async checkAuth() {
+    try {
+      this.csrfToken = await this.getCsrfToken();
+      const response = await this.runtime.fetch(
+        "https://www.yuque.com/api/mine/common_used",
+        {
+          method: "GET",
+          credentials: "include",
+          headers: {
+            "x-csrf-token": this.csrfToken
+          }
+        }
+      );
+      const res = await response.json();
+      logger4.debug("checkAuth response:", res);
+      if (res.data?.books && res.data.books.length > 0) {
+        const firstBook = res.data.books[0];
+        this.userInfo = firstBook.user;
+        this.bookId = firstBook.target_id;
+        return {
+          isAuthenticated: true,
+          userId: String(firstBook.user.id),
+          username: firstBook.user.name,
+          avatar: firstBook.user.avatar_url
+        };
+      }
+      return { isAuthenticated: false };
+    } catch (error) {
+      logger4.debug("checkAuth: not logged in -", error.message);
+      return { isAuthenticated: false, error: error.message };
+    }
+  }
+  async publish(article, options) {
+    return this.withHeaderRules(this.HEADER_RULES, async () => {
+      logger4.info("Starting publish...");
+      if (!this.userInfo || !this.bookId) {
+        const auth = await this.checkAuth();
+        if (!auth.isAuthenticated) {
+          throw new Error("\u8BF7\u5148\u767B\u5F55\u8BED\u96C0");
+        }
+      }
+      const createResponse = await this.runtime.fetch(
+        "https://www.yuque.com/api/docs",
+        {
+          method: "POST",
+          credentials: "include",
+          headers: {
+            "Content-Type": "application/json",
+            "x-csrf-token": this.csrfToken
+          },
+          body: JSON.stringify({
+            title: article.title,
+            type: "Doc",
+            format: "lake",
+            book_id: this.bookId,
+            status: 0
+          })
+        }
+      );
+      const createRes = await createResponse.json();
+      logger4.debug("Create doc response:", createRes);
+      if (!createRes.data?.id) {
+        throw new Error(createRes.message || "\u521B\u5EFA\u6587\u6863\u5931\u8D25");
+      }
+      const postId = createRes.data.id;
+      this.currentPostId = postId;
+      let markdown = article.markdown || "";
+      markdown = await this.processImages(
+        markdown,
+        (src) => this.uploadImageByUrl(src),
+        {
+          skipPatterns: ["yuque.com", "cdn.nlark.com"],
+          onProgress: options?.onImageProgress
+        }
+      );
+      const convertResponse = await this.runtime.fetch(
+        "https://www.yuque.com/api/docs/convert",
+        {
+          method: "POST",
+          credentials: "include",
+          headers: {
+            "Content-Type": "application/json",
+            "x-csrf-token": this.csrfToken
+          },
+          body: JSON.stringify({
+            from: "markdown",
+            to: "lake",
+            content: markdown
+          })
+        }
+      );
+      const convertRes = await convertResponse.json();
+      if (!convertRes.data?.content) {
+        throw new Error("\u5185\u5BB9\u8F6C\u6362\u5931\u8D25");
+      }
+      const lakeContent = convertRes.data.content;
+      const saveResponse = await this.runtime.fetch(
+        `https://www.yuque.com/api/docs/${postId}/content`,
+        {
+          method: "PUT",
+          credentials: "include",
+          headers: {
+            "Content-Type": "application/json",
+            "x-csrf-token": this.csrfToken
+          },
+          body: JSON.stringify({
+            format: "lake",
+            body_asl: lakeContent,
+            body: `<div class="lake-content" typography="traditional">${lakeContent}</div>`,
+            body_html: `<div class="lake-content" typography="traditional">${lakeContent}</div>`,
+            draft_version: 0,
+            sync_dynamic_data: false,
+            save_type: "auto",
+            edit_type: "Lake"
+          })
+        }
+      );
+      const saveRes = await saveResponse.json();
+      logger4.debug("Save response:", saveRes);
+      const draftUrl = `https://www.yuque.com/go/doc/${postId}/edit`;
+      return this.createResult(true, {
+        postId: String(postId),
+        postUrl: draftUrl
+      });
+    }).catch((error) => this.createResult(false, {
+      error: error.message
+    }));
+  }
+  async uploadImageByUrl(src) {
+    if (!this.currentPostId) {
+      throw new Error("\u6587\u6863 ID \u672A\u8BBE\u7F6E");
+    }
+    const imageResponse = await fetch(src);
+    if (!imageResponse.ok) {
+      throw new Error("\u56FE\u7247\u4E0B\u8F7D\u5931\u8D25: " + src);
+    }
+    const imageBlob = await imageResponse.blob();
+    const formData = new FormData();
+    formData.append("file", imageBlob, "image.jpg");
+    const uploadUrl = `https://www.yuque.com/api/upload/attach?attachable_type=Doc&attachable_id=${this.currentPostId}&type=image`;
+    const uploadResponse = await this.runtime.fetch(uploadUrl, {
+      method: "POST",
+      credentials: "include",
+      headers: {
+        "x-csrf-token": this.csrfToken
+      },
+      body: formData
+    });
+    const res = await uploadResponse.json();
+    logger4.debug("Image upload response:", res);
+    if (!res.data?.url) {
+      throw new Error("\u56FE\u7247\u4E0A\u4F20\u5931\u8D25");
+    }
+    return {
+      url: res.data.url
+    };
+  }
+};
+
+// src/adapters/platforms/imooc.ts
+var ImoocAdapter = class extends CodeAdapter {
+  meta = {
+    id: "imooc",
+    name: "\u6155\u8BFE\u624B\u8BB0",
+    icon: "https://www.imooc.com/favicon.ico",
+    homepage: "https://www.imooc.com/article",
+    capabilities: ["article", "draft", "image_upload"]
+  };
+  /** 预处理配置: 慕课网使用 Markdown 格式 */
+  preprocessConfig = {
+    outputFormat: "markdown"
+  };
+  /** 慕课网 API 需要的 Header 规则 */
+  HEADER_RULES = [
+    {
+      urlFilter: "*://www.imooc.com/article/*",
+      headers: {
+        Origin: "https://www.imooc.com",
+        Referer: "https://www.imooc.com/"
+      },
+      resourceTypes: ["xmlhttprequest"]
+    }
+  ];
+  /**
+   * 检查登录状态
+   */
+  async checkAuth() {
+    return this.withHeaderRules(this.HEADER_RULES, async () => {
+      const response = await this.runtime.fetch("https://www.imooc.com/u/card", {
+        credentials: "include"
+      });
+      let text = await response.text();
+      text = text.replace("jsonpcallback(", "").replace("})", "}");
+      const result = JSON.parse(text);
+      if (result.result !== 0) {
+        return { isAuthenticated: false, error: result.msg || "\u672A\u767B\u5F55" };
+      }
+      return {
+        isAuthenticated: true,
+        userId: result.data.uid,
+        username: result.data.nickname,
+        avatar: result.data.img
+      };
+    }).catch((error) => ({ isAuthenticated: false, error: error.message }));
+  }
+  /**
+   * 上传图片
+   */
+  async uploadImageByUrl(url) {
+    const imageResponse = await this.runtime.fetch(url);
+    const blob = await imageResponse.blob();
+    const formData = new FormData();
+    const filename = `${Date.now()}.jpg`;
+    const file = new File([blob], filename, { type: blob.type || "image/jpeg" });
+    formData.append("photo", file, filename);
+    formData.append("type", file.type);
+    formData.append("id", "WU_FILE_0");
+    formData.append("name", filename);
+    formData.append("lastModifiedDate", (/* @__PURE__ */ new Date()).toString());
+    formData.append("size", String(file.size));
+    const response = await this.runtime.fetch(
+      "https://www.imooc.com/article/ajaxuploadimg",
+      {
+        method: "POST",
+        credentials: "include",
+        body: formData
+      }
+    );
+    const res = await response.json();
+    if (res.result !== 0) {
+      throw new Error(res.msg || "\u56FE\u7247\u4E0A\u4F20\u5931\u8D25");
+    }
+    let imgUrl = res.data.imgpath;
+    if (imgUrl.startsWith("//")) {
+      imgUrl = "https:" + imgUrl;
+    }
+    return { url: imgUrl };
+  }
+  /**
+   * 发布文章
+   */
+  async publish(article) {
+    const now = Date.now();
+    return this.withHeaderRules(this.HEADER_RULES, async () => {
+      let content = article.markdown || article.html || "";
+      content = await this.processImages(content, (src) => this.uploadImageByUrl(src));
+      const response = await this.runtime.fetch("https://www.imooc.com/article/savedraft", {
+        method: "POST",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: new URLSearchParams({
+          editor: "0",
+          draft_id: "0",
+          title: article.title,
+          content
+        })
+      });
+      const res = await response.json();
+      if (!res.data) {
+        throw new Error("\u53D1\u5E03\u5931\u8D25");
+      }
+      return {
+        platform: this.meta.id,
+        success: true,
+        postId: res.data,
+        postUrl: `https://www.imooc.com/article/draft/id/${res.data}`,
+        timestamp: now
+      };
+    }).catch((error) => ({
+      platform: this.meta.id,
+      success: false,
+      error: error.message,
+      timestamp: now
+    }));
+  }
+};
+
+// src/adapters/platforms/oschina.ts
+var OschinaAdapter = class extends CodeAdapter {
+  meta = {
+    id: "oschina",
+    name: "\u5F00\u6E90\u4E2D\u56FD",
+    icon: "https://www.oschina.net/favicon.ico",
+    homepage: "https://my.oschina.net",
+    capabilities: ["article", "draft", "image_upload"]
+  };
+  /** 预处理配置: 开源中国使用 Markdown 格式 */
+  preprocessConfig = {
+    outputFormat: "markdown"
+  };
+  userId = null;
+  /** 开源中国 API 需要的 Header 规则 */
+  HEADER_RULES = [
+    {
+      urlFilter: "*://apiv1.oschina.net/oschinapi/*",
+      headers: {
+        Origin: "https://my.oschina.net",
+        Referer: "https://my.oschina.net/"
+      },
+      resourceTypes: ["xmlhttprequest"]
+    }
+  ];
+  /**
+   * 检查登录状态
+   */
+  async checkAuth() {
+    try {
+      const response = await this.runtime.fetch("https://apiv1.oschina.net/oschinapi/user/myDetails", {
+        credentials: "include"
+      });
+      const data = await response.json();
+      if (!data.success || !data.result?.userId) {
+        return { isAuthenticated: false, error: "\u672A\u767B\u5F55" };
+      }
+      this.userId = String(data.result.userId);
+      return {
+        isAuthenticated: true,
+        userId: this.userId,
+        username: data.result.userVo?.name || this.userId,
+        avatar: data.result.userVo?.portraitUrl
+      };
+    } catch (error) {
+      return { isAuthenticated: false, error: error.message };
+    }
+  }
+  /**
+   * 上传图片
+   */
+  async uploadImageByUrl(url) {
+    if (!this.userId) {
+      await this.checkAuth();
+    }
+    const imageResponse = await this.runtime.fetch(url);
+    const blob = await imageResponse.blob();
+    const filename = this.getFilenameFromUrl(url) || "image";
+    const formData = new FormData();
+    formData.append("file", blob, filename);
+    const response = await this.runtime.fetch(
+      "https://apiv1.oschina.net/oschinapi/ai/creation/project/uploadDetail",
+      {
+        method: "POST",
+        credentials: "include",
+        body: formData
+      }
+    );
+    const res = await response.json();
+    if (!res.success || !res.result) {
+      throw new Error(res.message || "\u56FE\u7247\u4E0A\u4F20\u5931\u8D25");
+    }
+    return { url: res.result };
+  }
+  getFilenameFromUrl(url) {
+    try {
+      const pathname = new URL(url).pathname;
+      const name = pathname.split("/").pop();
+      return name && name.trim() ? name : null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * 发布文章
+   */
+  async publish(article) {
+    const now = Date.now();
+    return this.withHeaderRules(this.HEADER_RULES, async () => {
+      if (!this.userId) {
+        const auth = await this.checkAuth();
+        if (!auth.isAuthenticated) {
+          throw new Error("\u672A\u767B\u5F55");
+        }
+      }
+      const rawMarkdown = article.markdown || "";
+      const rawHtml = article.html || "";
+      const useMarkdown = rawMarkdown.trim().length > 0;
+      let content = useMarkdown ? rawMarkdown : rawHtml;
+      content = await this.processImages(content, (src) => this.uploadImageByUrl(src));
+      const response = await this.runtime.fetch(
+        "https://apiv1.oschina.net/oschinapi/api/draft/save_draft",
+        {
+          method: "POST",
+          credentials: "include",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            title: article.title,
+            user: Number(this.userId),
+            content,
+            contentType: useMarkdown ? 1 : 2,
+            // 1=markdown, 2=html
+            catalog: 0,
+            originUrl: "",
+            privacy: true,
+            disableComment: false
+          })
+        }
+      );
+      const res = await response.json();
+      if (!res.success || !res.result?.id) {
+        throw new Error(res.message || "\u53D1\u5E03\u5931\u8D25");
+      }
+      const draftId = String(res.result.id);
+      return {
+        platform: this.meta.id,
+        success: true,
+        postId: draftId,
+        postUrl: `https://my.oschina.net/u/${this.userId}/blog/write/draft/${draftId}`,
+        timestamp: now
+      };
+    }).catch((error) => ({
+      platform: this.meta.id,
+      success: false,
+      error: error.message,
+      timestamp: now
+    }));
+  }
+};
+
+// src/adapters/platforms/segmentfault.ts
+var SegmentfaultAdapter = class extends CodeAdapter {
+  meta = {
+    id: "segmentfault",
+    name: "\u601D\u5426",
+    icon: "https://imgcache.iyiou.com/Company/2016-05-11/cf-segmentfault.jpg",
+    homepage: "https://segmentfault.com/user/draft",
+    capabilities: ["article", "draft", "image_upload"]
+  };
+  /** 预处理配置: 思否使用 Markdown 格式 */
+  preprocessConfig = {
+    outputFormat: "markdown"
+  };
+  sessionToken = null;
+  /** 思否 API 需要的 Header 规则 */
+  HEADER_RULES = [
+    {
+      urlFilter: "*://segmentfault.com/gateway/*",
+      headers: {
+        Origin: "https://segmentfault.com",
+        Referer: "https://segmentfault.com/"
+      },
+      resourceTypes: ["xmlhttprequest"]
+    }
+  ];
+  /**
+   * 检查登录状态
+   */
+  async checkAuth() {
+    try {
+      const response = await this.runtime.fetch("https://segmentfault.com/user/settings", {
+        credentials: "include"
+      });
+      const html = await response.text();
+      const userLinkMatch = html.match(/href="\/u\/([^"]+)"/);
+      if (!userLinkMatch) {
+        return { isAuthenticated: false, error: "\u672A\u767B\u5F55" };
+      }
+      const uid = userLinkMatch[1];
+      const avatarMatch = html.match(/src="(https:\/\/avatar-static\.segmentfault\.com\/[^"]+)"/);
+      const avatar = avatarMatch ? avatarMatch[1] : void 0;
+      return {
+        isAuthenticated: true,
+        userId: uid,
+        username: uid,
+        avatar
+      };
+    } catch (error) {
+      return { isAuthenticated: false, error: error.message };
+    }
+  }
+  /**
+   * 获取 session token
+   */
+  async getSessionToken() {
+    const response = await this.runtime.fetch("https://segmentfault.com/write", {
+      credentials: "include"
+    });
+    const html = await response.text();
+    const tokenMatch = html.match(/serverData":\s*\{\s*"Token"\s*:\s*"([^"]+)"/);
+    if (tokenMatch) {
+      return tokenMatch[1];
+    }
+    const markStr = "window.g_initialProps = ";
+    const authIndex = html.indexOf(markStr);
+    if (authIndex === -1) {
+      throw new Error("\u83B7\u53D6 session token \u5931\u8D25");
+    }
+    const endIndex = html.indexOf(";\n	</script>", authIndex);
+    if (endIndex === -1) {
+      throw new Error("\u89E3\u6790 session token \u5931\u8D25");
+    }
+    const configStr = html.substring(authIndex + markStr.length, endIndex);
+    try {
+      const config = JSON.parse(configStr);
+      const token = config?.global?.sessionInfo?.key;
+      if (!token) {
+        throw new Error("session token \u4E3A\u7A7A");
+      }
+      return token;
+    } catch (e) {
+      throw new Error("\u89E3\u6790 session token \u5931\u8D25: " + e.message);
+    }
+  }
+  /**
+   * 上传图片
+   */
+  async uploadImageByUrl(url) {
+    if (!this.sessionToken) {
+      throw new Error("\u672A\u83B7\u53D6 token");
+    }
+    const imageResponse = await this.runtime.fetch(url);
+    const blob = await imageResponse.blob();
+    const formData = new FormData();
+    formData.append("image", blob);
+    const response = await this.runtime.fetch(
+      "https://segmentfault.com/gateway/image",
+      {
+        method: "POST",
+        credentials: "include",
+        headers: {
+          token: this.sessionToken
+        },
+        body: formData
+      }
+    );
+    const text = await response.text();
+    if (text === "Unauthorized" || text.includes("\u7981\u8A00") || text.includes("\u9501\u5B9A")) {
+      throw new Error(text === "Unauthorized" ? "\u672A\u6388\u6743" : text);
+    }
+    let res;
+    try {
+      res = JSON.parse(text);
+    } catch {
+      throw new Error("\u56FE\u7247\u4E0A\u4F20\u5931\u8D25: " + text);
+    }
+    const imageUrl = res.result || (Array.isArray(res) ? res[0] === 1 ? null : res[1] || `https://image-static.segmentfault.com/${res[2]}` : null);
+    if (!imageUrl) {
+      throw new Error(Array.isArray(res) ? res[1] || "\u56FE\u7247\u4E0A\u4F20\u5931\u8D25" : "\u56FE\u7247\u4E0A\u4F20\u5931\u8D25");
+    }
+    return { url: imageUrl };
+  }
+  /**
+   * 发布文章
+   */
+  async publish(article) {
+    const now = Date.now();
+    return this.withHeaderRules(this.HEADER_RULES, async () => {
+      this.sessionToken = await this.getSessionToken();
+      let content = article.markdown || article.html || "";
+      content = await this.processImages(content, (src) => this.uploadImageByUrl(src));
+      const postData = {
+        title: article.title,
+        tags: [],
+        text: content,
+        object_id: "",
+        type: "article"
+      };
+      const response = await this.runtime.fetch("https://segmentfault.com/gateway/draft", {
+        method: "POST",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/json",
+          token: this.sessionToken,
+          accept: "*/*"
+        },
+        body: JSON.stringify(postData)
+      });
+      const text = await response.text();
+      if (text === "Unauthorized" || text.includes("\u7981\u8A00") || text.includes("\u9501\u5B9A")) {
+        throw new Error(text === "Unauthorized" ? "\u672A\u6388\u6743" : text);
+      }
+      let res;
+      try {
+        res = JSON.parse(text);
+      } catch {
+        throw new Error("\u53D1\u5E03\u5931\u8D25: " + text);
+      }
+      if (Array.isArray(res)) {
+        if (res[0] === 1) {
+          throw new Error(res[1] || "\u53D1\u5E03\u5931\u8D25");
+        }
+        const data = res[1];
+        if (data?.id) {
+          return {
+            platform: this.meta.id,
+            success: true,
+            postId: data.id,
+            postUrl: `https://segmentfault.com/write?draftId=${data.id}`,
+            timestamp: now
+          };
+        }
+      }
+      if (!res.id) {
+        const errorMsg = res.message || res.msg || res.error || res.errMsg || JSON.stringify(res);
+        throw new Error(errorMsg);
+      }
+      return {
+        platform: this.meta.id,
+        success: true,
+        postId: res.id,
+        postUrl: `https://segmentfault.com/write?draftId=${res.id}`,
+        timestamp: now
+      };
+    }).catch((error) => ({
+      platform: this.meta.id,
+      success: false,
+      error: error.message,
+      timestamp: now
+    }));
+  }
+};
+
+// src/adapters/platforms/zip-download.ts
+import JSZip from "jszip";
+var logger5 = createLogger("ZipDownload");
+var ZipDownloadAdapter = class extends CodeAdapter {
+  meta = {
+    id: "zip-download",
+    name: "Markdown \u538B\u7F29\u5305",
+    icon: "https://cdn-icons-png.flaticon.com/512/337/337946.png",
+    homepage: "",
+    capabilities: ["article"]
+  };
+  /**
+   * 本地导出不需要认证
+   */
+  async checkAuth() {
+    return {
+      isAuthenticated: true,
+      username: "\u672C\u5730\u4E0B\u8F7D"
+    };
+  }
+  /**
+   * 导出为 ZIP 压缩包
+   */
+  async publish(article, options) {
+    try {
+      const zip = new JSZip();
+      const imgFolder = zip.folder("images");
+      let markdown = article.markdown || htmlToMarkdown(article.html || "");
+      if (!markdown.trim()) {
+        return this.createResult(false, {
+          error: "\u6587\u7AE0\u5185\u5BB9\u4E3A\u7A7A"
+        });
+      }
+      const title = article.title || "\u672A\u547D\u540D\u6587\u7AE0";
+      if (!markdown.startsWith("# ")) {
+        markdown = `# ${title}
+
+${markdown}`;
+      }
+      const { processedMarkdown, imageCount } = await this.processImagesForZip(
+        markdown,
+        imgFolder,
+        options?.onImageProgress
+      );
+      zip.file("article.md", processedMarkdown);
+      const blob = await zip.generateAsync({
+        type: "blob",
+        compression: "DEFLATE",
+        compressionOptions: { level: 6 }
+      });
+      const filename = this.sanitizeFilename(title) + ".zip";
+      if (!this.runtime.downloads) {
+        return this.createResult(false, {
+          error: "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301\u4E0B\u8F7D\u529F\u80FD"
+        });
+      }
+      const downloadId = await this.runtime.downloads.download(blob, filename, true);
+      logger5.info(`Download started: ${filename}, id: ${downloadId}`);
+      return this.createResult(true, {
+        postId: String(downloadId),
+        postUrl: "",
+        // 本地下载，无链接
+        message: `\u5DF2\u4E0B\u8F7D ${filename}\uFF08${imageCount} \u5F20\u56FE\u7247\uFF09`
+      });
+    } catch (error) {
+      logger5.error("ZIP download failed:", error);
+      return this.createResult(false, {
+        error: error.message
+      });
+    }
+  }
+  /**
+   * 处理 Markdown 中的图片：下载并添加到 ZIP
+   */
+  async processImagesForZip(markdown, imgFolder, onProgress) {
+    const matches = parseMarkdownImages(markdown);
+    if (matches.length === 0) {
+      return { processedMarkdown: markdown, imageCount: 0 };
+    }
+    logger5.info(`Found ${matches.length} images to process`);
+    const timestamp = Math.floor(Date.now() / 1e3);
+    let processedMarkdown = markdown;
+    let imageIndex = 0;
+    let completed = 0;
+    const urlToFilename = /* @__PURE__ */ new Map();
+    const uniqueUrls = [];
+    for (const { src } of matches) {
+      if (src.startsWith("data:")) {
+        logger5.debug("Skipping data URI image");
+        continue;
+      }
+      if (!urlToFilename.has(src)) {
+        urlToFilename.set(src, "");
+        uniqueUrls.push(src);
+      }
+    }
+    if (uniqueUrls.length === 0) {
+      return { processedMarkdown: markdown, imageCount: 0 };
+    }
+    const downloadOne = async (src) => {
+      try {
+        const response = await this.runtime.fetch(src, {
+          credentials: "omit"
+        });
+        if (!response.ok) {
+          logger5.warn(`Failed to download image: ${src}, status: ${response.status}`);
+          return;
+        }
+        const blob = await response.blob();
+        const ext = this.getImageExtension(src, blob.type);
+        imageIndex++;
+        const filename = `image_${timestamp}_${String(imageIndex).padStart(3, "0")}.${ext}`;
+        imgFolder.file(filename, blob);
+        urlToFilename.set(src, filename);
+        logger5.debug(`Downloaded image: ${filename}`);
+      } catch (error) {
+        logger5.warn(`Failed to download image: ${src}`, error);
+      } finally {
+        completed++;
+        onProgress?.(completed, uniqueUrls.length);
+      }
+    };
+    const runPool = async (limit) => {
+      let cursor = 0;
+      const workers = Array.from({ length: Math.min(limit, uniqueUrls.length) }, async () => {
+        while (cursor < uniqueUrls.length) {
+          const current = cursor;
+          cursor++;
+          await downloadOne(uniqueUrls[current]);
+        }
+      });
+      await Promise.all(workers);
+    };
+    await runPool(4);
+    for (const { full, alt, src } of matches) {
+      const filename = urlToFilename.get(src);
+      if (filename) {
+        processedMarkdown = processedMarkdown.replace(full, `![${alt}](images/${filename})`);
+      }
+    }
+    return {
+      processedMarkdown,
+      imageCount: Array.from(urlToFilename.values()).filter(Boolean).length
+    };
+  }
+  /**
+   * 获取图片扩展名
+   */
+  getImageExtension(url, mimeType) {
+    const mimeMap = {
+      "image/jpeg": "jpg",
+      "image/png": "png",
+      "image/gif": "gif",
+      "image/webp": "webp",
+      "image/svg+xml": "svg",
+      "image/bmp": "bmp",
+      "image/x-icon": "ico"
+    };
+    if (mimeType && mimeMap[mimeType]) {
+      return mimeMap[mimeType];
+    }
+    const urlMatch = url.match(/\.(png|jpe?g|gif|webp|svg|bmp|ico)(?:\?|$)/i);
+    if (urlMatch) {
+      return urlMatch[1].toLowerCase().replace("jpeg", "jpg");
+    }
+    return "png";
+  }
+  /**
+   * 清理文件名，移除非法字符
+   */
+  sanitizeFilename(name) {
+    return name.replace(/[<>:"/\\|?*]/g, "_").replace(/[\x00-\x1f]/g, "").replace(/\.+$/, "").trim().slice(0, 200) || "article";
+  }
+};
+
+// src/adapters/platforms/eastmoney.ts
+var logger6 = createLogger("Eastmoney");
+var EastmoneyAdapter = class extends CodeAdapter {
+  meta = {
+    id: "eastmoney",
+    name: "\u4E1C\u65B9\u8D22\u5BCC",
+    icon: "https://mp.eastmoney.com/collect/pc_article/favicon.ico",
+    homepage: "https://mp.eastmoney.com",
+    capabilities: ["article", "draft", "image_upload", "cover"]
+  };
+  /** 预处理配置 */
+  preprocessConfig = {
+    outputFormat: "html",
+    removeComments: true,
+    removeSpecialTags: true,
+    processCodeBlocks: true,
+    convertSectionToDiv: true,
+    removeEmptyLines: true,
+    removeEmptyDivs: true,
+    removeNestedEmptyContainers: true,
+    unwrapSingleChildContainers: true,
+    unwrapNestedFigures: true,
+    removeTrailingBr: true,
+    removeDataAttributes: true,
+    removeSrcset: true,
+    removeSizes: true,
+    compactHtml: true
+  };
+  ctoken = "";
+  utoken = "";
+  deviceId = "";
+  /** 获取或生成持久化 deviceId（32位大写 hex） */
+  async getDeviceId() {
+    if (this.deviceId) return this.deviceId;
+    const stored = await this.runtime.storage.get("eastmoney_deviceId");
+    if (stored) {
+      this.deviceId = stored;
+      return this.deviceId;
+    }
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    this.deviceId = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0").toUpperCase()).join("");
+    await this.runtime.storage.set("eastmoney_deviceId", this.deviceId);
+    return this.deviceId;
+  }
+  /** API Header 规则 */
+  HEADER_RULES = [
+    {
+      urlFilter: "*://mp.eastmoney.com/*",
+      headers: {
+        Origin: "https://mp.eastmoney.com",
+        HOST: "emfront.eastmoney.com"
+      },
+      resourceTypes: ["xmlhttprequest"]
+    }
+  ];
+  async checkAuth() {
+    try {
+      await this.fetchToken();
+      const response = await this.runtime.fetch(
+        `https://caifuhaoapi.eastmoney.com/api/v2/getauthorinfo?platform=&ctoken=${this.ctoken}&utoken=${this.utoken}`,
+        {
+          method: "GET",
+          credentials: "include",
+          headers: { "x-requested-with": "fetch" }
+        }
+      );
+      const data = await response.json();
+      if (data.Success === 1 && data.Result?.accountId) {
+        return {
+          isAuthenticated: true,
+          userId: data.Result.accountId,
+          username: data.Result.accountName,
+          avatar: data.Result.portrait
+        };
+      }
+      return { isAuthenticated: false };
+    } catch (error) {
+      logger6.debug("checkAuth: not logged in -", error);
+      return { isAuthenticated: false, error: error.message };
+    }
+  }
+  /** 从 cookie 读取 token */
+  async fetchToken() {
+    if (!this.runtime.getCookie) {
+      throw new Error("Cookie API \u4E0D\u53EF\u7528\uFF0C\u8BF7\u5148\u767B\u5F55\u4E1C\u65B9\u8D22\u5BCC");
+    }
+    const ctoken = await this.runtime.getCookie(".eastmoney.com", "ct");
+    const utoken = await this.runtime.getCookie(".eastmoney.com", "ut");
+    if (!ctoken || !utoken) {
+      throw new Error("\u672A\u68C0\u6D4B\u5230\u767B\u5F55\u4FE1\u606F\uFF0C\u8BF7\u5148\u767B\u5F55\u4E1C\u65B9\u8D22\u5BCC");
+    }
+    this.ctoken = ctoken;
+    this.utoken = utoken;
+  }
+  async publish(article, options) {
+    return this.withHeaderRules(this.HEADER_RULES, async () => {
+      await this.fetchToken();
+      logger6.info("Starting publish to eastmoney...");
+      const draftId = await this.createDraft(article.title);
+      logger6.debug("Draft created:", draftId);
+      const content = await this.processImages(
+        article.html || "",
+        (src) => this.uploadImageByUrl(src),
+        {
+          skipPatterns: ["gbres.dfcfw.com"],
+          onProgress: options?.onImageProgress
+        }
+      );
+      await this.updateDraft(draftId, article.title, content);
+      logger6.debug("Draft updated");
+      const draftUrl = `https://mp.eastmoney.com/collect/pc_article/index.html#/?id=${draftId}`;
+      return this.createResult(true, {
+        postId: draftId,
+        postUrl: draftUrl
+      });
+    }).catch(
+      (error) => this.createResult(false, {
+        error: error.message
+      })
+    );
+  }
+  /** 构造 API 参数 */
+  async buildParm(params) {
+    const deviceid = await this.getDeviceId();
+    return [
+      { ip: "$IP$" },
+      { deviceid },
+      { version: "100" },
+      { plat: "web" },
+      { product: "CFH" },
+      { ctoken: this.ctoken },
+      { utoken: this.utoken },
+      { draftid: params.draftid ?? "" },
+      { drafttype: "0" },
+      { type: "0" },
+      { title: encodeURIComponent(params.title) },
+      { text: encodeURIComponent(params.text) },
+      { columns: "2" },
+      { cover: "" },
+      { issimplevideo: "0" },
+      { videos: "" },
+      { vods: "" },
+      { isoriginal: "0" },
+      { tgProduct: "" },
+      { spcolumns: "" },
+      { textsource: "0" },
+      { replyauthority: "" },
+      { modules: encodeURIComponent("[]") }
+    ];
+  }
+  /** 调用草稿 API */
+  async callDraftApi(parm, draftId) {
+    const pageUrl = draftId ? `https://mp.eastmoney.com/collect/pc_article/index.html#/?id=${draftId}` : "https://mp.eastmoney.com/collect/pc_article/index.html#/";
+    const body = JSON.stringify({
+      pageUrl,
+      path: "draft/api/Article/SaveDraft",
+      parm: JSON.stringify(parm)
+    });
+    const response = await this.runtime.fetch(
+      "https://emfront.eastmoney.com/apifront/Tran/GetData?platform=",
+      {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+        body
+      }
+    );
+    const responseText = await response.text();
+    logger6.debug(
+      "Draft API response:",
+      response.status,
+      responseText.substring(0, 200)
+    );
+    if (!response.ok) {
+      throw new Error(`\u8349\u7A3F API \u8BF7\u6C42\u5931\u8D25: ${response.status}`);
+    }
+    let rawData;
+    try {
+      rawData = JSON.parse(responseText);
+    } catch {
+      throw new Error("\u8349\u7A3F API \u54CD\u5E94\u4E0D\u662F\u6709\u6548 JSON");
+    }
+    if (!rawData.RRquestSuccess || rawData.RCode !== 200) {
+      throw new Error(`\u8349\u7A3F API \u9519\u8BEF: ${rawData.RMsg || "\u672A\u77E5\u9519\u8BEF"}`);
+    }
+    let innerData;
+    try {
+      innerData = JSON.parse(rawData.RData);
+    } catch {
+      throw new Error("\u65E0\u6CD5\u89E3\u6790\u8349\u7A3F\u54CD\u5E94\u6570\u636E");
+    }
+    if (innerData.error_code !== 0) {
+      throw new Error(`\u8349\u7A3F\u4E1A\u52A1\u9519\u8BEF: ${innerData.me || "\u672A\u77E5\u9519\u8BEF"}`);
+    }
+    return innerData;
+  }
+  async createDraft(title) {
+    const parm = await this.buildParm({
+      title,
+      text: '<div class="xeditor_content cfh_web"></div>'
+    });
+    const result = await this.callDraftApi(parm);
+    if (!result.draft_id) {
+      throw new Error("\u521B\u5EFA\u8349\u7A3F\u5931\u8D25: \u54CD\u5E94\u7F3A\u5C11 draft_id");
+    }
+    return result.draft_id;
+  }
+  async updateDraft(draftId, title, content) {
+    const parm = await this.buildParm({
+      draftid: draftId,
+      title,
+      text: `<div class="xeditor_content cfh_web">${content}</div>`
+    });
+    await this.callDraftApi(parm, draftId);
+  }
+  /** URL 上传图片 */
+  async uploadImageByUrl(src) {
+    if (src.startsWith("data:")) {
+      logger6.debug("Detected data URI, using binary upload");
+      const blob = await this.dataUriToBlob(src);
+      return this.uploadImageBlob(blob);
+    }
+    const response = await this.runtime.fetch(
+      "https://gbapi.eastmoney.com/iimage/image/byLink?platform=",
+      {
+        method: "PUT",
+        credentials: "include",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          noinlist: "1",
+          linkUrl: src,
+          ctoken: this.ctoken,
+          utoken: this.utoken
+        })
+      }
+    );
+    const res = await response.json();
+    if (res.code === 200 && res.data?.url) {
+      return { url: res.data.url };
+    }
+    throw new Error(
+      `\u56FE\u7247\u4E0A\u4F20\u5931\u8D25: ${res.message || "\u672A\u77E5\u9519\u8BEF"} (code: ${res.code})`
+    );
+  }
+  /** 上传图片 Blob */
+  async uploadImageBlob(file) {
+    const ext = file.type.split("/")[1] || "png";
+    const filename = `${Date.now()}.${ext}`;
+    const formData = new FormData();
+    formData.append("file", file, filename);
+    formData.append("noinlist", "1");
+    formData.append("utoken", this.utoken);
+    formData.append("ctoken", this.ctoken);
+    const response = await this.runtime.fetch(
+      "https://gbapi.eastmoney.com/iimage/image?platform=",
+      {
+        method: "POST",
+        credentials: "include",
+        body: formData
+      }
+    );
+    const res = await response.json();
+    if (res.code === 200 && res.data?.url) {
+      return { url: res.data.url };
+    }
+    throw new Error(
+      `\u56FE\u7247\u4E0A\u4F20\u5931\u8D25: ${res.message || "\u672A\u77E5\u9519\u8BEF"} (code: ${res.code})`
+    );
+  }
+};
+export {
+  BaijiahaoAdapter,
+  BaseAdapter,
+  BilibiliAdapter,
+  CSDNAdapter,
+  CnblogsAdapter,
+  CodeAdapter,
+  Cto51Adapter,
+  DEFAULT_PREPROCESS_CONFIG,
+  DoubanAdapter,
+  DouyinAdapter,
+  EastmoneyAdapter,
+  ImoocAdapter,
+  JuejinAdapter,
+  NeteaseAdapter,
+  OschinaAdapter,
+  SegmentfaultAdapter,
+  SohuAdapter,
+  TencentAdapter,
+  ToutiaoAdapter,
+  WeixinAdapter,
+  WoshipmAdapter,
+  XueqiuAdapter,
+  YuqueAdapter,
+  ZipDownloadAdapter,
+  adapterRegistry,
+  getAdapter,
+  getPreprocessConfig,
+  getPreprocessConfigs,
+  registerAdapter
+};
+//# sourceMappingURL=index.js.map