mcp-md-word-oss 1.0.1

package/markdownToWord.js

@@ -0,0 +1,130 @@
+/**
+ * Markdown → Word（pandoc），中间文件与 Mermaid 产出均在 workDir 下。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { randomUUID } = require('crypto');
+const { execFileSync } = require('child_process');
+
+function extractMermaidBlocks(mdContent) {
+  const blocks = [];
+  const pattern = /```mermaid\s*\n([\s\S]*?)\n```/g;
+  let match;
+  let index = 0;
+  while ((match = pattern.exec(mdContent)) !== null) {
+    blocks.push({
+      index,
+      code: match[1].trim(),
+      placeholder: `<!-- MERMAID_PLACEHOLDER_${index} -->`,
+    });
+    index += 1;
+  }
+  return blocks;
+}
+
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function generateMermaidImage(mermaidCode, outputPath) {
+  try {
+    const tempDir = path.dirname(outputPath);
+    const tempMmFile = path.join(tempDir, `temp_diagram_${Date.now()}.mmd`);
+    fs.writeFileSync(tempMmFile, mermaidCode, 'utf-8');
+    execFileSync(
+      'npx',
+      ['-y', '@mermaid-js/mermaid-cli', '-i', tempMmFile, '-o', outputPath, '-b', 'white'],
+      { timeout: 60000, encoding: 'utf-8', stdio: ['ignore', 'ignore', 'pipe'], maxBuffer: 2 * 1024 * 1024 }
+    );
+    if (fs.existsSync(tempMmFile)) fs.unlinkSync(tempMmFile);
+    return fs.existsSync(outputPath);
+  } catch (error) {
+    console.error('Mermaid图片生成失败:', error);
+    return false;
+  }
+}
+
+/**
+ * @param {{ mdPath: string, docxPath: string, workDir: string, skipMermaid?: boolean }} args
+ * @returns {Promise<{ docxPath: string, usedPandoc: boolean }>}
+ */
+async function markdownToWord(args) {
+  const { mdPath, docxPath, workDir, skipMermaid = false } = args;
+
+  if (!mdPath) throw new Error('缺少必需参数: mdPath');
+  if (!docxPath) throw new Error('缺少必需参数: docxPath');
+  if (!workDir) throw new Error('缺少必需参数: workDir');
+
+  if (!fs.existsSync(mdPath)) throw new Error(`文件不存在: ${mdPath}`);
+  if (!mdPath.toLowerCase().endsWith('.md')) throw new Error('仅支持.md格式');
+  if (!docxPath.toLowerCase().endsWith('.docx')) throw new Error('仅支持.docx格式');
+
+  if (!fs.existsSync(workDir)) {
+    fs.mkdirSync(workDir, { recursive: true });
+  }
+
+  let mdContent = fs.readFileSync(mdPath, 'utf-8');
+  const outputDir = workDir;
+  const mermaidImages = {};
+
+  if (!skipMermaid) {
+    const mermaidBlocks = extractMermaidBlocks(mdContent);
+    for (const block of mermaidBlocks) {
+      const imageFilename = `mermaid_diagram_${block.index}.png`;
+      const imagePath = path.join(outputDir, imageFilename);
+      const mermaidBlockPattern = new RegExp(
+        `\\\`\\\`\\\`mermaid\\s*\\n${escapeRegExp(block.code)}\\n\\\`\\\`\\\``,
+        'g'
+      );
+      mdContent = mdContent.replace(mermaidBlockPattern, block.placeholder);
+      const success = generateMermaidImage(block.code, imagePath);
+      if (success) {
+        mermaidImages[block.placeholder] = imagePath;
+      }
+    }
+  }
+
+  let wordContent = mdContent;
+  wordContent = wordContent.replace(/^### (.+)$/gm, '### $1');
+  wordContent = wordContent.replace(/^## (.+)$/gm, '## $1');
+  wordContent = wordContent.replace(/^# (.+)$/gm, '# $1');
+  wordContent = wordContent.replace(/```(\w+)?\n([\s\S]*?)```/g, '\n$2\n');
+  wordContent = wordContent.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+  wordContent = wordContent.replace(/\*\*([^*]+)\*\*/g, '$1');
+  wordContent = wordContent.replace(/\*([^*]+)\*/g, '$1');
+
+  for (const placeholder of Object.keys(mermaidImages)) {
+    wordContent = wordContent.replace(
+      placeholder,
+      `[Mermaid图表图片: ${path.basename(mermaidImages[placeholder])}]`
+    );
+  }
+
+  const tempTxtPath = path.join(workDir, `pandoc-${randomUUID()}.txt`);
+  fs.writeFileSync(tempTxtPath, wordContent, 'utf-8');
+
+  try {
+    execFileSync('pandoc', [tempTxtPath, '-o', docxPath], {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'ignore', 'pipe'],
+      maxBuffer: 4 * 1024 * 1024,
+    });
+    return { docxPath, usedPandoc: true };
+  } catch (e) {
+    const stderr = e.stderr != null ? String(e.stderr).trim() : '';
+    const hint =
+      e.code === 'ENOENT'
+        ? '未在 PATH 中找到 pandoc，请安装并配置 PATH。'
+        : stderr || e.message || '未知错误';
+    throw new Error(`无法生成 .docx（pandoc）：${hint}`);
+  } finally {
+    try {
+      if (fs.existsSync(tempTxtPath)) fs.unlinkSync(tempTxtPath);
+    } catch {
+      // ignore
+    }
+  }
+}
+
+module.exports = { markdownToWord };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "mcp-md-word-oss",
+  "version": "1.0.1",
+  "description": "MCP: JSON payload with markdown → OSS MD + pandoc Word → OSS DOCX (tmp dir: DOC_PIPELINE_TMP_DIR)",
+  "main": "server.js",
+  "type": "commonjs",
+  "bin": {
+    "mcp-md-word-oss": "server.js"
+  },
+  "files": [
+    "server.js",
+    "markdownToWord.js",
+    "upload_md_to_oss.py"
+  ],
+  "scripts": {
+    "start": "node server.js"
+  },
+  "keywords": [
+    "mcp",
+    "oss",
+    "markdown",
+    "docx",
+    "pandoc"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "zod": "^3.23.8",
+    "zod-to-json-schema": "^3.23.5"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/server.js

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+/**
+ * 合一 MCP：JSON payload（含 markdown）→ 写临时目录 → 上传 MD 到 OSS → pandoc 转 Word → 上传 DOCX → 返回 mdUrl / wordUrl
+ *
+ * 环境变量（OSS，与 mcp-oss-upload 一致）：
+ *   OSS_ACCESS_KEY_ID, OSS_ACCESS_KEY_SECRET, OSS_BUCKET_NAME, OSS_ENDPOINT
+ * 可选：OSS_MAX_MARKDOWN_CONTENT_BYTES（默认约 20MB）
+ *
+ * 临时目录：
+ *   DOC_PIPELINE_TMP_DIR — 指定本 MCP 工作临时目录（每次任务在其子目录下写入 .md/.docx/mermaid 等）；未设置则用 os.tmpdir()
+ * Python：
+ *   DOC_PIPELINE_PYTHON 或 PYTHON — 可选，指定 python 可执行文件路径（默认 Windows 用 python，其它平台 python3）
+ * Mermaid（可选）：
+ *   DOC_PIPELINE_SKIP_MERMAID=1 — 跳过 Mermaid 转图片（无网/无 npx 环境可避免因拉包超时卡住）
+ */
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+const { z } = require('zod');
+const { zodToJsonSchema } = require('zod-to-json-schema');
+const { execFile } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { randomBytes } = require('crypto');
+const { markdownToWord } = require('./markdownToWord.js');
+
+const EXEC_MAX_BUFFER = 10 * 1024 * 1024;
+const DEFAULT_MAX_MARKDOWN_BYTES = 20 * 1024 * 1024;
+let MAX_MARKDOWN_CONTENT_BYTES = parseInt(
+  process.env.OSS_MAX_MARKDOWN_CONTENT_BYTES || String(DEFAULT_MAX_MARKDOWN_BYTES),
+  10
+);
+if (!Number.isFinite(MAX_MARKDOWN_CONTENT_BYTES) || MAX_MARKDOWN_CONTENT_BYTES <= 0) {
+  MAX_MARKDOWN_CONTENT_BYTES = DEFAULT_MAX_MARKDOWN_BYTES;
+}
+
+function getPipelineTmpRoot() {
+  const raw = (process.env.DOC_PIPELINE_TMP_DIR || '').trim();
+  if (raw) {
+    const abs = path.resolve(raw);
+    try {
+      if (!fs.existsSync(abs)) {
+        fs.mkdirSync(abs, { recursive: true });
+      }
+      fs.accessSync(abs, fs.constants.W_OK);
+    } catch (e) {
+      throw new Error(
+        `DOC_PIPELINE_TMP_DIR 不可用（创建/写入失败）: ${abs} — ${e.message}`
+      );
+    }
+    return abs;
+  }
+  return os.tmpdir();
+}
+
+function getPythonExecutable() {
+  const fromEnv = (process.env.DOC_PIPELINE_PYTHON || process.env.PYTHON || '').trim();
+  if (fromEnv) return fromEnv;
+  return process.platform === 'win32' ? 'python' : 'python3';
+}
+
+function silenceBrokenPipe(stream) {
+  stream.on('error', (err) => {
+    if (err && err.code === 'EPIPE') return;
+    console.error('[md-word-oss] stream error:', err);
+  });
+}
+silenceBrokenPipe(process.stdout);
+silenceBrokenPipe(process.stderr);
+
+process.on('unhandledRejection', (reason) => {
+  console.error('[md-word-oss] unhandledRejection:', reason);
+});
+process.on('uncaughtException', (err) => {
+  console.error('[md-word-oss] uncaughtException:', err);
+  process.exit(1);
+});
+
+function assertMarkdownContentSize(content) {
+  const n = Buffer.byteLength(content, 'utf8');
+  if (n > MAX_MARKDOWN_CONTENT_BYTES) {
+    throw new Error(
+      `Markdown 超过 OSS_MAX_MARKDOWN_CONTENT_BYTES（${n} 字节，上限 ${MAX_MARKDOWN_CONTENT_BYTES}）`
+    );
+  }
+}
+
+function safeMdFilename(name) {
+  const raw =
+    name != null && String(name).trim() !== ''
+      ? String(name).trim()
+      : 'document.md';
+  const base = path.basename(raw) || 'document.md';
+  const withExt = base.toLowerCase().endsWith('.md') ? base : `${base}.md`;
+  return withExt.replace(/[/\\]/g, '-');
+}
+
+const PYTHON_SCRIPT = path.join(__dirname, 'upload_md_to_oss.py');
+
+async function uploadFileWithPython(filePath, objectKey = null) {
+  return new Promise((resolve, reject) => {
+    const args = [PYTHON_SCRIPT, filePath, '--json'];
+    if (objectKey) {
+      args.push('--object-key', objectKey);
+    }
+    const pythonExecutable = getPythonExecutable();
+    execFile(
+      pythonExecutable,
+      args,
+      { encoding: 'utf8', maxBuffer: EXEC_MAX_BUFFER },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.code === 'ENOENT') {
+            reject(
+              new Error(
+                `找不到 Python 可执行文件「${pythonExecutable}」。请安装 Python 并加入 PATH，或设置环境变量 DOC_PIPELINE_PYTHON（或 PYTHON）为完整路径。`
+              )
+            );
+            return;
+          }
+          if (stderr) {
+            try {
+              const errorResult = JSON.parse(stderr);
+              resolve(errorResult);
+              return;
+            } catch {
+              // fall through
+            }
+          }
+          reject(new Error(`执行 Python 上传失败: ${error.message}\nstderr: ${stderr}`));
+          return;
+        }
+        try {
+          resolve(JSON.parse(stdout));
+        } catch (e) {
+          reject(new Error(`解析 Python 输出失败: ${stdout}`));
+        }
+      }
+    );
+  });
+}
+
+async function uploadDocxFileWithPython(filePath, objectKey = null) {
+  return new Promise((resolve, reject) => {
+    const args = [PYTHON_SCRIPT, filePath, '--docx', '--json'];
+    if (objectKey) {
+      args.push('--object-key', objectKey);
+    }
+    const pythonExecutable = getPythonExecutable();
+    execFile(
+      pythonExecutable,
+      args,
+      { encoding: 'utf8', maxBuffer: EXEC_MAX_BUFFER },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.code === 'ENOENT') {
+            reject(
+              new Error(
+                `找不到 Python 可执行文件「${pythonExecutable}」。请安装 Python 并加入 PATH，或设置 DOC_PIPELINE_PYTHON（或 PYTHON）为完整路径。`
+              )
+            );
+            return;
+          }
+          if (stderr) {
+            try {
+              const errorResult = JSON.parse(stderr);
+              resolve(errorResult);
+              return;
+            } catch {
+              // fall through
+            }
+          }
+          reject(new Error(`执行 Python 上传 docx 失败: ${error.message}\nstderr: ${stderr}`));
+          return;
+        }
+        try {
+          resolve(JSON.parse(stdout));
+        } catch (e) {
+          reject(new Error(`解析 Python 输出失败: ${stdout}`));
+        }
+      }
+    );
+  });
+}
+
+const PublishPayloadSchema = z.object({
+  payload: z
+    .string()
+    .describe(
+      'JSON 字符串，必须包含 markdown；可选 filename（默认 document.md）、mdObjectKey、docxObjectKey（旧版 md_object_key / docx_object_key 仍兼容）'
+    ),
+});
+
+function pickOptionalKey(obj, camelKey, legacyKey) {
+  const a = obj[camelKey];
+  if (a != null && String(a).trim() !== '') return String(a).trim();
+  const b = obj[legacyKey];
+  if (b != null && String(b).trim() !== '') return String(b).trim();
+  return null;
+}
+
+const server = new Server(
+  {
+    name: 'md-word-oss',
+    version: '1.0.1',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'publishMarkdownOssWord',
+        description:
+          '解析 JSON 字符串（含 markdown 正文），写入临时目录（DOC_PIPELINE_TMP_DIR），上传 .md 到 OSS，pandoc 生成 .docx 并上传，返回 mdUrl 与 wordUrl。',
+        inputSchema: zodToJsonSchema(PublishPayloadSchema),
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  if (name !== 'publishMarkdownOssWord') {
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ error: `Unknown tool: ${name}` }) }],
+      isError: true,
+    };
+  }
+
+  let jobDir = null;
+  try {
+    const { payload } = PublishPayloadSchema.parse(args ?? {});
+
+    let inner;
+    try {
+      inner = JSON.parse(payload);
+    } catch {
+      throw new Error('payload 不是合法 JSON');
+    }
+    if (!inner || typeof inner !== 'object' || Array.isArray(inner)) {
+      throw new Error('payload 解析后必须是 JSON 对象（不能是数组）');
+    }
+    if (typeof inner.markdown !== 'string') {
+      throw new Error('JSON 内必须包含字符串字段 markdown');
+    }
+    const markdown = inner.markdown;
+    if (!markdown.trim()) {
+      throw new Error('markdown 不能为空');
+    }
+    assertMarkdownContentSize(markdown);
+
+    const tmpRoot = getPipelineTmpRoot();
+    const jobId = `${Date.now()}-${randomBytes(8).toString('hex')}`;
+    jobDir = path.join(tmpRoot, `doc-pipeline-${jobId}`);
+    fs.mkdirSync(jobDir, { recursive: true });
+
+    const mdName = safeMdFilename(inner.filename);
+    const mdPath = path.join(jobDir, mdName);
+    fs.writeFileSync(mdPath, markdown, 'utf8');
+
+    const mdKey = pickOptionalKey(inner, 'mdObjectKey', 'md_object_key');
+    const mdUpload = await uploadFileWithPython(mdPath, mdKey);
+    if (!mdUpload.success) {
+      throw new Error(mdUpload.error || '上传 Markdown 到 OSS 失败');
+    }
+    if (!mdUpload.url) {
+      throw new Error('OSS 上传返回异常：缺少 url 字段');
+    }
+
+    const docxBase = path.basename(mdName, '.md') + '.docx';
+    const docxPath = path.join(jobDir, docxBase);
+    const skipMermaid = /^1|true|yes$/i.test(
+      String(process.env.DOC_PIPELINE_SKIP_MERMAID || '').trim()
+    );
+    await markdownToWord({
+      mdPath,
+      docxPath,
+      workDir: jobDir,
+      skipMermaid,
+    });
+
+    const docxKey = pickOptionalKey(inner, 'docxObjectKey', 'docx_object_key');
+    const docxUpload = await uploadDocxFileWithPython(docxPath, docxKey);
+    if (!docxUpload.success) {
+      throw new Error(docxUpload.error || '上传 Word 到 OSS 失败');
+    }
+    if (!docxUpload.url) {
+      throw new Error('OSS 上传返回异常：缺少 url 字段');
+    }
+
+    const body = {
+      status: 'success',
+      mdUrl: mdUpload.url,
+      wordUrl: docxUpload.url,
+      mdObjectKey: mdUpload.object_key,
+      wordObjectKey: docxUpload.object_key,
+      bucket: mdUpload.bucket,
+    };
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(body, null, 2) }],
+    };
+  } catch (e) {
+    const msg =
+      e instanceof z.ZodError
+        ? e.errors.map((x) => `${x.path.join('.')}: ${x.message}`).join('; ')
+        : e.message || String(e);
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: msg }) }],
+      isError: true,
+    };
+  } finally {
+    if (jobDir && fs.existsSync(jobDir)) {
+      try {
+        fs.rmSync(jobDir, { recursive: true, force: true });
+      } catch {
+        // ignore
+      }
+    }
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error('[md-word-oss] fatal:', err);
+  process.exit(1);
+});

