@ww_nero/media 1.0.0

package/README.md

@@ -0,0 +1,77 @@
+# Media MCP Server
+
+媒体处理 MCP 服务，提供语音识别等功能。
+
+## 功能
+
+### asr - 语音识别
+
+将音频文件转换为带时间戳的 SRT 字幕文件。
+
+**参数：**
+- `working_directory`: 工作目录的绝对路径，识别结果将保存到此目录
+- `audio_file`: 音频文件的相对路径（相对于工作目录），支持 mp3/wav 格式
+
+**限制：**
+- 音频长度最大 1 分钟，超出需要外部分段处理后逐段识别
+
+**输出：**
+- 识别结果保存到工作目录下的 `transcribe.srt` 文件
+
+## 环境变量
+
+| 变量名 | 说明 | 必填 |
+|--------|------|------|
+| `ASR_API_KEY` | 阿里云 ASR API Key | 是 |
+| `ASR_UPLOAD_URL` | 上传接口的完整 URL，如 `http://server.domain.com/upload` | 是 |
+
+## 依赖
+
+### Python 依赖
+
+```bash
+pip install dashscope requests
+```
+
+### 系统依赖
+
+- `ffprobe` (用于检测音频时长，来自 ffmpeg)
+- `python3`
+
+## 配置示例
+
+```json
+{
+  "mcpServers": {
+    "media": {
+      "command": "node",
+      "args": ["/path/to/media/index.js"],
+      "env": {
+        "ASR_API_KEY": "your-api-key",
+        "ASR_UPLOAD_URL": "http://server.domain.com/upload"
+      }
+    }
+  }
+}
+```
+
+## 上传接口要求
+
+上传接口需符合以下规范（参考 demo_server 实现）：
+
+**请求：**
+- 方法: `POST`
+- Content-Type: `multipart/form-data`
+- 字段名: `file`
+
+**响应（成功）：**
+```json
+{
+  "message": "文件上传成功",
+  "fileName": "abc123.mp3"
+}
+```
+
+上传的文件可通过 `{base_url}/{fileName}` 访问，例如：
+- 上传接口: `http://server.domain.com/upload`
+- 文件访问: `http://server.domain.com/abc123.mp3`

package/index.js

