@ww_nero/media 1.0.5 → 1.0.6

package/README.md

@@ -13,7 +13,9 @@
 - `audio_file`: 音频文件的相对路径（相对于工作目录），支持 mp3/wav 格式
 
 **限制：**
-- 音频长度最大 1 分钟，超出需要外部分段处理后逐段识别
+- 音频长度最大 1 分钟
+- 文件大小不超过 5MB
+- 超出限制需要外部分段处理后逐段识别
 
 **输出：**
 - 识别结果保存到工作目录下的 `transcribe.srt` 文件
@@ -22,22 +24,14 @@
 
 | 变量名 | 说明 | 必填 |
 |--------|------|------|
-| `ASR_API_KEY` | 阿里云 ASR API Key | 是 |
-| `ASR_UPLOAD_URL` | 上传接口的完整 URL，如 `http://server.domain.com/upload` | 是 |
+| `ASR_API_KEY` | 阿里云 DashScope API Key | 是 |
 
-## 依赖
-
-### Python 依赖
+## 安装
 
 ```bash
-pip install dashscope requests
+npm install
 ```
 
-### 系统依赖
-
-- `ffprobe` (用于检测音频时长，来自 ffmpeg)
-- `python3`
-
 ## 配置示例
 
 ```json
@@ -47,31 +41,9 @@ pip install dashscope requests
       "command": "node",
       "args": ["/path/to/media/index.js"],
       "env": {
-        "ASR_API_KEY": "your-api-key",
-        "ASR_UPLOAD_URL": "http://server.domain.com/upload"
+        "ASR_API_KEY": "your-api-key"
       }
     }
   }
 }
 ```
-
-## 上传接口要求
-
-上传接口需符合以下规范（参考 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

