yuanflow-cli 0.1.43 → 0.1.45

package/src/voice-tools.js

@@ -0,0 +1,471 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { readConfig } from './config.js';
+import { callAtomic, cleanBaseUrl } from './atomic-request.js';
+
+const AUDIO_SPEECH_PATH = '/v1/audio/speech';
+const AUDIO_VOICES_PATH = '/v1/audio/voices';
+const YUANFLOW_FILE_TRANSFER_PATH = '/atomic/oss/temp-upload';
+
+const MODEL_VOICE_CLONE = 'qwen-voice-enrollment';
+const MODEL_VOICE_REPLICATE = 'qwen3-tts-vc-realtime-2026-01-15';
+
+export function listVoiceCommands() {
+  return [
+    voiceCommand({
+      key: 'voice.clone',
+      command: 'voice clone',
+      description: '通过 YuanFlow API 创建声音克隆，返回可复用的 voice_xxx 音色 ID。',
+      method: 'POST',
+      apiPath: AUDIO_VOICES_PATH,
+      options: [
+        option('--file', 'file', false, '本地音频文件；与 --file-transfer、--audio-url 三选一。'),
+        option('--file-transfer', 'fileTransfer', false, '本地音频文件；先通过 YuanFlow 文件中转生成临时 URL，再创建声音克隆。'),
+        option('--audio-url', 'audioUrl', false, '公网可访问音频 URL；与 --file、--file-transfer 三选一。'),
+        option('--name', 'name', false, '声音克隆展示名。'),
+        option('--preferred-name', 'preferredName', false, '偏好音色名，默认跟随 --name。'),
+        option('--text', 'text', false, '参考音频对应文本，可选。'),
+        option('--language', 'language', false, '语言代码，可选。'),
+        option('--activate', 'activate', false, '创建后设为当前默认音色。'),
+        ...commonOptions(),
+      ],
+      requestBody: {
+        model: MODEL_VOICE_CLONE,
+        audio: '<本地音频 data URI，或通过 audio_url 传入 YuanFlow 文件中转 URL>',
+      },
+      returns: '返回 voice_xxx 音色对象；后续 voice replicate 可通过 --voice voice_xxx 复刻声音。',
+    }),
+    voiceCommand({
+      key: 'voice.list',
+      command: 'voice list',
+      description: '查询当前 YuanFlow API 令牌下已有的声音克隆音色 ID。',
+      method: 'GET',
+      apiPath: AUDIO_VOICES_PATH,
+      options: commonOptions(),
+      requestBody: null,
+      returns: '返回当前用户可用的 voice_xxx 音色列表、名称、状态和是否默认激活。',
+    }),
+    voiceCommand({
+      key: 'voice.activate',
+      command: 'voice activate',
+      description: '把已有声音克隆音色设为默认音色，方便 voice replicate 使用 default 复刻。',
+      method: 'POST',
+      apiPath: `${AUDIO_VOICES_PATH}/{voice_xxx}/activate`,
+      options: [
+        option('--voice', 'voice', true, '声音克隆 ID，例如 voice_xxx。'),
+        ...commonOptions(),
+      ],
+      requestBody: null,
+      returns: '返回已激活的 voice_xxx 音色对象。',
+    }),
+    voiceCommand({
+      key: 'voice.replicate',
+      command: 'voice replicate',
+      description: '使用已有声音克隆音色 ID 复刻生成音频文件。',
+      method: 'POST',
+      apiPath: AUDIO_SPEECH_PATH,
+      options: [
+        option('--text', 'text', true, '待复刻合成文本。'),
+        option('--voice', 'voice', true, '声音克隆 ID：voice_xxx；也可传 default 使用已激活默认音色。'),
+        option('--output', 'output', true, '音频保存路径；dry-run 时可不传。'),
+        option('--response-format', 'responseFormat', false, 'mp3、wav、pcm 等，默认 mp3。'),
+        option('--speed', 'speed', false, '语速控制。'),
+        option('--sample-rate', 'sampleRate', false, '采样率。'),
+        option('--metadata', 'metadata', false, '透传给 YuanFlow API 的 metadata JSON。'),
+        ...commonOptions(),
+      ],
+      requestBody: {
+        model: MODEL_VOICE_REPLICATE,
+        input: '<text>',
+        voice: '<voice_xxx|default>',
+      },
+      returns: '返回音频二进制；CLI 通过 --output 保存到本地文件。',
+    }),
+  ];
+}
+
+export function formatVoiceHelp() {
+  return listVoiceCommands()
+    .map((command) => {
+      const options = command.options.map((item) => `    ${item.flag} ${item.label}`).join('\n');
+      return `${command.command}\n  ${command.description}\n  接口：${command.method} ${command.apiPath}\n  参数：\n${options}\n  返回：${command.returns}`;
+    })
+    .join('\n\n');
+}
+
+export async function runVoiceCommand({ action = 'help', options }) {
+  switch (action) {
+    case 'help':
+    case 'list-commands':
+      return { ok: true, commands: listVoiceCommands() };
+    case 'clone':
+      return cloneVoice(options);
+    case 'list':
+      return listVoices(options);
+    case 'activate':
+      return activateVoice(options);
+    case 'replicate':
+      return replicateVoice(options);
+    default:
+      throw new Error(`未知 voice 命令：${action}。可执行 yuanflow-cli voice help 查看用法。`);
+  }
+}
+
+async function cloneVoice(options) {
+  const body = await buildVoiceCloneBody(options);
+  const response = await callJson(AUDIO_VOICES_PATH, options, body);
+  return result('voice clone', AUDIO_VOICES_PATH, body, response, { kind: 'voice-clone' });
+}
+
+async function listVoices(options) {
+  const response = await callGetJson(AUDIO_VOICES_PATH, options);
+  return result('voice list', AUDIO_VOICES_PATH, undefined, response, {
+    method: 'GET',
+    kind: 'voice-clone',
+  });
+}
+
+async function activateVoice(options) {
+  const voice = requiredVoice(options);
+  const endpointPath = `${AUDIO_VOICES_PATH}/${encodeURIComponent(voice)}/activate`;
+  const response = await callJson(endpointPath, options, {});
+  return result('voice activate', endpointPath, undefined, response, { kind: 'voice-clone' });
+}
+
+async function replicateVoice(options) {
+  const body = buildVoiceReplicateBody(options);
+  const response = await callBinary(AUDIO_SPEECH_PATH, options, body);
+  return result('voice replicate', AUDIO_SPEECH_PATH, body, response, { kind: 'voice-replicate' });
+}
+
+async function buildVoiceCloneBody(options) {
+  if (options.json) {
+    return JSON.parse(options.json);
+  }
+  const filePath = cleanOptional(options.file);
+  const fileTransferPath = cleanOptional(options.named?.['file-transfer']);
+  const audioUrl = cleanOptional(options.named?.['audio-url']);
+  const sources = [filePath, fileTransferPath, audioUrl].filter(Boolean);
+  if (sources.length === 0) {
+    throw new Error('缺少 --file、--file-transfer 或 --audio-url。');
+  }
+  if (sources.length > 1) {
+    throw new Error('--file、--file-transfer 和 --audio-url 只能选择一个。');
+  }
+
+  const body = {
+    model: MODEL_VOICE_CLONE,
+    ...optionalField('name', options.named?.name),
+    ...optionalField('preferred_name', options.named?.['preferred-name']),
+    ...optionalField('text', options.named?.text),
+    ...optionalField('language', options.named?.language),
+    ...optionalBooleanField('activate', options.named?.activate),
+  };
+  if (audioUrl) {
+    body.audio_url = audioUrl;
+  } else if (fileTransferPath) {
+    body.audio_url = await resolveYuanFlowAudioFile(fileTransferPath, options);
+  } else {
+    body.audio = options.dryRun ? '<data URI omitted in dry-run>' : await fileToDataUri(filePath);
+  }
+  return body;
+}
+
+function buildVoiceReplicateBody(options) {
+  if (options.json) {
+    return JSON.parse(options.json);
+  }
+  const text = cleanOptional(options.named?.text || options.named?.input);
+  if (!text) {
+    throw new Error('缺少 --text。');
+  }
+  const voice = requiredVoice(options);
+  const body = {
+    model: MODEL_VOICE_REPLICATE,
+    input: text,
+    voice,
+    response_format: cleanOptional(options.named?.['response-format']) || 'mp3',
+    ...optionalField('instructions', options.named?.instructions),
+  };
+  addNumber(body, 'speed', options.named?.speed);
+  const metadata = parseJsonObject(options.named?.metadata);
+  addNumber(metadata, 'sample_rate', options.named?.['sample-rate']);
+  if (Object.keys(metadata).length > 0) {
+    body.metadata = metadata;
+  }
+  return body;
+}
+
+async function resolveYuanFlowAudioFile(filePath, options) {
+  const filename = path.basename(filePath);
+  if (options.dryRun) {
+    return `<YuanFlow 文件中转 signed_url:${filename}>`;
+  }
+  const response = await callAtomic(YUANFLOW_FILE_TRANSFER_PATH, {
+    ...options,
+    json: undefined,
+    method: 'POST',
+    body: {
+      filename,
+      content_base64: (await readFile(filePath)).toString('base64'),
+      content_type: inferAudioMimeType(filePath),
+    },
+  });
+  const data = response?.data && typeof response.data === 'object' ? response.data : response;
+  const url = cleanOptional(data?.signed_url) || cleanOptional(data?.url);
+  if (!url) {
+    throw new Error('YuanFlow 文件中转未返回 signed_url 或 url。');
+  }
+  return url;
+}
+
+async function callJson(apiPath, options, body) {
+  const request = await buildRequest(apiPath, options, 'POST', body);
+  if (request.dryRun) {
+    return request;
+  }
+  const response = await fetch(request.url, {
+    method: 'POST',
+    headers: {
+      ...request.headers,
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body || {}),
+  });
+  return readJsonResponse(response);
+}
+
+async function callGetJson(apiPath, options) {
+  const request = await buildRequest(apiPath, options, 'GET');
+  if (request.dryRun) {
+    return request;
+  }
+  const response = await fetch(request.url, {
+    method: 'GET',
+    headers: {
+      ...request.headers,
+      Accept: 'application/json',
+    },
+  });
+  return readJsonResponse(response);
+}
+
+async function callBinary(apiPath, options, body) {
+  const request = await buildRequest(apiPath, options, 'POST', body);
+  if (request.dryRun) {
+    return request;
+  }
+  if (!options.output) {
+    throw new Error('声音复刻需要 --output 指定保存路径。');
+  }
+  const response = await fetch(request.url, {
+    method: 'POST',
+    headers: {
+      ...request.headers,
+      Accept: '*/*',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body || {}),
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`请求失败：HTTP ${response.status} ${text}`);
+  }
+  const bytes = Buffer.from(await response.arrayBuffer());
+  await writeFile(options.output, bytes);
+  return {
+    ok: true,
+    output: options.output,
+    bytes: bytes.length,
+    content_type: response.headers.get('content-type') || '',
+  };
+}
+
+async function buildRequest(apiPath, options, method, body) {
+  const config = await readConfig();
+  const baseUrl = cleanBaseUrl(options.baseUrl || config.baseUrl);
+  const token = options.token || process.env.YUANCHUANG_API_TOKEN || config.token || '';
+  const url = new URL(apiPath, baseUrl);
+  if (options.dryRun) {
+    return {
+      dryRun: true,
+      method,
+      url: url.toString(),
+      headers: token ? { Authorization: `Bearer ${maskToken(token)}` } : {},
+      body: redactBody(body),
+    };
+  }
+  if (!token) {
+    throw new Error('缺少 token。请设置 YUANCHUANG_API_TOKEN，或执行 yuanflow-cli config set-token <你的令牌>');
+  }
+  return {
+    method,
+    url: url.toString(),
+    headers: { Authorization: `Bearer ${token}` },
+    body,
+  };
+}
+
+async function readJsonResponse(response) {
+  const text = await response.text();
+  const payload = parseMaybeJson(text);
+  if (!response.ok) {
+    const message = typeof payload === 'object' ? JSON.stringify(payload) : text;
+    throw new Error(`请求失败：HTTP ${response.status} ${message}`);
+  }
+  return payload;
+}
+
+function result(action, endpointPath, body, response, endpoint = {}) {
+  return {
+    ok: true,
+    action,
+    endpoint: { method: endpoint.method || 'POST', path: endpointPath, kind: endpoint.kind || 'voice' },
+    request: { body: redactBody(body) },
+    response,
+  };
+}
+
+function voiceCommand({ key, command, description, method, apiPath, options, requestBody, returns }) {
+  return {
+    key,
+    command,
+    kind: 'voice',
+    description,
+    method,
+    apiPath,
+    positionals: [],
+    options,
+    requestBody,
+    returns,
+  };
+}
+
+function requiredVoice(options) {
+  const voice = cleanOptional(options.named?.voice || options.named?.['voice-id']);
+  if (!voice) {
+    throw new Error('缺少 --voice。');
+  }
+  return voice;
+}
+
+function commonOptions() {
+  return [
+    option('--json', 'json', false, '直接传完整 YuanFlow API 请求 JSON。'),
+    option('--token', 'token', false, '临时 token。'),
+    option('--base-url', 'baseUrl', false, 'YuanFlow API 地址。'),
+    option('--format', 'format', false, 'Agent 调用时建议使用 agent-json。'),
+    option('--dry-run', 'dryRun', false, '仅预览请求映射，不发起真实请求，也不要求 token。'),
+  ];
+}
+
+function option(flag, name, required, label) {
+  return { flag, name, required, label };
+}
+
+async function fileToDataUri(filePath) {
+  const data = await readFile(filePath);
+  return `data:${inferAudioMimeType(filePath)};base64,${data.toString('base64')}`;
+}
+
+function inferAudioMimeType(filePath) {
+  switch (path.extname(filePath).toLowerCase()) {
+    case '.mp3':
+      return 'audio/mpeg';
+    case '.wav':
+      return 'audio/wav';
+    case '.m4a':
+      return 'audio/mp4';
+    case '.ogg':
+      return 'audio/ogg';
+    case '.flac':
+      return 'audio/flac';
+    case '.pcm':
+      return 'audio/pcm';
+    default:
+      return 'application/octet-stream';
+  }
+}
+
+function parseJsonObject(value) {
+  const cleaned = cleanOptional(value);
+  if (!cleaned) {
+    return {};
+  }
+  const parsed = JSON.parse(cleaned);
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('--metadata 必须是 JSON 对象。');
+  }
+  return parsed;
+}
+
+function optionalField(name, value) {
+  const cleaned = cleanOptional(value);
+  return cleaned === undefined ? {} : { [name]: cleaned };
+}
+
+function optionalBooleanField(name, value) {
+  const parsed = parseBoolean(value);
+  return parsed === undefined ? {} : { [name]: parsed };
+}
+
+function addNumber(target, name, value) {
+  const cleaned = cleanOptional(value);
+  if (cleaned !== undefined) {
+    const number = Number(cleaned);
+    target[name] = Number.isFinite(number) ? number : cleaned;
+  }
+}
+
+function parseBoolean(value) {
+  const cleaned = cleanOptional(value);
+  if (cleaned === undefined) {
+    return undefined;
+  }
+  if (typeof cleaned === 'boolean') {
+    return cleaned;
+  }
+  return ['1', 'true', 'yes', 'on'].includes(String(cleaned).toLowerCase());
+}
+
+function cleanOptional(value) {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+  }
+  return value;
+}
+
+function redactBody(body) {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    return body;
+  }
+  const redacted = { ...body };
+  if ('audio' in redacted) {
+    redacted.audio = '<data URI omitted>';
+  }
+  return redacted;
+}
+
+function parseMaybeJson(text) {
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function maskToken(token) {
+  if (!token) {
+    return '';
+  }
+  if (token.length <= 10) {
+    return '***';
+  }
+  return `${token.slice(0, 6)}...${token.slice(-4)}`;
+}