package/upload_md_to_oss.py

@@ -0,0 +1,421 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+上传Markdown文件到阿里云OSS
+通过环境变量 OSS_ACCESS_KEY_ID、OSS_ACCESS_KEY_SECRET、OSS_BUCKET_NAME、OSS_ENDPOINT 配置。
+"""
+
+import hashlib
+import hmac
+import base64
+import datetime
+import urllib.request
+import urllib.error
+from urllib.parse import quote
+import os
+import sys
+import json
+
+
+def get_oss_config():
+    """仅从环境变量读取（请在 MetaMCP / 宿主机的 MCP 配置里设置 OSS_*）。"""
+    return {
+        'access_key_id': os.environ.get('OSS_ACCESS_KEY_ID', ''),
+        'access_key_secret': os.environ.get('OSS_ACCESS_KEY_SECRET', ''),
+        'endpoint': os.environ.get('OSS_ENDPOINT', 'oss-cn-beijing.aliyuncs.com'),
+        'bucket_name': os.environ.get('OSS_BUCKET_NAME', ''),
+    }
+
+
+def normalize_and_validate_oss_config(config):
+    """
+    规范化 endpoint / bucket，并在非法时返回错误 dict；合法则返回 None（会原地改写 config）。
+    若 bucket 为空，URL 会变成 https://.<endpoint>/...，urllib 解析主机名会报 idna label empty。
+    """
+    bn = (config.get('bucket_name') or '').strip()
+    ak = (config.get('access_key_id') or '').strip()
+    sk = (config.get('access_key_secret') or '').strip()
+    ep = (config.get('endpoint') or '').strip()
+    for prefix in ('https://', 'http://'):
+        if ep.lower().startswith(prefix):
+            ep = ep[len(prefix) :]
+    ep = ep.split('/')[0].split(':')[0].strip()
+    config['bucket_name'] = bn
+    config['access_key_id'] = ak
+    config['access_key_secret'] = sk
+    config['endpoint'] = ep
+    if not bn:
+        return {
+            'success': False,
+            'error': '未设置环境变量 OSS_BUCKET_NAME（或值为空）',
+        }
+    if not ak or not sk:
+        return {
+            'success': False,
+            'error': '未设置 OSS_ACCESS_KEY_ID 或 OSS_ACCESS_KEY_SECRET',
+        }
+    if not ep:
+        return {'success': False, 'error': 'OSS_ENDPOINT 为空'}
+    return None
+
+
+def oss_put_url(bucket: str, endpoint: str, object_key: str) -> str:
+    """
+    构造 PUT 用的 HTTPS URL。object_key 含中文时须对路径做百分号编码，
+    否则 http.client 会按 ascii 发请求，触发 UnicodeEncodeError。
+    签名里的 CanonicalizedResource 仍用原始 UTF-8 object_key（见各上传函数）。
+    """
+    path = quote(object_key, safe='/')
+    return f"https://{bucket}.{endpoint}/{path}"
+
+
+def get_gmt_time():
+    """获取GMT时间格式"""
+    return datetime.datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
+
+
+def calculate_md5(content):
+    """计算Content-MD5"""
+    md5_hash = hashlib.md5(content).digest()
+    return base64.b64encode(md5_hash).decode('utf-8')
+
+
+def sign_request(method, content_md5, content_type, date, canonicalized_headers, canonicalized_resource, access_key_secret):
+    """生成OSS签名"""
+    string_to_sign = f"{method}\n{content_md5}\n{content_type}\n{date}\n{canonicalized_headers}{canonicalized_resource}"
+    signature = base64.b64encode(
+        hmac.new(access_key_secret.encode('utf-8'), string_to_sign.encode('utf-8'), hashlib.sha1).digest()
+    ).decode('utf-8')
+    return signature
+
+
+def upload_markdown(local_file_path, object_key=None, custom_headers=None):
+    """
+    上传Markdown文件到OSS
+
+    Args:
+        local_file_path: 本地markdown文件路径
+        object_key: OSS上的对象路径，默认为自动生成的路径
+        custom_headers: 自定义HTTP头
+
+    Returns:
+        dict: 包含上传结果的字典
+    """
+    config = get_oss_config()
+    bad = normalize_and_validate_oss_config(config)
+    if bad:
+        return bad
+
+    # 检查文件是否存在
+    if not os.path.exists(local_file_path):
+        return {
+            'success': False,
+            'error': f'文件不存在: {local_file_path}'
+        }
+
+    # 检查文件类型
+    if not local_file_path.lower().endswith('.md'):
+        return {
+            'success': False,
+            'error': '只支持上传.md格式的markdown文件'
+        }
+
+    # 读取文件内容
+    try:
+        with open(local_file_path, 'rb') as f:
+            content = f.read()
+    except Exception as e:
+        return {
+            'success': False,
+            'error': f'读取文件失败: {str(e)}'
+        }
+
+    # 如果没有指定object_key，自动生成
+    if not object_key:
+        filename = os.path.basename(local_file_path)
+        timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+        object_key = f"markdown/{timestamp}_{filename}"
+
+    # 确保路径以markdown/开头（如果用户没指定自定义路径）
+    if not object_key.startswith('/') and not object_key.startswith('http'):
+        if not object_key.startswith('markdown/') and not object_key.startswith('upload/'):
+            object_key = f"markdown/{object_key}"
+
+    # 计算Content-MD5
+    content_md5 = calculate_md5(content)
+    content_type = "text/markdown; charset=utf-8"
+    date = get_gmt_time()
+    canonicalized_resource = f"/{config['bucket_name']}/{object_key}"
+
+    # 生成签名
+    signature = sign_request("PUT", content_md5, content_type, date, "", canonicalized_resource, config['access_key_secret'])
+
+    # 构建请求
+    url = oss_put_url(config['bucket_name'], config['endpoint'], object_key)
+    headers = {
+        'Date': date,
+        'Content-Type': content_type,
+        'Content-MD5': content_md5,
+        'Authorization': f"OSS {config['access_key_id']}:{signature}"
+    }
+
+    # 添加自定义头
+    if custom_headers:
+        headers.update(custom_headers)
+
+    # 发送PUT请求
+    req = urllib.request.Request(url, data=content, headers=headers, method='PUT')
+
+    try:
+        with urllib.request.urlopen(req, timeout=60) as response:
+            if response.status == 200:
+                oss_url = oss_put_url(config['bucket_name'], config['endpoint'], object_key)
+                return {
+                    'success': True,
+                    'url': oss_url,
+                    'object_key': object_key,
+                    'bucket': config['bucket_name'],
+                    'endpoint': config['endpoint'],
+                    'local_path': local_file_path,
+                    'file_size': len(content),
+                    'message': '上传成功'
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': f'上传失败，HTTP状态码: {response.status}'
+                }
+    except urllib.error.HTTPError as e:
+        error_body = e.read().decode('utf-8') if hasattr(e, 'read') else str(e)
+        return {
+            'success': False,
+            'error': f'HTTP错误 {e.code}: {error_body}'
+        }
+    except Exception as e:
+        return {
+            'success': False,
+            'error': f'上传失败: {str(e)}'
+        }
+
+
+def upload_markdown_content(content, filename, object_key=None):
+    """
+    上传Markdown内容（字符串）到OSS
+
+    Args:
+        content: markdown内容字符串
+        filename: 文件名（用于生成默认object_key）
+        object_key: OSS上的对象路径
+
+    Returns:
+        dict: 包含上传结果的字典
+    """
+    config = get_oss_config()
+    bad = normalize_and_validate_oss_config(config)
+    if bad:
+        return bad
+
+    # 将字符串转换为bytes
+    if isinstance(content, str):
+        content = content.encode('utf-8')
+
+    # 如果没有指定object_key，自动生成
+    if not object_key:
+        timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+        safe_filename = filename.replace(' ', '_').replace('/', '_')
+        object_key = f"markdown/{timestamp}_{safe_filename}"
+
+    # 确保路径以markdown/开头
+    if not object_key.startswith('/') and not object_key.startswith('http'):
+        if not object_key.startswith('markdown/') and not object_key.startswith('upload/'):
+            object_key = f"markdown/{object_key}"
+
+    # 计算Content-MD5
+    content_md5 = calculate_md5(content)
+    content_type = "text/markdown; charset=utf-8"
+    date = get_gmt_time()
+    canonicalized_resource = f"/{config['bucket_name']}/{object_key}"
+
+    # 生成签名
+    signature = sign_request("PUT", content_md5, content_type, date, "", canonicalized_resource, config['access_key_secret'])
+
+    # 构建请求
+    url = oss_put_url(config['bucket_name'], config['endpoint'], object_key)
+    headers = {
+        'Date': date,
+        'Content-Type': content_type,
+        'Content-MD5': content_md5,
+        'Authorization': f"OSS {config['access_key_id']}:{signature}"
+    }
+
+    # 发送PUT请求
+    req = urllib.request.Request(url, data=content, headers=headers, method='PUT')
+
+    try:
+        with urllib.request.urlopen(req, timeout=60) as response:
+            if response.status == 200:
+                oss_url = oss_put_url(config['bucket_name'], config['endpoint'], object_key)
+                return {
+                    'success': True,
+                    'url': oss_url,
+                    'object_key': object_key,
+                    'bucket': config['bucket_name'],
+                    'endpoint': config['endpoint'],
+                    'filename': filename,
+                    'file_size': len(content),
+                    'message': '上传成功'
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': f'上传失败，HTTP状态码: {response.status}'
+                }
+    except urllib.error.HTTPError as e:
+        error_body = e.read().decode('utf-8') if hasattr(e, 'read') else str(e)
+        return {
+            'success': False,
+            'error': f'HTTP错误 {e.code}: {error_body}'
+        }
+    except Exception as e:
+        return {
+            'success': False,
+            'error': f'上传失败: {str(e)}'
+        }
+
+
+def upload_docx_file(local_file_path, object_key=None, custom_headers=None):
+    """
+    上传Word文档(.docx)到OSS
+
+    Args:
+        local_file_path: 本地docx文件路径
+        object_key: OSS上的对象路径，默认为自动生成的路径
+        custom_headers: 自定义HTTP头
+
+    Returns:
+        dict: 包含上传结果的字典
+    """
+    config = get_oss_config()
+    bad = normalize_and_validate_oss_config(config)
+    if bad:
+        return bad
+
+    # 检查文件是否存在
+    if not os.path.exists(local_file_path):
+        return {
+            'success': False,
+            'error': f'文件不存在: {local_file_path}'
+        }
+
+    # 检查文件类型
+    if not local_file_path.lower().endswith('.docx'):
+        return {
+            'success': False,
+            'error': '只支持上传.docx格式的Word文档'
+        }
+
+    # 读取文件内容
+    try:
+        with open(local_file_path, 'rb') as f:
+            content = f.read()
+    except Exception as e:
+        return {
+            'success': False,
+            'error': f'读取文件失败: {str(e)}'
+        }
+
+    # 如果没有指定object_key，自动生成
+    if not object_key:
+        filename = os.path.basename(local_file_path)
+        timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+        object_key = f"word/{timestamp}_{filename}"
+
+    # 确保路径以word/开头（如果用户没指定自定义路径）
+    if not object_key.startswith('/') and not object_key.startswith('http'):
+        if not object_key.startswith('word/') and not object_key.startswith('upload/'):
+            object_key = f"word/{object_key}"
+
+    # 计算Content-MD5
+    content_md5 = calculate_md5(content)
+    content_type = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    date = get_gmt_time()
+    canonicalized_resource = f"/{config['bucket_name']}/{object_key}"
+
+    # 生成签名
+    signature = sign_request("PUT", content_md5, content_type, date, "", canonicalized_resource, config['access_key_secret'])
+
+    # 构建请求
+    url = oss_put_url(config['bucket_name'], config['endpoint'], object_key)
+    headers = {
+        'Date': date,
+        'Content-Type': content_type,
+        'Content-MD5': content_md5,
+        'Authorization': f"OSS {config['access_key_id']}:{signature}"
+    }
+
+    # 添加自定义头
+    if custom_headers:
+        headers.update(custom_headers)
+
+    # 发送PUT请求
+    req = urllib.request.Request(url, data=content, headers=headers, method='PUT')
+
+    try:
+        with urllib.request.urlopen(req, timeout=60) as response:
+            if response.status == 200:
+                oss_url = oss_put_url(config['bucket_name'], config['endpoint'], object_key)
+                return {
+                    'success': True,
+                    'url': oss_url,
+                    'object_key': object_key,
+                    'bucket': config['bucket_name'],
+                    'endpoint': config['endpoint'],
+                    'local_path': local_file_path,
+                    'file_size': len(content),
+                    'message': '上传成功'
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': f'上传失败，HTTP状态码: {response.status}'
+                }
+    except urllib.error.HTTPError as e:
+        error_body = e.read().decode('utf-8') if hasattr(e, 'read') else str(e)
+        return {
+            'success': False,
+            'error': f'HTTP错误 {e.code}: {error_body}'
+        }
+    except Exception as e:
+        return {
+            'success': False,
+            'error': f'上传失败: {str(e)}'
+        }
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description='上传文件到阿里云OSS')
+    parser.add_argument('file', help='本地文件路径')
+    parser.add_argument('--object-key', '-o', help='OSS对象路径（可选）')
+    parser.add_argument('--json', '-j', action='store_true', help='输出JSON格式结果')
+    parser.add_argument('--docx', action='store_true', help='上传Word文档(.docx)')
+
+    args = parser.parse_args()
+
+    if args.docx:
+        result = upload_docx_file(args.file, args.object_key)
+    else:
+        result = upload_markdown(args.file, args.object_key)
+
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        if result['success']:
+            print(f"✅ {result['message']}")
+            print(f"📁 本地文件: {result['local_path']}")
+            print(f"🔗 OSS URL: {result['url']}")
+            print(f"📊 文件大小: {result['file_size']} 字节")
+        else:
+            print(f"❌ {result['error']}")
+            sys.exit(1)