@@ -0,0 +1,392 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+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 ASR_API_KEY = process.env.ASR_API_KEY || '';
+const ASR_UPLOAD_URL = process.env.ASR_UPLOAD_URL || '';
+
+const SUPPORTED_AUDIO_TYPES = ['.mp3', '.wav'];
+const MAX_AUDIO_DURATION_SECONDS = 60;
+
+const SCRIPTS_DIR = path.join(__dirname, 'scripts');
+
+/**
+ * 将 Windows 路径转换为 WSL 路径，或反之
+ */
+const convertPath = (filePath) => {
+  const wslMatch = filePath.match(/^\/mnt\/([a-zA-Z])\/(.*)$/);
+  if (wslMatch) {
+    const drive = wslMatch[1].toUpperCase();
+    const rest = wslMatch[2].replace(/\//g, '\\');
+    return `${drive}:\\${rest}`;
+  }
+
+  const winMatch = filePath.match(/^([a-zA-Z]):\\(.*)$/);
+  if (winMatch) {
+    const drive = winMatch[1].toLowerCase();
+    const rest = winMatch[2].replace(/\\/g, '/');
+    return `/mnt/${drive}/${rest}`;
+  }
+
+  return null;
+};
+
+/**
+ * 解析存在的路径（支持 WSL 和 Windows 路径互转）
+ */
+const resolveExistingPath = (inputPath) => {
+  if (fs.existsSync(inputPath)) {
+    return inputPath;
+  }
+
+  const converted = convertPath(inputPath);
+  if (converted && fs.existsSync(converted)) {
+    return converted;
+  }
+
+  return null;
+};
+
+/**
+ * 解析并验证工作目录
+ */
+const resolveWorkingDirectory = (rawPath) => {
+  if (!rawPath || typeof rawPath !== 'string') {
+    throw new Error('必须提供 working_directory');
+  }
+
+  if (!path.isAbsolute(rawPath)) {
+    throw new Error('working_directory 必须是绝对路径');
+  }
+
+  const resolved = resolveExistingPath(rawPath);
+  if (!resolved) {
+    throw new Error('工作目录不存在，请确认路径是否正确');
+  }
+
+  const stats = fs.statSync(resolved);
+  if (!stats.isDirectory()) {
+    throw new Error('working_directory 必须是文件夹路径');
+  }
+
+  return resolved;
+};
+
+/**
+ * 解析并验证音频文件路径
+ */
+const resolveAudioFile = (workingDir, rawPath) => {
+  if (!rawPath || typeof rawPath !== 'string') {
+    throw new Error('音频文件路径不能为空');
+  }
+
+  const trimmed = rawPath.trim();
+  if (!trimmed) {
+    throw new Error('音频文件路径不能为空');
+  }
+
+  const absolutePath = path.isAbsolute(trimmed)
+    ? trimmed
+    : path.join(workingDir, trimmed);
+
+  const resolved = resolveExistingPath(absolutePath);
+  if (!resolved) {
+    throw new Error(`音频文件不存在: ${trimmed}`);
+  }
+
+  const stats = fs.statSync(resolved);
+  if (!stats.isFile()) {
+    throw new Error(`音频路径不是文件: ${trimmed}`);
+  }
+
+  const ext = path.extname(resolved).toLowerCase();
+  if (!SUPPORTED_AUDIO_TYPES.includes(ext)) {
+    throw new Error(`不支持的音频格式: ${ext || '未知'}，仅支持 ${SUPPORTED_AUDIO_TYPES.join(', ')}`);
+  }
+
+  return resolved;
+};
+
+/**
+ * 将路径转换为 WSL 路径格式
+ */
+const toWslPath = (targetPath) => {
+  if (targetPath.startsWith('/mnt/')) {
+    return targetPath;
+  }
+  const winMatch = targetPath.match(/^([a-zA-Z]):\\(.*)$/);
+  if (winMatch) {
+    const drive = winMatch[1].toLowerCase();
+    const rest = winMatch[2].replace(/\\/g, '/');
+    return `/mnt/${drive}/${rest}`;
+  }
+  return targetPath;
+};
+
+/**
+ * 检查是否运行在 WSL 环境中
+ */
+const isWslEnvironment = () => {
+  try {
+    if (process.platform === 'linux') {
+      const release = fs.readFileSync('/proc/version', 'utf8');
+      return release.toLowerCase().includes('microsoft');
+    }
+  } catch {
+    // ignore
+  }
+  return false;
+};
+
+/**
+ * 获取音频时长（秒）
+ */
+const getAudioDuration = (audioPath) => {
+  return new Promise((resolve) => {
+    const wslPath = toWslPath(audioPath);
+    const isWsl = isWslEnvironment();
+
+    let cmd, args;
+    if (isWsl || process.platform === 'linux') {
+      cmd = 'ffprobe';
+      args = [
+        '-v', 'error',
+        '-show_entries', 'format=duration',
+        '-of', 'default=noprint_wrappers=1:nokey=1',
+        wslPath
+      ];
+    } else {
+      cmd = 'ffprobe';
+      args = [
+        '-v', 'error',
+        '-show_entries', 'format=duration',
+        '-of', 'default=noprint_wrappers=1:nokey=1',
+        audioPath
+      ];
+    }
+
+    const child = spawn(cmd, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: false
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code === 0 && stdout.trim()) {
+        const duration = parseFloat(stdout.trim());
+        if (!isNaN(duration)) {
+          resolve(duration);
+          return;
+        }
+      }
+      // 如果获取失败，返回 -1 表示未知（不阻止执行）
+      resolve(-1);
+    });
+
+    child.on('error', () => {
+      resolve(-1);
+    });
+  });
+};
+
+/**
+ * 执行 Python 脚本进行 ASR 识别
+ */
+const runAsrScript = (audioPath, outputPath, uploadUrl, apiKey) => {
+  return new Promise((resolve, reject) => {
+    const scriptPath = path.join(SCRIPTS_DIR, 'asr_srt.py');
+    const wslScriptPath = toWslPath(scriptPath);
+    const wslAudioPath = toWslPath(audioPath);
+    const wslOutputPath = toWslPath(outputPath);
+
+    const isWsl = isWslEnvironment();
+
+    let cmd, args;
+    if (isWsl || process.platform === 'linux') {
+      cmd = 'python3';
+      args = [
+        wslScriptPath,
+        '--audio', wslAudioPath,
+        '--output', wslOutputPath,
+        '--upload-url', uploadUrl,
+        '--api-key', apiKey
+      ];
+    } else {
+      // Windows 环境，通过 wsl 调用
+      cmd = 'wsl';
+      args = [
+        '-e', 'python3',
+        wslScriptPath,
+        '--audio', wslAudioPath,
+        '--output', wslOutputPath,
+        '--upload-url', uploadUrl,
+        '--api-key', apiKey
+      ];
+    }
+
+    const child = spawn(cmd, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: false,
+      env: {
+        ...process.env,
+        ASR_API_KEY: apiKey
+      }
+    });
+
+    let stdout = '';
+    let stderr = '';
+    const maxOutput = 64 * 1024;
+
+    child.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+      if (stdout.length > maxOutput) {
+        stdout = stdout.slice(-maxOutput);
+      }
+    });
+
+    child.stderr.on('data', (data) => {
+      const chunk = data.toString();
+      stderr += chunk;
+      if (stderr.length > maxOutput) {
+        stderr = stderr.slice(-maxOutput);
+      }
+    });
+
+    const timeout = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error('ASR 识别超时（超过 5 分钟）'));
+    }, 5 * 60 * 1000);
+
+    child.on('close', (code) => {
+      clearTimeout(timeout);
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        const errorMsg = stderr.trim() || stdout.trim() || `进程退出码: ${code}`;
+        reject(new Error(errorMsg));
+      }
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`执行脚本失败: ${err.message}`));
+    });
+  });
+};
+
+/**
+ * ASR 语音识别
+ */
+const asr = async ({ working_directory, audio_file }) => {
+  // 验证环境变量
+  if (!ASR_API_KEY) {
+    throw new Error('请配置 ASR_API_KEY 环境变量');
+  }
+  if (!ASR_UPLOAD_URL) {
+    throw new Error('请配置 ASR_UPLOAD_URL 环境变量（完整的上传接口 URL，如 http://server.domain.com/upload）');
+  }
+
+  const workingDir = resolveWorkingDirectory(working_directory);
+  const audioPath = resolveAudioFile(workingDir, audio_file);
+
+  // 检查音频时长
+  const duration = await getAudioDuration(audioPath);
+  if (duration > 0 && duration > MAX_AUDIO_DURATION_SECONDS) {
+    throw new Error(
+      `音频时长 ${Math.round(duration)} 秒超过限制（最大 ${MAX_AUDIO_DURATION_SECONDS} 秒）。` +
+      `请先对音频进行分段处理后再逐段识别。`
+    );
+  }
+
+  // 输出文件路径
+  const outputPath = path.join(workingDir, 'transcribe.srt');
+
+  // 执行 ASR 脚本
+  await runAsrScript(audioPath, outputPath, ASR_UPLOAD_URL, ASR_API_KEY);
+
+  return 'transcribe.srt';
+};
+
+const server = new Server(
+  {
+    name: 'media',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'asr',
+      description: '语音识别工具，将音频文件转换为带时间戳的 SRT 字幕文件。支持 mp3/wav 格式，音频长度限制 1 分钟以内。',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          working_directory: {
+            type: 'string',
+            description: '工作目录的绝对路径，识别结果将保存到此目录下的 transcribe.srt 文件',
+          },
+          audio_file: {
+            type: 'string',
+            description: '音频文件的相对路径（相对于工作目录），支持 mp3/wav 格式',
+          },
+        },
+        required: ['working_directory', 'audio_file'],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    if (name === 'asr') {
+      const { working_directory, audio_file } = args;
+      if (!working_directory || !audio_file) {
+        throw new Error('必须同时提供 working_directory 和 audio_file 参数');
+      }
+      const filename = await asr({ working_directory, audio_file });
+      return { content: [{ type: 'text', text: `语音识别完成，字幕文件已保存到工作目录下：${filename}` }] };
+    }
+
+    return {
+      content: [{ type: 'text', text: `未知工具: ${name}` }],
+      isError: true,
+    };
+  } catch (error) {
+    const message = error?.message || '未知错误';
+    return { content: [{ type: 'text', text: message }], isError: true };
+  }
+});
+
+const main = async () => {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+};
+
+main().catch(console.error);

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@ww_nero/media",
+  "version": "1.0.0",
+  "description": "MCP server for media processing, including ASR speech recognition",
+  "main": "index.js",
+  "bin": {
+    "media": "index.js"
+  },
+  "files": [
+    "index.js",
+    "scripts"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.22.0"
+  }
+}

