oceanpress 1.0.12 → 1.0.13

package/dist-cli/cli.js

@@ -77,8 +77,22 @@ import { computed, reactive, watch } from "vue";
 // package.json
 var package_default = {
   name: "oceanpress",
-  version: "1.0.10",
+  version: "1.0.13",
   type: "module",
+  description: "\u4ECE\u601D\u6E90\u7B14\u8BB0\u672C\u751F\u6210\u9759\u6001\u7AD9\u70B9\u7684\u5DE5\u5177",
+  author: "siyuan-note",
+  license: "MIT",
+  keywords: [
+    "siyuan",
+    "static-site-generator",
+    "markdown",
+    "blog",
+    "ssg"
+  ],
+  homepage: "https://github.com/siyuan-note/oceanpress#readme",
+  bugs: {
+    url: "https://github.com/siyuan-note/oceanpress/issues"
+  },
   scripts: {
     dev: "vite",
     cli: "tsx ./src/cli.ts",
@@ -105,6 +119,10 @@ var package_default = {
     "dist-cli",
     "*.md"
   ],
+  repository: {
+    type: "git",
+    url: "https://github.com/siyuan-note/oceanpress.git"
+  },
   dependencies: {
     "@aws-sdk/client-s3": "^3.873.0",
     "@hono/node-server": "^1.19.0",
@@ -119,12 +137,14 @@ var package_default = {
     octokit: "^5.0.3",
     superjson: "^2.2.2",
     tsx: "^4.20.4",
+    turndown: "^7.2.2",
     vditor: "^3.11.1",
     vue: "^3.5.19",
     "vue-router": "^4.5.1",
     "zstd-codec": "^0.1.5"
   },
   devDependencies: {
+    "@types/turndown": "^5.0.6",
     "@vitejs/plugin-vue": "^6.0.1",
     "@vitejs/plugin-vue-jsx": "^5.0.1",
     "dependency-cruiser": "^17.0.1",
@@ -248,6 +268,17 @@ var defaultConfig = {
     apiKey: "",
     indexName: ""
   },
+  /** Markdown 镜像导出配置 */
+  markdownMirror: {
+    enable: false,
+    outputDir: "",
+    includeAssets: false,
+    watchMode: false,
+    /** 定时同步间隔（毫秒） */
+    watchInterval: 6e4,
+    /** 是否移除头部和底部（侧边栏、导航、footer 等） */
+    removeTemplate: false
+  },
   /** html模板嵌入代码块，会将此处配置中的代码嵌入到生成的html所对应的位置 */
   embedCode: {
     head: "",
@@ -518,6 +549,237 @@ var s3_uploads = async function* (tree, config) {
   }
 };
 
+// src/plugins/markdown_mirror/plugin.ts
+import TurndownService from "turndown";
+var MarkdownMirrorPlugin = class {
+  constructor(config) {
+    this.config = config;
+    __publicField(this, "name", "MarkdownMirrorPlugin");
+    /** 拦截 build，添加 Markdown 导出回调 */
+    __publicField(this, "build", function([config, otherConfig], next) {
+      return next(config, {
+        ...otherConfig,
+        beforeFileTree: async (tree, effectApi) => {
+          if (otherConfig?.beforeFileTree) {
+            await otherConfig.beforeFileTree(tree, effectApi);
+          }
+          if (config.markdownMirror?.enable) {
+            effectApi.log("\n=== \u5F00\u59CB Markdown \u955C\u50CF\u5BFC\u51FA ===");
+            try {
+              convertHtmlToMarkdown(
+                tree,
+                config.markdownMirror.includeAssets
+              );
+              effectApi.log("=== Markdown \u955C\u50CF\u5BFC\u51FA\u5B8C\u6210 ===\n");
+            } catch (error) {
+              effectApi.log("\u274C Markdown \u955C\u50CF\u5BFC\u51FA\u5931\u8D25: " + error);
+            }
+          }
+        },
+        onFileTree: async (tree, effectApi) => {
+          if (otherConfig?.onFileTree) {
+            await otherConfig.onFileTree(tree, effectApi);
+          }
+        }
+      });
+    });
+  }
+};
+function buildIdToHeadingMap(htmlContent) {
+  const idToHeading = /* @__PURE__ */ new Map();
+  const headingRegex = /<h([1-6])\s+id="([^"]+)"[^>]*>(.*?)<\/h\1>/gi;
+  let match;
+  while ((match = headingRegex.exec(htmlContent)) !== null) {
+    const id = match[2];
+    const headingText = match[3].replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'").trim();
+    idToHeading.set(id, headingText);
+  }
+  return idToHeading;
+}
+function headingToAnchor(headingText) {
+  return headingText.toLowerCase().replace(/[^\p{L}\p{N}\s-]/gu, "").replace(/[\s_]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizePath(relativePath) {
+  let normalized = relativePath.replace(/^\.\//, "");
+  while (normalized.startsWith("../")) {
+    normalized = normalized.slice(3);
+  }
+  return normalized;
+}
+function convertHtmlToMarkdown(tree, includeAssets = false) {
+  const allFiles = Object.keys(tree);
+  console.log(`\u{1F4C2} \u6587\u4EF6\u6811\u4E2D\u5171\u6709 ${allFiles.length} \u4E2A\u6587\u4EF6`);
+  if (allFiles.length > 0) {
+    console.log("\u{1F4C2} \u524D 10 \u4E2A\u6587\u4EF6:", allFiles.slice(0, 10));
+  }
+  const globalIdToHeading = /* @__PURE__ */ new Map();
+  const htmlFiles = Object.entries(tree).filter(([filePath]) => filePath.endsWith(".html"));
+  console.log("\u{1F4D6} \u6B63\u5728\u626B\u63CF HTML \u6587\u4EF6\u4EE5\u5EFA\u7ACB\u6807\u9898\u6620\u5C04...");
+  for (const [htmlPath, htmlContent] of htmlFiles) {
+    const htmlStr = htmlContent.toString();
+    const idToHeading = buildIdToHeadingMap(htmlStr);
+    for (const [id, heading] of idToHeading.entries()) {
+      const mdPath = htmlPath.replace(/\.html$/, ".md");
+      globalIdToHeading.set(`${mdPath}:${id}`, heading);
+      globalIdToHeading.set(`${htmlPath}:${id}`, heading);
+      globalIdToHeading.set(`./${mdPath}:${id}`, heading);
+      globalIdToHeading.set(`./${htmlPath}:${id}`, heading);
+    }
+  }
+  console.log(`\u2705 \u5EFA\u7ACB\u4E86 ${globalIdToHeading.size} \u4E2A\u6807\u9898\u6620\u5C04
+`);
+  const turndownService = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "-"
+  });
+  turndownService.addRule("remove-sidebars", {
+    filter: (node) => {
+      return node.id === "oceanpress-left-sidebar" || node.id === "oceanpress-right-sidebar";
+    },
+    replacement: () => ""
+  });
+  turndownService.addRule("remove-html-metadata", {
+    filter: (node) => {
+      return ["head", "style", "script", "noscript", "link", "meta", "title"].includes(
+        node.nodeName?.toLowerCase()
+      );
+    },
+    replacement: () => ""
+  });
+  turndownService.addRule("remove-json-ld", {
+    filter: (node) => {
+      return node.nodeName === "SCRIPT" && node.getAttribute("type") === "application/ld+json";
+    },
+    replacement: () => ""
+  });
+  turndownService.addRule("remove-siyuan-config", {
+    filter: (node) => {
+      return node.nodeName === "SCRIPT" && node.textContent?.includes("window.siyuan");
+    },
+    replacement: () => ""
+  });
+  turndownService.addRule("remove-footer", {
+    filter: (node) => {
+      return node.nodeName === "FOOTER" || node.nodeName === "DIV" && node.classList?.contains("theme-aware-footer");
+    },
+    replacement: () => ""
+  });
+  turndownService.addRule("remove-home-link", {
+    filter: (node) => {
+      return node.nodeName === "A" && node.getAttribute("href") === "/";
+    },
+    replacement: () => ""
+  });
+  turndownService.addRule("convert-internal-links", {
+    filter: (node) => {
+      return node.nodeName === "A" && node.getAttribute("href")?.includes(".html");
+    },
+    replacement: (content, node) => {
+      const href = node.getAttribute("href");
+      if (!href) return content;
+      const linkMatch = href.match(/^(.+?\.html)(#.+)?$/);
+      if (!linkMatch) return `[${content}](${href})`;
+      const htmlPath = linkMatch[1];
+      const anchor = linkMatch[2] || "";
+      const normalizedHtmlPath = normalizePath(htmlPath);
+      const mdPath = normalizedHtmlPath.replace(/\.html$/, ".md");
+      if (anchor) {
+        const anchorId = anchor.slice(1);
+        let headingText;
+        const possiblePaths = [
+          `/${mdPath}:${anchorId}`,
+          // /工具/blender.md:xxx
+          `${mdPath}:${anchorId}`,
+          // 工具/blender.md:xxx
+          `/${normalizedHtmlPath}:${anchorId}`,
+          `${normalizedHtmlPath}:${anchorId}`
+        ];
+        for (const possiblePath of possiblePaths) {
+          if (globalIdToHeading.has(possiblePath)) {
+            headingText = globalIdToHeading.get(possiblePath);
+            break;
+          }
+        }
+        if (headingText) {
+          const headingAnchor = headingToAnchor(headingText);
+          const prefix2 = href.startsWith("../") ? "../" : href.startsWith("./") ? "./" : "";
+          return `[${content}](${prefix2}${mdPath}#${headingAnchor})`;
+        } else {
+          if (Math.random() < 0.05) {
+            console.warn(`\u26A0\uFE0F  \u672A\u627E\u5230\u6807\u9898\u6620\u5C04: ${href}`);
+            console.warn(`   \u5C1D\u8BD5\u7684\u8DEF\u5F84:`, possiblePaths.slice(0, 2));
+          }
+        }
+      }
+      const prefix = href.startsWith("../") ? "../" : href.startsWith("./") ? "./" : "";
+      return `[${content}](${prefix}${mdPath})`;
+    }
+  });
+  turndownService.addRule("convert-code-blocks", {
+    filter: (node) => {
+      return node.nodeName === "DIV" && node.classList?.contains("hljs");
+    },
+    replacement: (_content, node) => {
+      const code = node.textContent || "";
+      let language = "";
+      const previousSibling = node.previousSibling;
+      if (previousSibling && previousSibling.nodeName === "DIV") {
+        const actionDiv = previousSibling.querySelector(".protyle-action--first");
+        if (actionDiv) {
+          const langText = actionDiv.textContent?.trim();
+          if (langText && langText !== "Copy") {
+            language = langText.toLowerCase();
+          }
+        }
+      }
+      if (!language) {
+        if (code.includes("function ") || code.includes("const ") || code.includes("let ") || code.includes("=>") || code.includes("interface ")) {
+          language = "typescript";
+        } else if (code.includes("def ") || code.includes("import ") || code.includes("class ")) {
+          language = "python";
+        } else if (code.includes("SELECT ") || code.includes("INSERT ") || code.includes("UPDATE ")) {
+          language = "sql";
+        }
+      }
+      return `
+\`\`\`${language}
+${code.trim()}
+\`\`\`
+`;
+    }
+  });
+  console.log(`\u{1F4C4} \u627E\u5230 ${htmlFiles.length} \u4E2A HTML \u6587\u4EF6
+`);
+  let convertedCount = 0;
+  for (const [htmlPath, htmlContent] of htmlFiles) {
+    try {
+      const mdPath = htmlPath.replace(/\.html$/, ".md");
+      const htmlStr = htmlContent.toString();
+      let markdown = turndownService.turndown(htmlStr);
+      markdown = markdown.trimStart();
+      markdown = markdown.replace(/\n([a-z]+)\n\n(```[a-z]+\n)/g, "\n$2");
+      tree[mdPath] = markdown;
+      delete tree[htmlPath];
+      convertedCount++;
+      console.log(`\u2705 [${convertedCount}] ${htmlPath} \u2192 ${mdPath}`);
+    } catch (error) {
+      console.error(`\u274C \u8F6C\u6362\u5931\u8D25: ${htmlPath}`, error);
+    }
+  }
+  console.log(`
+\u{1F389} \u6210\u529F\u8F6C\u6362 ${convertedCount} \u4E2A HTML \u6587\u4EF6\u4E3A Markdown`);
+  if (!includeAssets) {
+    const assetPaths = Object.keys(tree).filter((path) => path.startsWith("assets/"));
+    assetPaths.forEach((assetPath) => {
+      delete tree[assetPath];
+    });
+    if (assetPaths.length > 0) {
+      console.log(`\u{1F5D1}\uFE0F  \u5DF2\u4ECE\u6587\u4EF6\u6811\u4E2D\u79FB\u9664 ${assetPaths.length} \u4E2A\u8D44\u6E90\u6587\u4EF6`);
+    }
+  }
+}
+
 // src/core/build.ts
 import { Effect as Effect4 } from "effect";
 
@@ -882,6 +1144,101 @@ function sitemap_xml(docArr, config) {
 }
 
 // src/core/seo.ts
+var simplifiedStopWords = /* @__PURE__ */ new Set([
+  "\u7684",
+  "\u4E86",
+  "\u5728",
+  "\u662F",
+  "\u6211",
+  "\u6709",
+  "\u548C",
+  "\u5C31",
+  "\u4E0D",
+  "\u4EBA",
+  "\u90FD",
+  "\u4E00",
+  "\u4E2A",
+  "\u4E0A",
+  "\u4E5F",
+  "\u5F88",
+  "\u5230",
+  "\u8BF4",
+  "\u8981",
+  "\u53BB",
+  "\u4F60",
+  "\u4F1A",
+  "\u7740",
+  "\u6CA1\u6709",
+  "\u770B",
+  "\u597D",
+  "\u81EA\u5DF1",
+  "\u8FD9",
+  "\u90A3",
+  "\u73B0\u5728",
+  "\u53EF\u4EE5",
+  "\u4F46\u662F",
+  "\u8FD8\u662F",
+  "\u56E0\u4E3A",
+  "\u4EC0\u4E48",
+  "\u5982\u679C",
+  "\u6240\u4EE5",
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "can",
+  "this",
+  "that",
+  "these",
+  "those",
+  "i",
+  "you",
+  "he",
+  "she",
+  "it",
+  "we",
+  "they"
+]);
+var htmlCleanupCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 500;
+function manageCacheSize() {
+  if (htmlCleanupCache.size > MAX_CACHE_SIZE) {
+    const firstKey = htmlCleanupCache.keys().next().value;
+    if (firstKey) {
+      htmlCleanupCache.delete(firstKey);
+    }
+  }
+}
 function extractDateFromId(id) {
   if (!id || id.length < 14) return (/* @__PURE__ */ new Date()).toISOString();
   try {
@@ -920,369 +1277,35 @@ function formatDate(dateString) {
     return (/* @__PURE__ */ new Date()).toISOString();
   }
 }
-var TFIDFKeywordExtractor = class {
-  constructor() {
-    __publicField(this, "stopWords", /* @__PURE__ */ new Set([
-      // 中文停用词
-      "\u7684",
-      "\u4E86",
-      "\u5728",
-      "\u662F",
-      "\u6211",
-      "\u6709",
-      "\u548C",
-      "\u5C31",
-      "\u4E0D",
-      "\u4EBA",
-      "\u90FD",
-      "\u4E00",
-      "\u4E2A",
-      "\u4E0A",
-      "\u4E5F",
-      "\u5F88",
-      "\u5230",
-      "\u8BF4",
-      "\u8981",
-      "\u53BB",
-      "\u4F60",
-      "\u4F1A",
-      "\u7740",
-      "\u6CA1\u6709",
-      "\u770B",
-      "\u597D",
-      "\u81EA\u5DF1",
-      "\u8FD9",
-      "\u90A3",
-      "\u73B0\u5728",
-      "\u53EF\u4EE5",
-      "\u4F46\u662F",
-      "\u8FD8\u662F",
-      "\u56E0\u4E3A",
-      "\u4EC0\u4E48",
-      "\u5982\u679C",
-      "\u6240\u4EE5",
-      "\u5BF9\u4E8E",
-      "\u5173\u4E8E",
-      "\u901A\u8FC7",
-      "\u8FDB\u884C",
-      "\u57FA\u4E8E",
-      "\u4EE5\u53CA",
-      "\u6216\u8005",
-      "\u800C\u4E14",
-      "\u7136\u540E",
-      "\u53EA\u662F",
-      "\u5DF2\u7ECF",
-      "\u6B63\u5728",
-      "\u5E94\u8BE5",
-      "\u80FD\u591F",
-      "\u9700\u8981",
-      "\u53EF\u80FD",
-      "\u4E00\u5B9A",
-      "\u8FD9\u6837",
-      "\u90A3\u6837",
-      "\u600E\u4E48",
-      "\u4E3A\u4EC0\u4E48",
-      "\u54EA\u91CC",
-      "\u54EA\u4E2A",
-      "\u591A\u5C11",
-      "\u51E0\u4E2A",
-      "\u4EC0\u4E48",
-      "\u600E\u4E48",
-      "\u5982\u4F55",
-      "\u4E3A\u4EC0\u4E48",
-      // 英文停用词
-      "the",
-      "a",
-      "an",
-      "and",
-      "or",
-      "but",
-      "in",
-      "on",
-      "at",
-      "to",
-      "for",
-      "of",
-      "with",
-      "by",
-      "is",
-      "are",
-      "was",
-      "were",
-      "be",
-      "been",
-      "being",
-      "have",
-      "has",
-      "had",
-      "do",
-      "does",
-      "did",
-      "will",
-      "would",
-      "could",
-      "should",
-      "may",
-      "might",
-      "must",
-      "can",
-      "this",
-      "that",
-      "these",
-      "those",
-      "i",
-      "you",
-      "he",
-      "she",
-      "it",
-      "we",
-      "they",
-      "me",
-      "him",
-      "her",
-      "us",
-      "them",
-      "my",
-      "your",
-      "his",
-      "its",
-      "our",
-      "their",
-      "not",
-      "no",
-      "yes",
-      "so",
-      "if",
-      "when",
-      "where",
-      "how",
-      "why",
-      "what",
-      "which",
-      "who",
-      "whom",
-      "there",
-      "here"
-    ]));
-  }
-  /**
-   * 计算词频 (TF)
-   */
-  calculateTermFrequency(text) {
-    const words = this.tokenize(text);
-    const tf = /* @__PURE__ */ new Map();
-    const totalWords = words.length;
-    for (const word of words) {
-      tf.set(word, (tf.get(word) || 0) + 1);
-    }
-    for (const [word, count] of tf) {
-      tf.set(word, count / totalWords);
-    }
-    return tf;
-  }
-  /**
-   * 分词处理（针对中文和英文优化）
-   */
-  tokenize(text) {
-    const tokens = [];
-    const plainText = text.replace(/<[^>]*>/g, " ").replace(/&[^;]+;/g, " ").replace(/\s+/g, " ").trim();
-    const englishWords = plainText.match(/[a-zA-Z]{3,}/g) || [];
-    tokens.push(...englishWords.map((word) => word.toLowerCase()).filter((word) => !this.stopWords.has(word)));
-    const camelCaseWords = plainText.match(/[a-z]+[A-Z][a-zA-Z0-9]*|[A-Z][a-z0-9]+[A-Z][a-zA-Z0-9]*/g) || [];
-    tokens.push(...camelCaseWords.map((word) => word.toLowerCase()));
-    const chineseTokens = this.extractChineseTokens(plainText);
-    tokens.push(...chineseTokens);
-    const filteredTokens = tokens.filter((token) => {
-      if (token.length < 2) return false;
-      const htmlRelatedWords = ["div", "span", "class", "id", "type", "data", "href", "src", "alt", "title", "style", "width", "height", "rootid", "endid", "nodedocument", "ezcqbj", "cktc", "quot"];
-      if (htmlRelatedWords.includes(token.toLowerCase())) {
-        return false;
-      }
-      if (token.match(/^[a-f0-9]{6,}$/)) return false;
-      if (/[\u4e00-\u9fa5]/.test(token) && token.length < 2) {
-        return false;
-      }
-      return true;
-    });
-    return filteredTokens;
-  }
-  /**
-   * 智能中文分词 - 基于文本特征分析
-   */
-  extractChineseTokens(text) {
-    const tokens = [];
-    const chineseText = text.replace(/[^\u4e00-\u9fa5\s]/g, " ");
-    const wordPatterns = [
-      /[\u4e00-\u9fa5]{4}/g,
-      // 4字词汇
-      /[\u4e00-\u9fa5]{3}/g,
-      // 3字词汇
-      /[\u4e00-\u9fa5]{2}/g
-      // 2字词汇
-    ];
-    for (const pattern of wordPatterns) {
-      const matches = chineseText.match(pattern) || [];
-      for (const word of matches) {
-        if (!this.stopWords.has(word) && this.isMeaningfulChineseWord(word)) {
-          tokens.push(word.toLowerCase());
-        }
-      }
+function cleanHtmlContent(content) {
+  const cacheKey = content;
+  if (htmlCleanupCache.has(cacheKey)) {
+    return htmlCleanupCache.get(cacheKey);
+  }
+  const cleaned = content.replace(/<[^>]*>/g, " ").replace(/&[^;]+;/g, " ").replace(/\s+/g, " ").trim();
+  htmlCleanupCache.set(cacheKey, cleaned);
+  manageCacheSize();
+  return cleaned;
+}
+function simplifiedKeywordExtraction(text, maxKeywords = 8) {
+  const words = [];
+  const wordCount = /* @__PURE__ */ new Map();
+  const englishWords = text.match(/[a-zA-Z]{3,}/g) || [];
+  for (const word of englishWords) {
+    const lowerWord = word.toLowerCase();
+    if (!simplifiedStopWords.has(lowerWord) && lowerWord.length >= 3) {
+      words.push(lowerWord);
+      wordCount.set(lowerWord, (wordCount.get(lowerWord) || 0) + 1);
     }
-    return tokens;
   }
-  /**
-   * 判断是否为有意义的中文词汇
-   */
-  isMeaningfulChineseWord(word) {
-    const meaninglessPatterns = [
-      /^的.*$/,
-      /^.*的$/,
-      /^了.*$/,
-      /^.*了$/,
-      /^在.*$/,
-      /^.*在$/,
-      /^是.*$/,
-      /^.*是$/,
-      /^我.*$/,
-      /^.*我$/,
-      /^有.*$/,
-      /^.*有$/,
-      /^和.*$/,
-      /^.*和$/,
-      /^就.*$/,
-      /^.*就$/,
-      /^不.*$/,
-      /^.*不$/,
-      /^人.*$/,
-      /^.*人$/
-    ];
-    for (const pattern of meaninglessPatterns) {
-      if (pattern.test(word)) {
-        return false;
-      }
-    }
-    if (/(.)\1{2,}/.test(word)) {
-      return false;
+  const chineseWords = text.match(/[\u4e00-\u9fa5]{2,4}/g) || [];
+  for (const word of chineseWords) {
+    if (!simplifiedStopWords.has(word)) {
+      words.push(word);
+      wordCount.set(word, (wordCount.get(word) || 0) + 1);
     }
-    return true;
-  }
-  /**
-   * 计算逆文档频率 (IDF) - 简化版本
-   */
-  calculateInverseDocumentFrequency(term) {
-    const commonTerms = /* @__PURE__ */ new Set([
-      "\u6280\u672F",
-      "\u5F00\u53D1",
-      "\u4EE3\u7801",
-      "\u7CFB\u7EDF",
-      "\u6570\u636E",
-      "\u529F\u80FD",
-      "\u5E94\u7528",
-      "\u5B9E\u73B0",
-      "\u65B9\u6CD5",
-      "\u95EE\u9898",
-      "time",
-      "data",
-      "system",
-      "code",
-      "development",
-      "application",
-      "function",
-      "method",
-      "problem",
-      "solution"
-    ]);
-    if (commonTerms.has(term.toLowerCase())) {
-      return Math.log(1e3 / 500);
-    }
-    return Math.log(1e3 / 10);
   }
-  /**
-   * 提取关键词
-   */
-  extractKeywords(content, maxKeywords = 10) {
-    const tf = this.calculateTermFrequency(content);
-    const keywordScores = /* @__PURE__ */ new Map();
-    for (const [term, frequency] of tf) {
-      const idf = this.calculateInverseDocumentFrequency(term);
-      const tfidf = frequency * idf;
-      let bonus = 1;
-      if (content.toLowerCase().includes(term.toLowerCase()) && (content.match(new RegExp(`^${term}`, "mi")) || content.match(new RegExp(`${term}$`, "mi")))) {
-        bonus *= 1.5;
-      }
-      if (term.length >= 2 && term.length <= 6) {
-        bonus *= 1.2;
-      }
-      keywordScores.set(term, tfidf * bonus);
-    }
-    return Array.from(keywordScores.entries()).sort((a, b) => b[1] - a[1]).slice(0, maxKeywords).map(([term]) => term);
-  }
-};
-function extractDescription(content, maxLength = 160) {
-  const plainText = content.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
-  if (plainText.length <= maxLength) return plainText;
-  const truncated = plainText.substring(0, maxLength);
-  const lastSentenceEnd = Math.max(
-    truncated.lastIndexOf("\u3002"),
-    truncated.lastIndexOf("\uFF01"),
-    truncated.lastIndexOf("\uFF1F"),
-    truncated.lastIndexOf("."),
-    truncated.lastIndexOf("!"),
-    truncated.lastIndexOf("?")
-  );
-  if (lastSentenceEnd > maxLength * 0.7) {
-    return truncated.substring(0, lastSentenceEnd + 1);
-  }
-  return truncated + "...";
-}
-function extractKeywords(content) {
-  const tfidfExtractor = new TFIDFKeywordExtractor();
-  return tfidfExtractor.extractKeywords(content, 8);
-}
-function generateArticleJsonLd(doc, config, pageUrl, content) {
-  const title = doc.Properties?.title || "\u672A\u547D\u540D\u6587\u6863";
-  const description = extractDescription(content);
-  const keywords = extractKeywords(content);
-  const datePublished = extractDateFromId(doc.ID);
-  const dateModified = formatDate(doc.Properties?.updated);
-  const jsonLd = {
-    "@context": "https://schema.org",
-    "@type": "Article",
-    headline: title,
-    description,
-    keywords: keywords.join(", "),
-    datePublished,
-    dateModified,
-    author: {
-      "@type": "Person",
-      name: config.sitemap?.title || "\u5D2E\u751F",
-      url: config.sitemap?.siteLink || ""
-    },
-    publisher: {
-      "@type": "Organization",
-      name: config.sitemap?.title || "OceanPress",
-      logo: {
-        "@type": "ImageObject",
-        url: `${config.sitemap?.siteLink || ""}/assets/logo.png`
-      }
-    },
-    mainEntityOfPage: {
-      "@type": "WebPage",
-      "@id": pageUrl
-    },
-    image: doc.Properties?.["title-img"] ? {
-      "@type": "ImageObject",
-      url: `${config.sitemap?.siteLink || ""}${doc.Properties["title-img"].replace("assets", "/assets")}`,
-      width: 1200,
-      height: 630
-    } : void 0,
-    wordCount: content.replace(/<[^>]*>/g, "").length,
-    articleSection: "\u6280\u672F\u6587\u6863",
-    inLanguage: "zh-CN"
-  };
-  return `<script type="application/ld+json">
-${JSON.stringify(jsonLd, null, 2)}
-</script>`;
+  return Array.from(wordCount.entries()).sort((a, b) => b[1] - a[1]).slice(0, maxKeywords).map(([word]) => word);
 }
 function generateBreadcrumbJsonLd(breadcrumbs) {
   const itemListElement = breadcrumbs.map((crumb, index) => ({
@@ -1300,10 +1323,20 @@ function generateBreadcrumbJsonLd(breadcrumbs) {
 ${JSON.stringify(jsonLd, null, 2)}
 </script>`;
 }
-function generateSeoMetaTags(doc, config, pageUrl, content) {
+function generateSeoContent(data) {
+  const plainText = cleanHtmlContent(data.content);
+  const description = extractDescriptionFromPlainText(plainText);
+  const keywords = simplifiedKeywordExtraction(plainText, 8);
+  const metaTags = generateSeoMetaTagsFromCache(data.doc, data.config, data.pageUrl, { plainText, description, keywords });
+  let jsonLd = generateArticleJsonLdFromCache(data.doc, data.config, data.pageUrl, { plainText, description, keywords });
+  if (data.breadcrumbs && data.breadcrumbs.length > 0) {
+    jsonLd += "\n" + generateBreadcrumbJsonLd(data.breadcrumbs);
+  }
+  return { metaTags, jsonLd };
+}
+function generateSeoMetaTagsFromCache(doc, config, pageUrl, cache2) {
   const title = doc.Properties?.title || "\u672A\u547D\u540D\u6587\u6863";
-  const description = extractDescription(content);
-  const keywords = extractKeywords(content);
+  const { description, keywords } = cache2;
   let metaTags = "";
   metaTags += `  <meta name="description" content="${description.replace(/"/g, "&quot;")}" />
 `;
@@ -1353,16 +1386,62 @@ function generateSeoMetaTags(doc, config, pageUrl, content) {
 `;
   return metaTags;
 }
-function generateSeoContent(data) {
-  const metaTags = generateSeoMetaTags(data.doc, data.config, data.pageUrl, data.content);
-  let jsonLd = generateArticleJsonLd(data.doc, data.config, data.pageUrl, data.content);
-  if (data.breadcrumbs && data.breadcrumbs.length > 0) {
-    jsonLd += "\n" + generateBreadcrumbJsonLd(data.breadcrumbs);
-  }
-  return {
-    metaTags,
-    jsonLd
+function generateArticleJsonLdFromCache(doc, config, pageUrl, cache2) {
+  const title = doc.Properties?.title || "\u672A\u547D\u540D\u6587\u6863";
+  const { description, keywords } = cache2;
+  const datePublished = extractDateFromId(doc.ID);
+  const dateModified = formatDate(doc.Properties?.updated);
+  const jsonLd = {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: title,
+    description,
+    keywords: keywords.join(", "),
+    datePublished,
+    dateModified,
+    author: {
+      "@type": "Person",
+      name: config.sitemap?.title || "\u5D2E\u751F",
+      url: config.sitemap?.siteLink || ""
+    },
+    publisher: {
+      "@type": "Organization",
+      name: config.sitemap?.title || "OceanPress",
+      logo: {
+        "@type": "ImageObject",
+        url: `${config.sitemap?.siteLink || ""}/assets/logo.png`
+      }
+    },
+    mainEntityOfPage: {
+      "@type": "WebPage",
+      "@id": pageUrl
+    },
+    image: doc.Properties?.["title-img"] ? {
+      "@type": "ImageObject",
+      url: `${config.sitemap?.siteLink || ""}${doc.Properties["title-img"].replace("assets", "/assets")}`,
+      width: 1200,
+      height: 630
+    } : void 0,
+    wordCount: cache2.plainText.length,
+    articleSection: "\u6280\u672F\u6587\u6863",
+    inLanguage: "zh-CN"
   };
+  return `<script type="application/ld+json">
+${JSON.stringify(jsonLd, null, 2)}
+</script>`;
+}
+function extractDescriptionFromPlainText(plainText, maxLength = 160) {
+  if (plainText.length <= maxLength) return plainText;
+  const truncated = plainText.substring(0, maxLength);
+  const lastSentenceEnd = Math.max(
+    truncated.lastIndexOf("\u3002"),
+    truncated.lastIndexOf("\uFF01"),
+    truncated.lastIndexOf("\uFF1F"),
+    truncated.lastIndexOf("."),
+    truncated.lastIndexOf("!"),
+    truncated.lastIndexOf("?")
+  );
+  return lastSentenceEnd > maxLength * 0.7 ? truncated.substring(0, lastSentenceEnd + 1) : truncated + "...";
 }
 
 // src/core/htmlTemplate.ts
@@ -2529,7 +2608,8 @@ function build(config, otherConfig) {
       return config.enableIncrementalCompilation_doc;
     })();
     effectLog.log(`=== \u5F00\u59CB\u6E32\u67D3\u6587\u6863 ===`);
-    yield* Effect4.forEach(Object.entries(docTree), ([path, { sy, docBlock }]) => {
+    const renderStartTime = Date.now();
+    yield* Effect4.all(Object.entries(docTree).map(([path, { sy, docBlock }]) => {
       return Effect4.gen(function* () {
         if (config.enableIncrementalCompilation && enableIncrementalCompilation_doc && /** 文档本身没有发生变化 */
         config.__skipBuilds__[docBlock.id]?.hash === docBlock.hash && /** docBlock所引用的文档也没有更新 */
@@ -2574,16 +2654,19 @@ function build(config, otherConfig) {
               [...renderInstance.refs.values()]
             )
           });
-          effectLog.log(`\u6E32\u67D3\u5B8C\u6BD5:${path}`);
         } catch (error) {
           effectLog.log(`${path} \u6E32\u67D3\u5931\u8D25:${error}`);
           console.log(error);
         }
-        process2(i / Doc_blocks.length);
-        return `\u6E32\u67D3\u5B8C\u6BD5:${path}`;
+        return;
       });
+    }), {
+      /** 这里设置为 6 会比 'unbounded' 更快，猜测是并发太高会导致栈切换不过来. 在我的电脑上测试 6 是一个最佳数值 */
+      concurrency: 6
     });
-    effectLog.log(`=== \u6E32\u67D3\u6587\u6863\u5B8C\u6210 ===`);
+    const renderEndTime = Date.now();
+    const renderDuration = ((renderEndTime - renderStartTime) / 1e3).toFixed(2);
+    effectLog.log(`=== \u6587\u6863\u6E32\u67D3\u5B8C\u6BD5\uFF0C\u5171 ${Object.keys(docTree).length + 1}\u7BC7\uFF0C\u8017\u65F6: ${renderDuration}\u79D2 ===`);
     effectLog.log(`=== \u5F00\u59CB\u751F\u6210 sitemap.xml ===`);
     if (config.sitemap.enable) {
       fileTree["sitemap.xml"] = sitemap_xml(Doc_blocks, config.sitemap);
@@ -2646,8 +2729,11 @@ function build(config, otherConfig) {
       fileTree[renderDocTreeJsPath] = yield* renderDocTree();
       effectLog.log(`=== \u6587\u6863\u6811\u751F\u6210\u5B8C\u6210 ===`);
     }
+    if (otherConfig?.beforeFileTree) {
+      yield* Effect4.tryPromise(() => Promise.resolve(otherConfig.beforeFileTree(fileTree, effectLog)));
+    }
     if (otherConfig?.onFileTree) {
-      otherConfig.onFileTree(fileTree, effectLog);
+      yield* Effect4.tryPromise(() => Promise.resolve(otherConfig.onFileTree(fileTree, effectLog)));
     }
     if (config.compressedZip) {
       effectLog.log(`=== \u5F00\u59CB\u751F\u6210\u538B\u7F29\u5305 ===`);
@@ -2779,6 +2865,11 @@ var OceanPress = class {
         deployOceanPressServer_plugin(this.config)
       );
     }
+    if (config.markdownMirror?.enable) {
+      this.pluginCenter.registerPlugin(
+        new MarkdownMirrorPlugin(config.markdownMirror)
+      );
+    }
   }
   build() {
     const build_res = this.pluginCenter.fun.build(this.config, {
@@ -2859,15 +2950,22 @@ var nodeApiDep = {
 // src/cli/common.ts
 import { Command } from "commander";
 var program = new Command();
-program.name("OceanPress").description("\u8FD9\u662F\u4E00\u6B3E\u4ECE\u601D\u6E90\u7B14\u8BB0\u672C\u751F\u6210\u4E00\u4E2A\u9759\u6001\u7AD9\u70B9\u7684\u5DE5\u5177");
+program.name("OceanPress").description("\u8FD9\u662F\u4E00\u6B3E\u4ECE\u601D\u6E90\u7B14\u8BB0\u672C\u751F\u6210\u4E00\u4E2A\u9759\u6001\u7AD9\u70B9\u7684\u5DE5\u5177").version(package_default.version);
 
 // src/cli/deploy.ts
 import { Context as Context3, Effect as Effect5 } from "effect";
 program.command("deploy").description("\u90E8\u7F72\u7AD9\u70B9").option("-c, --config <string>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u7684\u4F4D\u7F6E").option("-h, --apiBase <string>", "OceanPress server \u5730\u5740").option("-k, --apiKey <string>", "OceanPress server Api \u5BC6\u94A5").action(async (opt) => {
   if (!opt.apiBase || !opt.apiKey) {
-    return console.error(`\u8BF7\u914D\u7F6E apiBase \u548C apiKey`);
+    console.error(`\u8BF7\u914D\u7F6E apiBase \u548C apiKey`);
+    throw new Error("\u8BF7\u914D\u7F6E apiBase \u548C apiKey");
+  }
+  let config;
+  try {
+    config = await readFile(opt.config, "utf-8");
+  } catch (error) {
+    console.error("\u914D\u7F6E\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25:", error);
+    throw new Error("\u914D\u7F6E\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25");
   }
-  const config = await readFile(opt.config, "utf-8");
   const client = await createRPC("apiConsumer", {
     remoteCall(method, data) {
       let body;
@@ -2877,7 +2975,9 @@ program.command("deploy").description("\u90E8\u7F72\u7AD9\u70B9").option("-c, --
         content_type = "application/octet-stream";
       } else {
         body = stringify2(data);
-        console.log("[body]", body);
+        if (process.env.NODE_ENV !== "production") {
+          console.log("[body]", body);
+        }
         content_type = "application/json";
       }
       return fetch(`${opt.apiBase}/api/${method}`, {
@@ -2893,7 +2993,7 @@ program.command("deploy").description("\u90E8\u7F72\u7AD9\u70B9").option("-c, --
       }).then((res) => res.json()).then((r) => {
         if (r.error) {
           console.log("[r]", r);
-          throw new Error();
+          throw new Error(r.error.message || "API\u8BF7\u6C42\u5931\u8D25");
         }
         return r.result;
       });
@@ -2919,7 +3019,14 @@ ${msg}`);
   );
   const p = Effect5.provide(
     Effect5.gen(function* () {
-      yield* loadConfigFile(JSON.parse(config));
+      let parsedConfig;
+      try {
+        parsedConfig = JSON.parse(config);
+      } catch (error) {
+        console.error("\u914D\u7F6E\u6587\u4EF6\u89E3\u6790\u5931\u8D25:", error);
+        throw new Error("\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF");
+      }
+      yield* loadConfigFile(parsedConfig);
       const ocean_press = new OceanPress(currentConfig.value);
       ocean_press.pluginCenter.registerPlugin({
         async build_onFileTree([tree], next) {
@@ -2947,16 +3054,36 @@ import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
 import { resolve } from "path";
 import { join } from "path/posix";
 import { Context as Context4, Effect as Effect6 } from "effect";
-program.command("build").description("\u8F93\u51FA\u9759\u6001\u7AD9\u70B9\u6E90\u7801").option("-c, --config <string>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u7684\u4F4D\u7F6E").option("-o, --output <string>", "\u6307\u5B9A\u8F93\u51FA\u76EE\u5F55\u4F4D\u7F6E").action(async (opt) => {
+program.command("build").description("\u8F93\u51FA\u9759\u6001\u7AD9\u70B9\u6E90\u7801").option("-c, --config <string>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u7684\u4F4D\u7F6E").option("-o, --output <string>", "\u6307\u5B9A\u8F93\u51FA\u76EE\u5F55\u4F4D\u7F6E").option("--md", "\u542F\u7528 Markdown \u955C\u50CF\u5BFC\u51FA\u6A21\u5F0F").option("--watch", "\u542F\u7528\u76D1\u542C\u6A21\u5F0F\uFF0C\u5B9A\u65F6\u81EA\u52A8\u91CD\u65B0\u6784\u5EFA").option("--watch-interval <number>", "\u76D1\u542C\u6A21\u5F0F\u4E0B\u7684\u540C\u6B65\u95F4\u9694\uFF08\u79D2\uFF09", "60").action(async (opt) => {
   if (!opt.config || !opt.output) {
     console.log(`\u8BF7\u8BBE\u7F6E\u914D\u7F6E\u6587\u4EF6\u4F4D\u7F6E\u548C\u8F93\u51FA\u76EE\u5F55\u4F4D\u7F6E`);
     throw new Error("\u8BF7\u8BBE\u7F6E\u914D\u7F6E\u6587\u4EF6\u4F4D\u7F6E\u548C\u8F93\u51FA\u76EE\u5F55\u4F4D\u7F6E");
   }
   const config = await readFile2(opt.config, "utf-8");
   const filePath = resolve(opt.output);
+  let parsedConfig;
+  try {
+    parsedConfig = JSON.parse(config);
+  } catch (error) {
+    console.error("\u914D\u7F6E\u6587\u4EF6\u89E3\u6790\u5931\u8D25:", error);
+    throw new Error("\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF");
+  }
+  if (opt.md) {
+    const currentProfileName = parsedConfig.__current__;
+    const currentProfile = parsedConfig[currentProfileName];
+    if (currentProfile) {
+      currentProfile.markdownMirror = {
+        enable: true,
+        // --md 参数强制启用
+        includeAssets: currentProfile.markdownMirror?.includeAssets ?? false
+        // 默认不同步资源
+      };
+      console.log("\u2705 \u5DF2\u542F\u7528 Markdown \u955C\u50CF\u5BFC\u51FA\u6A21\u5F0F\n");
+    }
+  }
   await Effect6.runPromise(
     Effect6.provideService(
-      loadConfigFile(JSON.parse(config)),
+      loadConfigFile(parsedConfig),
       EffectLocalStorageDep,
       nodeApiDep
     )
@@ -2979,35 +3106,62 @@ ${msg}`);
       }
     })
   );
-  const p = Effect6.provide(
-    Effect6.gen(function* () {
-      const ocean_press = new OceanPress(currentConfig.value);
-      ocean_press.pluginCenter.registerPlugin({
-        async build_onFileTree([tree]) {
-          for (const [path, data] of Object.entries(tree)) {
-            const fullPath = join(filePath, "./", path);
-            const pathArray = fullPath.split("/").slice(0, -1);
-            const dirPath = pathArray.join("/");
-            mkdir(dirPath, { recursive: true });
-            try {
-              if (typeof data === "string") {
-                await writeFile(fullPath, data, "utf-8");
-              } else {
-                await writeFile(fullPath, new DataView(data));
+  const runBuild = async () => {
+    const p = Effect6.provide(
+      Effect6.gen(function* () {
+        const ocean_press = new OceanPress(currentConfig.value);
+        ocean_press.pluginCenter.registerPlugin({
+          async build_onFileTree([tree]) {
+            const dirPromises = /* @__PURE__ */ new Set();
+            for (const [path, data] of Object.entries(tree)) {
+              const fullPath = join(filePath, path);
+              const dirPath = resolve(fullPath, "..");
+              if (!dirPromises.has(dirPath)) {
+                dirPromises.add(dirPath);
+                await mkdir(dirPath, { recursive: true });
+              }
+              try {
+                if (typeof data === "string") {
+                  await writeFile(fullPath, data, "utf-8");
+                } else {
+                  await writeFile(fullPath, new DataView(data));
+                }
+              } catch (error) {
+                console.error(`${fullPath} \u65E0\u6CD5\u5199\u5165:`, error);
               }
-            } catch (error) {
-              console.log(`${fullPath} \u65E0\u6CD5\u5199\u5165`);
             }
           }
-        }
-      });
-      console.log("[config.__current__]", JSON.parse(config).__current__);
-      console.log("[currentConfig.value.name]", currentConfig.value.name);
-      return yield* ocean_press.build();
-    }),
-    context
-  );
-  await Effect6.runPromise(p);
+        });
+        console.log("[config.__current__]", parsedConfig.__current__);
+        console.log("[currentConfig.value.name]", currentConfig.value.name);
+        return yield* ocean_press.build();
+      }),
+      context
+    );
+    await Effect6.runPromise(p);
+  };
+  if (opt.watch) {
+    const intervalSeconds = parseInt(opt.watchInterval || "60", 10);
+    const intervalMs = intervalSeconds * 1e3;
+    console.log(`
+\u{1F504} \u76D1\u542C\u6A21\u5F0F\u5DF2\u542F\u52A8\uFF0C\u6BCF ${intervalSeconds} \u79D2\u81EA\u52A8\u6784\u5EFA\u4E00\u6B21
+`);
+    await runBuild();
+    setInterval(async () => {
+      console.log("\n\u23F0 \u5B9A\u65F6\u4EFB\u52A1\u89E6\u53D1\uFF0C\u5F00\u59CB\u6784\u5EFA...");
+      try {
+        await runBuild();
+        const nextTime = new Date(Date.now() + intervalMs).toLocaleTimeString();
+        console.log(`
+\u23F0 \u4E0B\u6B21\u6784\u5EFA: ${nextTime}
+`);
+      } catch (error) {
+        console.error("\u274C \u6784\u5EFA\u5931\u8D25:", error);
+      }
+    }, intervalMs);
+  } else {
+    await runBuild();
+  }
 });
 
 // src/cli/server.ts
@@ -3135,6 +3289,13 @@ function server(config = { port: 80, hostname: "0.0.0.0" }) {
 
 // src/cli/server.ts
 import { Context as Context6, Effect as Effect9 } from "effect";
+function validatePort(port) {
+  const portNum = Number(port);
+  if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
+    throw new Error(`\u7AEF\u53E3\u53F7\u5FC5\u987B\u5728 1-65535 \u4E4B\u95F4\uFF0C\u5F53\u524D\u503C: ${port}`);
+  }
+  return portNum;
+}
 program.command("server").description("\u542F\u52A8\u52A8\u6001\u4EE3\u7406").option("-c, --config <string>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u7684\u4F4D\u7F6E").option("-h, --host <string>", "web\u670D\u52A1\u7ED1\u5B9A\u5230\u7684\u5730\u5740", "127.0.0.1").option("-p, --port <number>", "web\u670D\u52A1\u7ED1\u5B9A\u5230\u7684\u7AEF\u53E3", "80").option(
   "--cache <boolean>",
   "\u914D\u7F6E\u4E3A true \u65F6\u5F00\u542F\u7F13\u5B58,\u9ED8\u8BA4\u4E3A false \u4E0D\u5F00\u542F\u7F13\u5B58",
@@ -3143,8 +3304,15 @@ program.command("server").description("\u542F\u52A8\u52A8\u6001\u4EE3\u7406").op
   async (opt) => {
     if (!opt.config) {
       console.log(`\u8BF7\u8BBE\u7F6E\u914D\u7F6E\u6587\u4EF6\u4F4D\u7F6E`);
+      throw new Error("\u8BF7\u8BBE\u7F6E\u914D\u7F6E\u6587\u4EF6\u4F4D\u7F6E");
+    }
+    let config;
+    try {
+      config = await readFile3(opt.config, "utf-8");
+    } catch (error) {
+      console.error("\u914D\u7F6E\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25:", error);
+      throw new Error("\u914D\u7F6E\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25");
     }
-    const config = await readFile3(opt.config, "utf-8");
     setCache(opt.cache !== "false");
     const context = Context6.empty().pipe(
       Context6.add(EffectRender, renderApiDep),
@@ -3165,11 +3333,18 @@ ${msg}`);
     );
     const p = Effect9.provide(
       Effect9.gen(function* () {
-        yield* loadConfigFile(JSON.parse(config));
+        let parsedConfig;
+        try {
+          parsedConfig = JSON.parse(config);
+        } catch (error) {
+          console.error("\u914D\u7F6E\u6587\u4EF6\u89E3\u6790\u5931\u8D25:", error);
+          throw new Error("\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF");
+        }
+        yield* loadConfigFile(parsedConfig);
         tempConfig.cdn.siyuanPrefix = "/notebook/";
         return yield* server({
           hostname: opt.host,
-          port: Number(opt.port)
+          port: validatePort(opt.port)
         });
       }),
       context
@@ -3179,5 +3354,13 @@ ${msg}`);
 );
 
 // src/cli.ts
+process.on("uncaughtException", (error) => {
+  console.error("\u672A\u6355\u83B7\u7684\u5F02\u5E38:", error);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("\u672A\u5904\u7406\u7684 Promise \u62D2\u7EDD:", reason);
+  process.exit(1);
+});
 program.parse(process.argv);
 //# sourceMappingURL=cli.js.map