@@ -2,7 +2,6 @@
 
 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 {
@@ -12,11 +11,185 @@ const {
 
 const ASR_API_KEY = process.env.ASR_API_KEY || '';
 const ASR_UPLOAD_URL = 'http://fsheep.com:10808/upload';
+const ASR_SERVICE_URL = 'https://dashscope.aliyuncs.com/api/v1/services/audio/asr/transcription';
 
 const SUPPORTED_AUDIO_TYPES = ['.mp3', '.wav'];
-const MAX_AUDIO_DURATION_SECONDS = 60;
+const MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024; // 5MB
+const LANGUAGE_HINTS = ['zh', 'en', 'ja'];
 
-const SCRIPTS_DIR = path.join(__dirname, 'scripts');
+/**
+ * 将毫秒转换为 SRT 时间格式 HH:MM:SS,mmm
+ */
+const msToSrtTime = (ms) => {
+  const hours = Math.floor(ms / 3600000);
+  const minutes = Math.floor((ms % 3600000) / 60000);
+  const seconds = Math.floor((ms % 60000) / 1000);
+  const milliseconds = ms % 1000;
+  return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')},${String(milliseconds).padStart(3, '0')}`;
+};
+
+/**
+ * 将 ASR 识别结果转换为 SRT 字幕内容
+ */
+const asrToSrt = (asrData) => {
+  const srtEntries = [];
+  let subtitleIndex = 1;
+
+  for (const item of asrData) {
+    const transcription = item.transcription || {};
+    const transcripts = transcription.transcripts || [];
+
+    for (const transcript of transcripts) {
+      const sentences = transcript.sentences || [];
+
+      for (const sentence of sentences) {
+        const beginTime = sentence.begin_time || 0;
+        const endTime = sentence.end_time || 0;
+        const text = (sentence.text || '').trim();
+
+        if (text) {
+          const startStr = msToSrtTime(beginTime);
+          const endStr = msToSrtTime(endTime);
+
+          srtEntries.push(`${subtitleIndex}\n${startStr} --> ${endStr}\n${text}\n`);
+          subtitleIndex++;
+        }
+      }
+    }
+  }
+
+  return srtEntries.join('\n');
+};
+
+/**
+ * 上传音频文件到服务器
+ */
+const uploadAudio = async (uploadUrl, audioPath) => {
+  const fileBuffer = fs.readFileSync(audioPath);
+  const fileName = path.basename(audioPath);
+
+  const FormData = (await import('form-data')).default;
+  const formData = new FormData();
+  formData.append('file', fileBuffer, fileName);
+
+  const response = await fetch(uploadUrl, {
+    method: 'POST',
+    body: formData,
+    headers: formData.getHeaders(),
+  });
+
+  if (!response.ok) {
+    throw new Error(`上传失败: ${response.status} - ${await response.text()}`);
+  }
+
+  const data = await response.json();
+
+  if (!data.success || !data.data || !data.data.path) {
+    throw new Error(`上传响应格式错误: ${JSON.stringify(data)}`);
+  }
+
+  return data.data.path;
+};
+
+/**
+ * 根据上传接口 URL 和文件路径构建静态资源 URL
+ */
+const getStaticUrl = (uploadUrl, filePath) => {
+  const url = new URL(uploadUrl);
+  return `${url.protocol}//${url.host}${filePath}`;
+};
+
+/**
+ * 提交 ASR 转写任务
+ */
+const submitAsrTask = async (fileUrls, apiKey) => {
+  const response = await fetch(ASR_SERVICE_URL, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      'X-DashScope-Async': 'enable',
+    },
+    body: JSON.stringify({
+      model: 'paraformer-v2',
+      input: { file_urls: fileUrls },
+      parameters: {
+        channel_id: [0],
+        language_hints: LANGUAGE_HINTS,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`ASR 任务提交失败: ${response.status} - ${errorText}`);
+  }
+
+  const data = await response.json();
+
+  if (!data.output || !data.output.task_id) {
+    throw new Error(`ASR 响应格式错误: ${JSON.stringify(data)}`);
+  }
+
+  return data.output.task_id;
+};
+
+/**
+ * 轮询等待 ASR 任务完成
+ */
+const waitForTaskComplete = async (taskId, apiKey, timeoutMs = 5 * 60 * 1000) => {
+  const taskUrl = `https://dashscope.aliyuncs.com/api/v1/tasks/${taskId}`;
+  const startTime = Date.now();
+  const pollInterval = 500;
+
+  while (Date.now() - startTime < timeoutMs) {
+    const response = await fetch(taskUrl, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`查询任务状态失败: ${response.status}`);
+    }
+
+    const data = await response.json();
+    const status = data.output?.task_status;
+
+    if (status === 'SUCCEEDED') {
+      return data.output.results || [];
+    } else if (status === 'FAILED') {
+      throw new Error('ASR 识别任务失败');
+    }
+
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+  }
+
+  throw new Error('ASR 识别超时');
+};
+
+/**
+ * 获取转写结果详情
+ */
+const fetchTranscriptionResults = async (results) => {
+  const allTranscriptions = [];
+
+  for (const result of results) {
+    if (result.subtask_status === 'SUCCEEDED' && result.transcription_url) {
+      const response = await fetch(result.transcription_url);
+      if (response.ok) {
+        const transcriptionData = await response.json();
+        allTranscriptions.push({
+          file_url: result.file_url,
+          transcription: transcriptionData,
+        });
+      }
+    }
+  }
+
+  return allTranscriptions;
+};
 
 /**
  * 将 Windows 路径转换为 WSL 路径，或反之
@@ -115,175 +288,6 @@ const resolveAudioFile = (workingDir, rawPath) => {
   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);
-
-    // 构建 python 命令字符串
-    const pythonCommand = [
-      'python',
-      `"${wslScriptPath}"`,
-      '--audio', `"${wslAudioPath}"`,
-      '--output', `"${wslOutputPath}"`,
-      '--upload-url', `"${uploadUrl}"`,
-      '--api-key', `"${apiKey}"`
-    ].join(' ');
-
-    const isWsl = isWslEnvironment();
-
-    // 参考 bash.js 的调用方式，通过 bash -ic 执行命令
-    cmd = 'bash';
-    args = ['-ic', pythonCommand];
-
-    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 语音识别
  */
@@ -296,20 +300,38 @@ const asr = async ({ working_directory, audio_file }) => {
   const workingDir = resolveWorkingDirectory(working_directory);
   const audioPath = resolveAudioFile(workingDir, audio_file);
 
-  // 检查音频时长
-  const duration = await getAudioDuration(audioPath);
-  if (duration > 0 && duration > MAX_AUDIO_DURATION_SECONDS) {
+  // 检查文件大小
+  const fileSize = fs.statSync(audioPath).size;
+  if (fileSize > MAX_FILE_SIZE_BYTES) {
     throw new Error(
-      `音频时长 ${Math.round(duration)} 秒超过限制（最大 ${MAX_AUDIO_DURATION_SECONDS} 秒）。` +
+      `音频文件大小 ${(fileSize / 1024 / 1024).toFixed(2)}MB 超过限制（最大 5MB）。` +
       `请先对音频进行分段处理后再逐段识别。`
     );
   }
 
-  // 输出文件路径
-  const outputPath = path.join(workingDir, 'transcribe.srt');
+  // 1. 上传音频文件
+  const filePath = await uploadAudio(ASR_UPLOAD_URL, audioPath);
+
+  // 2. 构建静态资源 URL
+  const audioUrl = getStaticUrl(ASR_UPLOAD_URL, filePath);
+
+  // 3. 提交 ASR 任务
+  const taskId = await submitAsrTask([audioUrl], ASR_API_KEY);
+
+  // 4. 等待任务完成
+  const results = await waitForTaskComplete(taskId, ASR_API_KEY);
 
-  // 执行 ASR 脚本
-  await runAsrScript(audioPath, outputPath, ASR_UPLOAD_URL, ASR_API_KEY);
+  // 5. 获取转写结果
+  const transcriptions = await fetchTranscriptionResults(results);
+
+  if (!transcriptions.length) {
+    throw new Error('未获取到识别结果');
+  }
+
+  // 6. 转换为 SRT 格式并保存
+  const srtContent = asrToSrt(transcriptions);
+  const outputPath = path.join(workingDir, 'transcribe.srt');
+  fs.writeFileSync(outputPath, srtContent, 'utf-8');
 
   return 'transcribe.srt';
 };
@@ -317,7 +339,7 @@ const asr = async ({ working_directory, audio_file }) => {
 const server = new Server(
   {
     name: 'media',
-    version: '1.0.5',
+    version: '1.0.6',
   },
   {
     capabilities: {
@@ -330,7 +352,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
     {
       name: 'asr',
-      description: '语音识别工具，将音频文件转换为带时间戳的 SRT 字幕文件。支持 mp3/wav 格式，音频长度限制 1 分钟以内。',
+      description: '语音识别工具，将音频文件转换为带时间戳的 SRT 字幕文件。',
       inputSchema: {
         type: 'object',
         properties: {
@@ -340,7 +362,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
           },
           audio_file: {
             type: 'string',
-            description: '音频文件的相对路径（相对于工作目录），支持 mp3/wav 格式',
+            description: '音频文件的相对路径（相对于工作目录），支持 mp3/wav 格式，音频长度限制 1 分钟以内，文件大小不超过 5MB',
           },
         },
         required: ['working_directory', 'audio_file'],

package/package.json

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

package/scripts/asr_srt.py

@@ -1,227 +0,0 @@
-#!/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 != 200:
-        raise Exception(f"上传失败: {response.status_code} - {response.text}")
-
-    data = response.json()
-
-    # 响应格式: {'success': True, 'data': {'path': '/tmp/xxx.wav'}}
-    if not data.get('success') or 'data' not in data or 'path' not in data['data']:
-        raise Exception(f"上传响应格式错误: {data}")
-
-    # 返回完整的相对路径，用于拼接到服务器地址后面
-    return data['data']['path']
-
-
-def get_static_url(upload_url: str, file_path: str) -> str:
-    """
-    根据上传接口 URL 和文件路径构建静态资源 URL
-
-    Args:
-        upload_url: 上传接口的完整 URL (如 http://server.domain.com/upload)
-        file_path: 上传后返回的文件路径 (如 /tmp/xxx.wav)
-
-    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, '', '', '', ''))
-    # file_path 已经是以 / 开头的完整相对路径，直接拼接
-    return f"{base_url}{file_path}"
-
-
-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}")
-        file_path = upload_audio(args.upload_url, args.audio)
-        print(f"上传成功: {file_path}")
-
-        # 2. 构建静态资源 URL
-        audio_url = get_static_url(args.upload_url, file_path)
-        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()