package/scripts/asr_srt.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ASR 语音识别脚本
+上传音频文件到服务器，调用阿里云 ASR 接口进行识别，生成 SRT 字幕文件
+"""
+
+import os
+import sys
+import json
+import time
+import argparse
+import requests
+from pathlib import Path
+from http import HTTPStatus
+
+# 尝试导入 dashscope，如果失败则提示安装
+try:
+    import dashscope
+    from dashscope.audio.asr import Transcription
+except ImportError:
+    print("错误: 请先安装 dashscope 库: pip install dashscope", file=sys.stderr)
+    sys.exit(1)
+
+
+def ms_to_srt_time(ms: int) -> str:
+    """将毫秒转换为 SRT 时间格式 HH:MM:SS,mmm"""
+    hours = ms // 3600000
+    minutes = (ms % 3600000) // 60000
+    seconds = (ms % 60000) // 1000
+    milliseconds = ms % 1000
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d},{milliseconds:03d}"
+
+
+def asr_to_srt(asr_data: list, output_srt_path: str):
+    """
+    将 ASR 识别结果转换为 SRT 字幕文件
+
+    Args:
+        asr_data: ASR 识别结果列表
+        output_srt_path: 输出的 SRT 文件路径
+    """
+    srt_entries = []
+    subtitle_index = 1
+
+    for item in asr_data:
+        transcription = item.get('transcription', {})
+        transcripts = transcription.get('transcripts', [])
+
+        for transcript in transcripts:
+            sentences = transcript.get('sentences', [])
+
+            for sentence in sentences:
+                begin_time = sentence.get('begin_time', 0)
+                end_time = sentence.get('end_time', 0)
+                text = sentence.get('text', '').strip()
+
+                if text:
+                    start_str = ms_to_srt_time(begin_time)
+                    end_str = ms_to_srt_time(end_time)
+
+                    srt_entry = f"{subtitle_index}\n{start_str} --> {end_str}\n{text}\n"
+                    srt_entries.append(srt_entry)
+                    subtitle_index += 1
+
+    with open(output_srt_path, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(srt_entries))
+
+    return subtitle_index - 1
+
+
+def upload_audio(upload_url: str, audio_path: str) -> str:
+    """
+    上传音频文件到服务器
+
+    Args:
+        upload_url: 上传接口的完整 URL
+        audio_path: 本地音频文件路径
+
+    Returns:
+        上传后的文件名
+    """
+    audio_path = Path(audio_path)
+    if not audio_path.exists():
+        raise FileNotFoundError(f"音频文件不存在: {audio_path}")
+
+    with open(audio_path, 'rb') as f:
+        files = {'file': (audio_path.name, f)}
+        response = requests.post(upload_url, files=files, timeout=60)
+
+    if response.status_code == 409:
+        # 文件已存在，从响应中获取文件名或根据原文件名推断
+        data = response.json()
+        if 'fileName' in data:
+            return data['fileName']
+        # 如果没有返回文件名，使用原始文件名的扩展名
+        raise Exception(f"文件已存在: {data.get('message', '未知错误')}")
+
+    if response.status_code != 200:
+        raise Exception(f"上传失败: {response.status_code} - {response.text}")
+
+    data = response.json()
+    if 'fileName' not in data:
+        raise Exception(f"上传响应格式错误: {data}")
+
+    return data['fileName']
+
+
+def get_static_url(upload_url: str, filename: str) -> str:
+    """
+    根据上传接口 URL 和文件名构建静态资源 URL
+
+    Args:
+        upload_url: 上传接口的完整 URL (如 http://server.domain.com/upload)
+        filename: 上传后的文件名
+
+    Returns:
+        静态资源的完整 URL
+    """
+    # 从上传 URL 中提取基础 URL
+    # 例如: http://server.domain.com/upload -> http://server.domain.com/
+    from urllib.parse import urlparse, urlunparse
+    parsed = urlparse(upload_url)
+    base_url = urlunparse((parsed.scheme, parsed.netloc, '/', '', '', ''))
+    return f"{base_url.rstrip('/')}/{filename}"
+
+
+def transcribe_audio(audio_url: str, api_key: str) -> list:
+    """
+    调用阿里云 ASR 接口进行语音识别
+
+    Args:
+        audio_url: 音频文件的公网 URL
+        api_key: 阿里云 ASR API Key
+
+    Returns:
+        识别结果列表
+    """
+    dashscope.api_key = api_key
+
+    # 发起异步识别请求
+    transcribe_response = Transcription.async_call(
+        model='paraformer-v2',
+        file_urls=[audio_url],
+        language_hints=['zh', 'en', 'ja']
+    )
+
+    if not transcribe_response or not hasattr(transcribe_response, 'output'):
+        raise Exception("ASR 请求失败: 无效的响应")
+
+    # 轮询等待识别完成
+    while True:
+        task_status = transcribe_response.output.task_status
+        if task_status == 'SUCCEEDED' or task_status == 'FAILED':
+            break
+        time.sleep(1)
+        transcribe_response = Transcription.fetch(task=transcribe_response.output.task_id)
+
+    if transcribe_response.status_code != HTTPStatus.OK:
+        raise Exception(f"ASR 识别失败: {transcribe_response.status_code}")
+
+    if transcribe_response.output.task_status == 'FAILED':
+        raise Exception("ASR 识别任务失败")
+
+    # 获取识别结果
+    results = transcribe_response.output.get('results', [])
+    all_transcriptions = []
+
+    for result in results:
+        if result.get('subtask_status') == 'SUCCEEDED':
+            transcription_url = result.get('transcription_url')
+            if transcription_url:
+                resp = requests.get(transcription_url, timeout=30)
+                if resp.status_code == 200:
+                    transcription_data = resp.json()
+                    all_transcriptions.append({
+                        'file_url': result.get('file_url'),
+                        'transcription': transcription_data
+                    })
+
+    return all_transcriptions
+
+
+def main():
+    parser = argparse.ArgumentParser(description='ASR 语音识别并生成 SRT 字幕')
+    parser.add_argument('--audio', required=True, help='音频文件路径')
+    parser.add_argument('--output', required=True, help='输出 SRT 文件路径')
+    parser.add_argument('--upload-url', required=True, help='上传接口的完整 URL')
+    parser.add_argument('--api-key', help='ASR API Key (也可通过 ASR_API_KEY 环境变量设置)')
+
+    args = parser.parse_args()
+
+    # 获取 API Key
+    api_key = args.api_key or os.environ.get('ASR_API_KEY')
+    if not api_key:
+        print("错误: 请通过 --api-key 参数或 ASR_API_KEY 环境变量提供 API Key", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        # 1. 上传音频文件
+        print(f"正在上传音频文件: {args.audio}")
+        filename = upload_audio(args.upload_url, args.audio)
+        print(f"上传成功: {filename}")
+
+        # 2. 构建静态资源 URL
+        audio_url = get_static_url(args.upload_url, filename)
+        print(f"音频 URL: {audio_url}")
+
+        # 3. 调用 ASR 识别
+        print("正在进行语音识别...")
+        transcriptions = transcribe_audio(audio_url, api_key)
+
+        if not transcriptions:
+            print("警告: 未获取到识别结果", file=sys.stderr)
+            sys.exit(1)
+
+        # 4. 生成 SRT 文件
+        subtitle_count = asr_to_srt(transcriptions, args.output)
+        print(f"SRT 字幕文件已生成: {args.output}")
+        print(f"共 {subtitle_count} 条字幕")
+
+    except FileNotFoundError as e:
+        print(f"错误: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"错误: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()