n8n-nodes-vidflow 0.1.9 → 0.1.11

package/README.md

@@ -44,9 +44,13 @@ npm run release
 
 ## 节点运行说明
 
-- `Douyin -> Download Video` 支持直接粘贴抖音分享文案，节点会优先从整段文本里提取抖音链接再下载视频。
-- `Douyin -> Download Video` 默认会优先尝试分块并发下载；当源站支持 `Range` 时可断点续传，不支持时会自动降级为单连接流式下载。
-- `Douyin -> Download Video` 新增 `Chunk Size (MB)` 和 `Worker Count` 两个调优参数，默认分别为 `5` 和 `8`，运行时会限制在 `1-64 MB` 与 `1-16` 的安全范围内。
+- `Douyin -> Extract Link` 可从抖音分享文案中提取一套明确字段：`pageUrl`、`resolvedPageUrl`、`playUrl`、`downloadUrl`，再附带 `videoId`、作者、标题、封面、媒体类型和文件大小等信息。
+- `Douyin -> Download Media` 现在用于下载媒体文件，输入参数为 `sourceUrl`，建议传 `resolvedPageUrl` 页面链接，或在已拿到真实直链时直接传 `downloadUrl`。
+- `Douyin -> Download Media` 新增 `Media Type` 参数，可直接下载视频，或先下载视频再通过 `ffmpeg` 提取音频。
+- 当 `Media Type` 为 `Audio` 时，可额外配置 `Audio Format` 和 `FFmpeg Path`。
+- `Douyin -> Download Media` 默认会优先尝试分块并发下载；当源站支持 `Range` 时可断点续传，不支持时会自动降级为单连接流式下载。
+- `Douyin -> Download Media` 保留 `Chunk Size (MB)` 和 `Worker Count` 两个调优参数，默认分别为 `5` 和 `8`，运行时会限制在 `1-64 MB` 与 `1-16` 的安全范围内。
+- 推荐工作流可以直接写成：`Extract Link` 输出 `resolvedPageUrl` 或 `downloadUrl`，再赋给 `Download Media` 的 `sourceUrl`。
 - `Audio -> Extract From Video` 依赖本机 `ffmpeg`，默认路径是 `/usr/bin/ffmpeg`。
 - `Transcription -> Transcribe` 会调用 BCut 转录接口，适合接在音频提取之后使用。
 

package/dist/nodes/Vidflow/Vidflow.node.js

@@ -66,12 +66,17 @@ const transcriptionDisplayOptions = {
 };
 const douyinDownloadDisplayOptions = {
     resource: ['douyin'],
-    operation: ['downloadVideo'],
+    operation: ['downloadMedia'],
 };
 const douyinExtractLinkDisplayOptions = {
     resource: ['douyin'],
     operation: ['extractLink'],
 };
+const douyinAudioDownloadDisplayOptions = {
+    resource: ['douyin'],
+    operation: ['downloadMedia'],
+    mediaType: ['audio'],
+};
 const transcriptionDescription = [
     {
         displayName: 'Operation',
@@ -270,13 +275,13 @@ const douyinDescription = [
                 description: 'Extract the Douyin link from a share message and resolve short links',
             },
             {
-                name: 'Download Video',
-                value: 'downloadVideo',
-                action: 'Download a video',
-                description: 'Download a Douyin video from a share link',
+                name: 'Download Media',
+                value: 'downloadMedia',
+                action: 'Download media',
+                description: 'Download audio or video from a Douyin page link or resolved download link',
             },
         ],
-        default: 'downloadVideo',
+        default: 'downloadMedia',
     },
     {
         displayName: 'Share Text Or Link',
@@ -293,15 +298,35 @@ const douyinDescription = [
         description: 'A Douyin share message, short link, or direct video link to extract from',
     },
     {
-        displayName: 'Video Link',
-        name: 'videoUrl',
+        displayName: 'Source URL',
+        name: 'sourceUrl',
         type: 'string',
         required: true,
         default: '',
         displayOptions: {
             show: douyinDownloadDisplayOptions,
         },
-        description: 'A Douyin video page link from the Extract Link operation, such as the resolvedUrl value',
+        description: 'A Douyin page link or direct media link from the Extract Link operation. Prefer resolvedPageUrl for page links and downloadUrl for direct downloads.',
+    },
+    {
+        displayName: 'Media Type',
+        name: 'mediaType',
+        type: 'options',
+        default: 'video',
+        displayOptions: {
+            show: douyinDownloadDisplayOptions,
+        },
+        options: [
+            {
+                name: 'Video',
+                value: 'video',
+            },
+            {
+                name: 'Audio',
+                value: 'audio',
+            },
+        ],
+        description: 'Whether to download the original video file or extract audio after download',
     },
     {
         displayName: 'Output Binary Property',
@@ -312,7 +337,7 @@ const douyinDescription = [
         displayOptions: {
             show: douyinDownloadDisplayOptions,
         },
-        description: 'Name of the output binary property that will contain the MP4 file',
+        description: 'Name of the output binary property that will contain the downloaded media file',
     },
     {
         displayName: 'File Name',
@@ -324,6 +349,44 @@ const douyinDescription = [
         },
         description: 'Optional output file name override',
     },
+    {
+        displayName: 'Audio Format',
+        name: 'audioFormat',
+        type: 'options',
+        default: 'mp3',
+        displayOptions: {
+            show: douyinAudioDownloadDisplayOptions,
+        },
+        options: [
+            {
+                name: 'AAC',
+                value: 'aac',
+            },
+            {
+                name: 'MP3',
+                value: 'mp3',
+            },
+            {
+                name: 'OGG',
+                value: 'ogg',
+            },
+            {
+                name: 'WAV',
+                value: 'wav',
+            },
+        ],
+        description: 'Audio format used when Media Type is set to Audio',
+    },
+    {
+        displayName: 'FFmpeg Path',
+        name: 'audioFfmpegPath',
+        type: 'string',
+        default: DEFAULT_FFMPEG_PATH,
+        displayOptions: {
+            show: douyinAudioDownloadDisplayOptions,
+        },
+        description: 'FFmpeg executable path used when extracting audio from the downloaded video',
+    },
     {
         displayName: 'Chunk Size (MB)',
         name: 'chunkSizeMb',
@@ -522,6 +585,18 @@ function getDouyinContentLength(headers) {
     const rawValue = Array.isArray(contentLength) ? contentLength[0] : contentLength;
     return Number(rawValue);
 }
+function getDouyinContentRange(headers) {
+    const contentRange = headers['content-range'];
+    return Array.isArray(contentRange) ? contentRange[0] : contentRange;
+}
+function getDouyinTotalBytesFromContentRange(contentRange) {
+    var _a;
+    if (!contentRange) {
+        return 0;
+    }
+    const totalBytes = (_a = contentRange.match(/\/(\d+)$/)) === null || _a === void 0 ? void 0 : _a[1];
+    return totalBytes ? Number(totalBytes) : 0;
+}
 function supportsDouyinRange(headers) {
     var _a;
     const acceptRanges = headers['accept-ranges'];
@@ -532,7 +607,7 @@ function emitDouyinDownloadProgress(context, itemIndex, percent, downloadedBytes
     context.sendMessageToUI({
         itemIndex,
         resource: 'douyin',
-        operation: 'downloadVideo',
+        operation: 'downloadMedia',
         stage,
         progressPercent: percent,
         downloadedBytes,
@@ -571,7 +646,7 @@ function sanitizeFileName(fileName) {
     }
     return sanitized.slice(0, 200);
 }
-function parseRouterDataVideoInfo(html, originalUrl, resolvedUrl) {
+function parseRouterDataVideoInfo(html, pageUrl, resolvedPageUrl) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
     const routerDataMatch = html.match(/window\._ROUTER_DATA\s*=\s*(.*?)<\/script>/s);
     if (!(routerDataMatch === null || routerDataMatch === void 0 ? void 0 : routerDataMatch[1])) {
@@ -593,17 +668,17 @@ function parseRouterDataVideoInfo(html, originalUrl, resolvedUrl) {
         throw new n8n_workflow_1.ApplicationError('Douyin video URL was missing from the page data.');
     }
     return {
-        awemeId: (_j = item.aweme_id) !== null && _j !== void 0 ? _j : '',
+        videoId: (_j = item.aweme_id) !== null && _j !== void 0 ? _j : '',
         title: (_k = item.desc) !== null && _k !== void 0 ? _k : '',
         author: (_m = (_l = item.author) === null || _l === void 0 ? void 0 : _l.nickname) !== null && _m !== void 0 ? _m : '',
         cover: (_q = (_p = (_o = item.video) === null || _o === void 0 ? void 0 : _o.cover) === null || _p === void 0 ? void 0 : _p.url_list) === null || _q === void 0 ? void 0 : _q[0],
-        videoUrl,
+        playUrl: videoUrl,
         createTime: item.create_time,
-        originalUrl,
-        resolvedUrl,
+        pageUrl,
+        resolvedPageUrl,
     };
 }
-function parseRenderDataVideoInfo(html, originalUrl, resolvedUrl) {
+function parseRenderDataVideoInfo(html, pageUrl, resolvedPageUrl) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     const renderDataMatch = html.match(/<script id="RENDER_DATA" type="application\/json">([^<]+)<\/script>/);
     if (!(renderDataMatch === null || renderDataMatch === void 0 ? void 0 : renderDataMatch[1])) {
@@ -621,13 +696,13 @@ function parseRenderDataVideoInfo(html, originalUrl, resolvedUrl) {
         throw new n8n_workflow_1.ApplicationError('Douyin video URL was missing from RENDER_DATA.');
     }
     return {
-        awemeId: String((_j = pageRoot.awemeId) !== null && _j !== void 0 ? _j : ''),
+        videoId: String((_j = pageRoot.awemeId) !== null && _j !== void 0 ? _j : ''),
         title: String((_k = pageRoot.desc) !== null && _k !== void 0 ? _k : ''),
         author: String((_m = (_l = pageRoot.author) === null || _l === void 0 ? void 0 : _l.nickname) !== null && _m !== void 0 ? _m : ''),
         cover: ((_p = (_o = video === null || video === void 0 ? void 0 : video.cover) === null || _o === void 0 ? void 0 : _o.urlList) !== null && _p !== void 0 ? _p : [])[0],
-        videoUrl: playUrl,
-        originalUrl,
-        resolvedUrl,
+        playUrl,
+        pageUrl,
+        resolvedPageUrl,
     };
 }
 async function bcutRequest(context, requestOptions) {
@@ -660,51 +735,93 @@ async function douyinRequestText(context, url, allowRedirect = true) {
     };
 }
 async function resolveDouyinUrl(context, shareText) {
-    const originalUrl = sanitizeSharedLink(extractFirstUrl(shareText.trim()));
-    if (!originalUrl.includes('v.douyin.com')) {
+    const pageUrl = sanitizeSharedLink(extractFirstUrl(shareText.trim()));
+    if (!pageUrl.includes('v.douyin.com')) {
         return {
-            originalUrl,
-            resolvedUrl: originalUrl,
+            pageUrl,
+            resolvedPageUrl: pageUrl,
         };
     }
-    const response = await douyinRequestText(context, originalUrl, false);
+    const response = await douyinRequestText(context, pageUrl, false);
     const redirectLocation = getHeaderValue(response.headers, 'location');
     return {
-        originalUrl,
-        resolvedUrl: redirectLocation !== null && redirectLocation !== void 0 ? redirectLocation : originalUrl,
+        pageUrl,
+        resolvedPageUrl: redirectLocation !== null && redirectLocation !== void 0 ? redirectLocation : pageUrl,
     };
 }
-function getDirectDouyinVideoUrl(input) {
+function getDirectDouyinSourceUrl(input) {
     const directUrl = sanitizeSharedLink(extractFirstUrl(input.trim()));
     if (directUrl.includes('v.douyin.com')) {
-        throw new n8n_workflow_1.ApplicationError('Video Link does not accept Douyin short links. Use the Extract Link operation first and pass its resolvedUrl value to Download Video.');
+        throw new n8n_workflow_1.ApplicationError('Source URL does not accept Douyin short links. Use the Extract Link operation first and pass its resolvedPageUrl value to Download Media.');
     }
     return directUrl;
 }
-async function getDouyinVideoInfo(context, videoUrlInput) {
-    const originalUrl = getDirectDouyinVideoUrl(videoUrlInput);
-    const resolvedUrl = originalUrl;
-    const videoId = extractDouyinVideoId(resolvedUrl);
+function isDouyinPageUrl(urlString) {
+    try {
+        const parsedUrl = new URL(urlString);
+        const host = parsedUrl.hostname.toLowerCase();
+        if (!['www.douyin.com', 'douyin.com', 'iesdouyin.com'].includes(host)) {
+            return false;
+        }
+        return /\/video\//.test(parsedUrl.pathname) || parsedUrl.searchParams.has('modal_id');
+    }
+    catch {
+        return false;
+    }
+}
+async function getDouyinVideoInfo(context, sourceUrlInput) {
+    const pageUrl = getDirectDouyinSourceUrl(sourceUrlInput);
+    const resolvedPageUrl = pageUrl;
+    const videoId = extractDouyinVideoId(resolvedPageUrl);
     if (videoId === '') {
-        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'A Douyin video ID could not be extracted from Video Link.');
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'A Douyin video ID could not be extracted from Source URL.');
     }
     try {
         const iesPageResponse = await douyinRequestText(context, `https://www.iesdouyin.com/share/video/${videoId}`);
-        return parseRouterDataVideoInfo(iesPageResponse.body, originalUrl, resolvedUrl);
+        return parseRouterDataVideoInfo(iesPageResponse.body, pageUrl, resolvedPageUrl);
     }
     catch (iesError) {
         const webPageResponse = await douyinRequestText(context, `https://www.douyin.com/video/${videoId}`);
         try {
-            return parseRenderDataVideoInfo(webPageResponse.body, originalUrl, resolvedUrl);
+            return parseRenderDataVideoInfo(webPageResponse.body, pageUrl, resolvedPageUrl);
         }
         catch {
             throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Douyin video details could not be resolved: ${asErrorMessage(iesError)}`);
         }
     }
 }
+async function resolveDouyinMediaSource(context, input) {
+    const normalizedInput = sanitizeSharedLink(extractFirstUrl(input.trim()));
+    if (normalizedInput.includes('v.douyin.com')) {
+        throw new n8n_workflow_1.ApplicationError('Download does not accept Douyin short links. Use the Extract Link operation first and pass its resolvedPageUrl or downloadUrl value.');
+    }
+    if (isDouyinPageUrl(normalizedInput)) {
+        const videoInfo = await getDouyinVideoInfo(context, normalizedInput);
+        const metadata = await getDouyinDownloadMetadata(videoInfo.playUrl);
+        return {
+            downloadId: sanitizeFileName(videoInfo.videoId || 'douyin_video'),
+            metadata,
+            requestUrl: videoInfo.playUrl,
+            sourceType: 'page',
+            videoInfo,
+        };
+    }
+    const metadata = await getDouyinDownloadMetadata(normalizedInput);
+    const derivedVideoId = extractDouyinVideoId(normalizedInput) || extractDouyinVideoId(metadata.downloadUrl);
+    return {
+        downloadId: sanitizeFileName(derivedVideoId || 'douyin_media'),
+        metadata,
+        requestUrl: normalizedInput,
+        sourceType: 'media',
+    };
+}
 function getRequestModule(urlString) {
     return urlString.startsWith('https:') ? https : http;
 }
+function shouldFallbackToStreamDownload(error) {
+    const message = asErrorMessage(error);
+    return message.includes('Range request was not honored') || message.includes('Content-Range');
+}
 async function requestDouyinResponse(url, method, headers, redirectCount = 0) {
     if (redirectCount > DOUYIN_DOWNLOAD_MAX_REDIRECTS) {
         throw new n8n_workflow_1.ApplicationError('Douyin download exceeded the redirect limit.');
@@ -736,15 +853,23 @@ async function requestDouyinResponse(url, method, headers, redirectCount = 0) {
 async function getDouyinDownloadMetadata(videoUrl) {
     const headers = {
         Referer: 'https://www.douyin.com/',
+        Range: 'bytes=0-0',
         'User-Agent': DOUYIN_MOBILE_USER_AGENT,
     };
-    const { response, resolvedUrl } = await requestDouyinResponse(videoUrl, 'HEAD', headers);
-    response.resume();
+    const { response, resolvedUrl } = await requestDouyinResponse(videoUrl, 'GET', headers);
+    const contentRange = getDouyinContentRange(response.headers);
+    const mimeType = getDouyinMimeTypeFromHeaders(response.headers);
+    const totalBytes = getDouyinTotalBytesFromContentRange(contentRange) || getDouyinContentLength(response.headers);
+    const acceptRanges = supportsDouyinRange(response.headers) || response.statusCode === 206 || contentRange !== undefined;
+    response.destroy();
+    if (mimeType.startsWith('text/html')) {
+        throw new n8n_workflow_1.ApplicationError('Douyin media probe returned HTML instead of a downloadable media file. The extracted link is not a direct download URL.');
+    }
     return {
-        acceptRanges: supportsDouyinRange(response.headers),
-        mimeType: getDouyinMimeTypeFromHeaders(response.headers),
-        resolvedUrl,
-        totalBytes: getDouyinContentLength(response.headers),
+        acceptRanges,
+        downloadUrl: resolvedUrl,
+        mimeType,
+        totalBytes,
     };
 }
 async function loadDouyinDownloadState(stateFilePath) {
@@ -784,6 +909,11 @@ async function downloadDouyinChunk(resolvedUrl, headers, start, end) {
         ...headers,
         Range: `bytes=${String(start)}-${String(end)}`,
     });
+    const contentRange = getDouyinContentRange(response.headers);
+    if (response.statusCode !== 206 || !(contentRange === null || contentRange === void 0 ? void 0 : contentRange.startsWith(`bytes ${String(start)}-${String(end)}/`))) {
+        response.resume();
+        throw new n8n_workflow_1.ApplicationError('Range request was not honored by the download server. Falling back to a single-stream download is required.');
+    }
     return await new Promise((resolve, reject) => {
         const chunks = [];
         response.on('data', (chunk) => {
@@ -823,9 +953,9 @@ async function streamDouyinDownloadToFile(context, itemIndex, resolvedUrl, outpu
     return {
         buffer,
         downloadMode: 'stream',
+        downloadUrl: resolvedUrl,
         mimeType: getDouyinMimeTypeFromHeaders(response.headers),
         progressPercent: 100,
-        resolvedDownloadUrl: resolvedUrl,
         totalBytes: totalBytes > 0 ? totalBytes : buffer.length,
     };
 }
@@ -909,13 +1039,13 @@ async function chunkedDouyinDownloadToFile(context, itemIndex, resolvedUrl, outp
     return {
         buffer,
         downloadMode: 'chunked',
+        downloadUrl: resolvedUrl,
         mimeType: metadata.mimeType,
         progressPercent: 100,
-        resolvedDownloadUrl: resolvedUrl,
         totalBytes: metadata.totalBytes,
     };
 }
-async function streamDownloadWithProgress(context, itemIndex, videoUrl, downloadId, chunkSize, workerCount) {
+async function streamDownloadWithProgress(context, itemIndex, videoUrl, downloadId, chunkSize, workerCount, metadata) {
     const requestHeaders = {
         Referer: 'https://www.douyin.com/',
         'User-Agent': DOUYIN_MOBILE_USER_AGENT,
@@ -923,16 +1053,26 @@ async function streamDownloadWithProgress(context, itemIndex, videoUrl, download
     const downloadDirectory = getDouyinDownloadDirectory(downloadId);
     const outputFile = (0, node_path_1.join)(downloadDirectory, 'video.mp4');
     await node_fs_1.promises.mkdir(downloadDirectory, { recursive: true });
-    const metadata = await getDouyinDownloadMetadata(videoUrl);
+    const downloadMetadata = metadata !== null && metadata !== void 0 ? metadata : (await getDouyinDownloadMetadata(videoUrl));
     try {
-        if (metadata.acceptRanges && metadata.totalBytes > 0) {
-            return await chunkedDouyinDownloadToFile(context, itemIndex, metadata.resolvedUrl, outputFile, requestHeaders, metadata, chunkSize, workerCount);
+        if (downloadMetadata.acceptRanges && downloadMetadata.totalBytes > 0) {
+            const chunkedResult = await chunkedDouyinDownloadToFile(context, itemIndex, downloadMetadata.downloadUrl, outputFile, requestHeaders, downloadMetadata, chunkSize, workerCount).catch(async (error) => {
+                if (!shouldFallbackToStreamDownload(error)) {
+                    return await Promise.reject(error);
+                }
+                emitDouyinDownloadProgress(context, itemIndex, 0, 0, downloadMetadata.totalBytes, 'range_fallback', { reason: asErrorMessage(error) });
+                await node_fs_1.promises.rm(downloadDirectory, { force: true, recursive: true });
+                await node_fs_1.promises.mkdir(downloadDirectory, { recursive: true });
+                return undefined;
+            });
+            if (chunkedResult) {
+                return chunkedResult;
+            }
         }
-        return await streamDouyinDownloadToFile(context, itemIndex, metadata.resolvedUrl, outputFile, requestHeaders, metadata.totalBytes);
+        return await streamDouyinDownloadToFile(context, itemIndex, downloadMetadata.downloadUrl, outputFile, requestHeaders, downloadMetadata.totalBytes);
     }
     finally {
-        await node_fs_1.promises.rm(outputFile, { force: true });
-        await node_fs_1.promises.rm(downloadDirectory, { force: true, recursive: false }).catch(() => undefined);
+        await node_fs_1.promises.rm(downloadDirectory, { force: true, recursive: true }).catch(() => undefined);
     }
 }
 async function extractAudioFromVideo(context, buffer, inputFileName, outputFileName, format, ffmpegPath, mimeType) {
@@ -1196,7 +1336,7 @@ class Vidflow {
         };
     }
     async execute() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const items = this.getInputData();
         const returnData = [];
         for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
@@ -1276,15 +1416,23 @@ class Vidflow {
                 }
                 if (resource === 'douyin' && operation === 'extractLink') {
                     const shareText = this.getNodeParameter('shareText', itemIndex);
-                    const { originalUrl, resolvedUrl } = await resolveDouyinUrl(this, shareText);
-                    const videoId = extractDouyinVideoId(resolvedUrl);
+                    const { pageUrl, resolvedPageUrl } = await resolveDouyinUrl(this, shareText);
+                    const mediaSource = await resolveDouyinMediaSource(this, resolvedPageUrl);
+                    const videoInfo = mediaSource.videoInfo;
                     returnData.push({
                         json: {
                             shareText,
-                            extractedUrl: originalUrl,
-                            resolvedUrl,
-                            videoId,
-                            isShortLink: originalUrl !== resolvedUrl,
+                            pageUrl,
+                            resolvedPageUrl,
+                            videoId: (_d = videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.videoId) !== null && _d !== void 0 ? _d : extractDouyinVideoId(resolvedPageUrl),
+                            isShortLink: pageUrl !== resolvedPageUrl,
+                            title: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.title,
+                            author: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.author,
+                            cover: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.cover,
+                            playUrl: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.playUrl,
+                            downloadUrl: mediaSource.metadata.downloadUrl,
+                            mimeType: mediaSource.metadata.mimeType,
+                            totalBytes: mediaSource.metadata.totalBytes,
                         },
                         pairedItem: {
                             item: itemIndex,
@@ -1292,42 +1440,56 @@ class Vidflow {
                     });
                     continue;
                 }
-                if (resource === 'douyin' && operation === 'downloadVideo') {
-                    const videoUrl = this.getNodeParameter('videoUrl', itemIndex);
+                if (resource === 'douyin' && operation === 'downloadMedia') {
+                    const sourceUrl = this.getNodeParameter('sourceUrl', itemIndex);
+                    const mediaType = this.getNodeParameter('mediaType', itemIndex, 'video');
                     const outputBinaryPropertyName = this.getNodeParameter('outputBinaryPropertyName', itemIndex);
                     const outputFileName = this.getNodeParameter('outputFileName', itemIndex, '');
+                    const audioFormat = this.getNodeParameter('audioFormat', itemIndex, 'mp3');
+                    const audioFfmpegPath = this.getNodeParameter('audioFfmpegPath', itemIndex, '');
                     const chunkSizeMb = this.getNodeParameter('chunkSizeMb', itemIndex);
                     const workerCount = this.getNodeParameter('workerCount', itemIndex);
-                    const videoInfo = await getDouyinVideoInfo(this, videoUrl);
-                    const videoId = sanitizeFileName(videoInfo.awemeId || 'douyin_video');
+                    const mediaSource = await resolveDouyinMediaSource(this, sourceUrl);
+                    const videoInfo = mediaSource.videoInfo;
+                    const videoId = mediaSource.downloadId;
                     const normalizedChunkSizeMb = Math.min(DOUYIN_DOWNLOAD_MAX_CHUNK_SIZE_MB, Math.max(1, Math.floor(chunkSizeMb || DOUYIN_DOWNLOAD_CHUNK_SIZE / (1024 * 1024))));
                     const chunkSize = normalizedChunkSizeMb * 1024 * 1024;
                     const normalizedWorkerCount = Math.min(DOUYIN_DOWNLOAD_MAX_WORKERS, Math.max(1, Math.floor(workerCount || DOUYIN_DOWNLOAD_WORKERS)));
-                    const { buffer, downloadMode, mimeType, progressPercent, resolvedDownloadUrl, totalBytes, } = await streamDownloadWithProgress(this, itemIndex, videoInfo.videoUrl, videoId, chunkSize, normalizedWorkerCount);
-                    const finalFileName = outputFileName.trim() !== ''
+                    const { buffer, downloadMode, downloadUrl, mimeType, progressPercent, totalBytes, } = await streamDownloadWithProgress(this, itemIndex, mediaSource.requestUrl, videoId, chunkSize, normalizedWorkerCount, mediaSource.metadata);
+                    let finalBuffer = buffer;
+                    let finalFileName = outputFileName.trim() !== ''
                         ? sanitizeFileName(outputFileName.trim())
                         : `${videoId}.mp4`;
-                    const binaryData = await this.helpers.prepareBinaryData(buffer, finalFileName, mimeType);
+                    let finalMimeType = mimeType;
+                    if (mediaType === 'audio') {
+                        const extractedAudio = await extractAudioFromVideo(this, buffer, `${videoId}.${inferVideoExtension(mimeType)}`, outputFileName, audioFormat, audioFfmpegPath, mimeType);
+                        finalBuffer = extractedAudio.buffer;
+                        finalFileName = extractedAudio.fileName;
+                        finalMimeType = extractedAudio.mimeType;
+                    }
+                    const binaryData = await this.helpers.prepareBinaryData(finalBuffer, finalFileName, finalMimeType);
                     returnData.push({
                         json: {
                             videoId,
-                            awemeId: videoInfo.awemeId,
-                            title: videoInfo.title,
-                            author: videoInfo.author,
-                            cover: videoInfo.cover,
-                            videoUrl: videoInfo.videoUrl,
-                            createTime: videoInfo.createTime,
-                            originalUrl: videoInfo.originalUrl,
-                            resolvedUrl: videoInfo.resolvedUrl,
-                            resolvedDownloadUrl,
+                            title: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.title,
+                            author: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.author,
+                            cover: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.cover,
+                            playUrl: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.playUrl,
+                            createTime: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.createTime,
+                            pageUrl: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.pageUrl,
+                            resolvedPageUrl: videoInfo === null || videoInfo === void 0 ? void 0 : videoInfo.resolvedPageUrl,
+                            downloadUrl,
+                            sourceType: mediaSource.sourceType,
+                            mediaType,
                             downloadMode,
                             fileName: finalFileName,
-                            mimeType,
-                            size: buffer.length,
+                            mimeType: finalMimeType,
+                            size: finalBuffer.length,
                             totalBytes,
                             downloadProgressPercent: progressPercent,
                             chunkSizeMb: normalizedChunkSizeMb,
                             workerCount: normalizedWorkerCount,
+                            audioFormat: mediaType === 'audio' ? audioFormat : undefined,
                         },
                         binary: {
                             [outputBinaryPropertyName]: binaryData,