n8n-nodes-vidflow 0.1.2 → 0.1.6

package/README.md

@@ -22,6 +22,16 @@ npm run release
 git status --short
 git add .
 git commit -m "chore: prepare release"
+
+
+本地发布：
+
+npm version patch
+npm run release:check
+
+npm publish --access public
+
+
 ```
 
 然后再执行：
@@ -31,3 +41,18 @@ npm version patch
 npm run release:check
 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` 的安全范围内。
+- `Audio -> Extract From Video` 依赖本机 `ffmpeg`，默认路径是 `/usr/bin/ffmpeg`。
+- `Transcription -> Transcribe` 会调用 BCut 转录接口，适合接在音频提取之后使用。
+
+## 前端进度展示
+
+- 抖音下载和 BCut 转录都会通过 `sendMessageToUI` 向 n8n 前端发送进度消息。
+- 进度消息统一包含 `resource`、`operation`、`stage`、`progressPercent`，下载场景还会附带 `downloadedBytes` 和 `totalBytes`。
+- 抖音下载会根据能力检测展示 `chunked_start`、`resuming`、`downloading`、`stream_start`、`completed` 等阶段，并在输出 JSON 里返回 `downloadMode`、`chunkSizeMb`、`workerCount`。
+- BCut 转录展示的是阶段性进度，不是官方返回的真实百分比；下载进度则基于实际已下载字节数计算。

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

@@ -1,8 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vidflow = void 0;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
+const http = __importStar(require("node:http"));
+const https = __importStar(require("node:https"));
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
@@ -12,7 +47,14 @@ const BCUT_MODEL_ID = '8';
 const BCUT_QUERY_MODEL_ID = 7;
 const BCUT_POLL_STATE_FAILED = 3;
 const BCUT_POLL_STATE_COMPLETED = 4;
+const DEFAULT_FFMPEG_PATH = '/usr/bin/ffmpeg';
 const DOUYIN_MOBILE_USER_AGENT = 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) EdgiOS/121.0.2277.107 Version/17.0 Mobile/15E148 Safari/604.1';
+const DOUYIN_DOWNLOAD_CHUNK_SIZE = 5 * 1024 * 1024;
+const DOUYIN_DOWNLOAD_WORKERS = 8;
+const DOUYIN_DOWNLOAD_MAX_CHUNK_SIZE_MB = 64;
+const DOUYIN_DOWNLOAD_MAX_WORKERS = 16;
+const DOUYIN_DOWNLOAD_MAX_REDIRECTS = 5;
+const DOUYIN_DOWNLOAD_MAX_RETRIES = 3;
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const audioExtractDisplayOptions = {
     resource: ['audio'],
@@ -198,11 +240,11 @@ const audioDescription = [
         displayName: 'FFmpeg Path',
         name: 'ffmpegPath',
         type: 'string',
-        default: '',
+        default: DEFAULT_FFMPEG_PATH,
         displayOptions: {
             show: audioExtractDisplayOptions,
         },
-        description: 'Optional ffmpeg executable path. When empty, ffmpeg is resolved from PATH.',
+        description: 'FFmpeg executable path used for audio extraction',
     },
 ];
 const douyinDescription = [
@@ -261,6 +303,36 @@ const douyinDescription = [
         },
         description: 'Optional output file name override',
     },
+    {
+        displayName: 'Chunk Size (MB)',
+        name: 'chunkSizeMb',
+        type: 'number',
+        typeOptions: {
+            minValue: 1,
+            maxValue: DOUYIN_DOWNLOAD_MAX_CHUNK_SIZE_MB,
+            numberPrecision: 0,
+        },
+        default: 5,
+        displayOptions: {
+            show: douyinDownloadDisplayOptions,
+        },
+        description: 'Chunk size used for resumable downloads when the server supports range requests. Keep it between 1 and 64 MB.',
+    },
+    {
+        displayName: 'Worker Count',
+        name: 'workerCount',
+        type: 'number',
+        typeOptions: {
+            minValue: 1,
+            maxValue: DOUYIN_DOWNLOAD_MAX_WORKERS,
+            numberPrecision: 0,
+        },
+        default: 8,
+        displayOptions: {
+            show: douyinDownloadDisplayOptions,
+        },
+        description: 'Number of concurrent chunk workers used for resumable downloads. Keep it between 1 and 16.',
+    },
 ];
 function getBcutHeaders() {
     return {
@@ -394,11 +466,68 @@ function getHeaderValue(headers, name) {
     return headerValue;
 }
 function extractFirstUrl(input) {
-    const match = input.match(/https?:\/\/[^\s]+/i);
+    const douyinMatch = input.match(/https?:\/\/(?:v\.douyin\.com|www\.douyin\.com|iesdouyin\.com)\/[^\s]+/i);
+    const match = douyinMatch !== null && douyinMatch !== void 0 ? douyinMatch : input.match(/https?:\/\/[^\s]+/i);
     if (!match) {
         throw new n8n_workflow_1.ApplicationError('No URL was found in Share Text Or Link.');
     }
-    return match[0].replace(/[),.;!?]+$/, '');
+    return sanitizeSharedLink(match[0]);
+}
+function sanitizeSharedLink(input) {
+    return input
+        .trim()
+        .replace(/[),.;!?]+$/g, '')
+        .replace(/[，。；：！？]+$/g, '');
+}
+function getDouyinDownloadDirectory(downloadId) {
+    return (0, node_path_1.join)((0, node_os_1.tmpdir)(), 'vidflow-douyin', sanitizeFileName(downloadId));
+}
+function getDouyinChunkCount(totalSize, chunkSize) {
+    return Math.ceil(totalSize / chunkSize);
+}
+function getDouyinPartFilePath(outputFile, index) {
+    return `${outputFile}.part${String(index)}`;
+}
+function getDouyinStateFilePath(outputFile) {
+    return `${outputFile}.dl.json`;
+}
+function getDouyinMimeTypeFromHeaders(headers) {
+    const contentType = headers['content-type'];
+    const rawValue = Array.isArray(contentType) ? contentType[0] : contentType;
+    return (rawValue === null || rawValue === void 0 ? void 0 : rawValue.split(';')[0]) || 'video/mp4';
+}
+function getDouyinContentLength(headers) {
+    const contentLength = headers['content-length'];
+    const rawValue = Array.isArray(contentLength) ? contentLength[0] : contentLength;
+    return Number(rawValue);
+}
+function supportsDouyinRange(headers) {
+    var _a;
+    const acceptRanges = headers['accept-ranges'];
+    const rawValue = Array.isArray(acceptRanges) ? acceptRanges[0] : acceptRanges;
+    return (_a = rawValue === null || rawValue === void 0 ? void 0 : rawValue.toLowerCase().includes('bytes')) !== null && _a !== void 0 ? _a : false;
+}
+function emitDouyinDownloadProgress(context, itemIndex, percent, downloadedBytes, totalBytes, stage = 'downloading', extra) {
+    context.sendMessageToUI({
+        itemIndex,
+        resource: 'douyin',
+        operation: 'downloadVideo',
+        stage,
+        progressPercent: percent,
+        downloadedBytes,
+        totalBytes,
+        ...extra,
+    });
+}
+function emitBcutTranscriptionProgress(context, itemIndex, percent, stage, extra) {
+    context.sendMessageToUI({
+        itemIndex,
+        operation: 'transcribe',
+        progressPercent: percent,
+        resource: 'transcription',
+        stage,
+        ...extra,
+    });
 }
 function extractDouyinVideoId(urlString) {
     var _a;
@@ -510,7 +639,7 @@ async function douyinRequestText(context, url, allowRedirect = true) {
     };
 }
 async function resolveDouyinUrl(context, shareText) {
-    const originalUrl = extractFirstUrl(shareText.trim());
+    const originalUrl = sanitizeSharedLink(extractFirstUrl(shareText.trim()));
     if (!originalUrl.includes('v.douyin.com')) {
         return {
             originalUrl,
@@ -544,30 +673,242 @@ async function getDouyinVideoInfo(context, shareText) {
         }
     }
 }
-async function downloadDouyinVideoBuffer(context, videoUrl) {
-    var _a;
-    const response = (await context.helpers.httpRequest({
-        url: videoUrl,
-        method: 'GET',
-        headers: {
-            Referer: 'https://www.douyin.com/',
-            'User-Agent': DOUYIN_MOBILE_USER_AGENT,
-        },
-        json: false,
-        encoding: 'arraybuffer',
-        returnFullResponse: true,
-    }));
-    const buffer = response.body;
-    if (!buffer || !(buffer instanceof Buffer)) {
-        throw new n8n_workflow_1.ApplicationError('Douyin video download did not return binary content.');
+function getRequestModule(urlString) {
+    return urlString.startsWith('https:') ? https : http;
+}
+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.');
+    }
+    return await new Promise((resolve, reject) => {
+        const request = getRequestModule(url).request(url, { headers, method }, (response) => {
+            var _a;
+            const statusCode = (_a = response.statusCode) !== null && _a !== void 0 ? _a : 0;
+            const redirectLocation = response.headers.location;
+            if (statusCode >= 300 && statusCode < 400 && redirectLocation) {
+                response.resume();
+                const nextUrl = new URL(redirectLocation, url).toString();
+                void requestDouyinResponse(nextUrl, method, headers, redirectCount + 1)
+                    .then(resolve)
+                    .catch(reject);
+                return;
+            }
+            if (statusCode < 200 || statusCode >= 300) {
+                response.resume();
+                reject(new n8n_workflow_1.ApplicationError(`Douyin request failed with HTTP status ${String(statusCode)}.`));
+                return;
+            }
+            resolve({ response, resolvedUrl: url });
+        });
+        request.on('error', reject);
+        request.end();
+    });
+}
+async function getDouyinDownloadMetadata(videoUrl) {
+    const headers = {
+        Referer: 'https://www.douyin.com/',
+        'User-Agent': DOUYIN_MOBILE_USER_AGENT,
+    };
+    const { response, resolvedUrl } = await requestDouyinResponse(videoUrl, 'HEAD', headers);
+    response.resume();
+    return {
+        acceptRanges: supportsDouyinRange(response.headers),
+        mimeType: getDouyinMimeTypeFromHeaders(response.headers),
+        resolvedUrl,
+        totalBytes: getDouyinContentLength(response.headers),
+    };
+}
+async function loadDouyinDownloadState(stateFilePath) {
+    try {
+        const fileContents = await node_fs_1.promises.readFile(stateFilePath, 'utf8');
+        return JSON.parse(fileContents);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return undefined;
+        }
+        await node_fs_1.promises.rm(stateFilePath, { force: true });
+        return undefined;
+    }
+}
+async function saveDouyinDownloadState(stateFilePath, state) {
+    await node_fs_1.promises.writeFile(stateFilePath, JSON.stringify(state, null, 2), 'utf8');
+}
+async function mergeDouyinChunks(outputFile, chunkCount) {
+    const fileHandle = await node_fs_1.promises.open(outputFile, 'w');
+    try {
+        for (let index = 0; index < chunkCount; index++) {
+            const chunkBuffer = await node_fs_1.promises.readFile(getDouyinPartFilePath(outputFile, index));
+            await fileHandle.writeFile(chunkBuffer);
+        }
+    }
+    finally {
+        await fileHandle.close();
+    }
+}
+async function cleanupDouyinChunkArtifacts(outputFile, chunkCount) {
+    await Promise.allSettled(Array.from({ length: chunkCount }, (_, index) => node_fs_1.promises.rm(getDouyinPartFilePath(outputFile, index), { force: true })));
+    await node_fs_1.promises.rm(getDouyinStateFilePath(outputFile), { force: true });
+}
+async function downloadDouyinChunk(resolvedUrl, headers, start, end) {
+    const { response } = await requestDouyinResponse(resolvedUrl, 'GET', {
+        ...headers,
+        Range: `bytes=${String(start)}-${String(end)}`,
+    });
+    return await new Promise((resolve, reject) => {
+        const chunks = [];
+        response.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        response.on('end', () => {
+            resolve(Buffer.concat(chunks));
+        });
+        response.on('error', reject);
+    });
+}
+async function streamDouyinDownloadToFile(context, itemIndex, resolvedUrl, outputFile, headers, totalBytes) {
+    const { response } = await requestDouyinResponse(resolvedUrl, 'GET', headers);
+    const chunks = [];
+    let downloadedBytes = 0;
+    let lastProgressPercent = -1;
+    emitDouyinDownloadProgress(context, itemIndex, 0, 0, totalBytes || undefined, 'stream_start');
+    const buffer = await new Promise((resolve, reject) => {
+        response.on('data', (chunk) => {
+            chunks.push(chunk);
+            downloadedBytes += chunk.length;
+            if (totalBytes > 0) {
+                const progressPercent = Math.min(100, Math.floor((downloadedBytes / totalBytes) * 100));
+                if (progressPercent >= lastProgressPercent + 5 || progressPercent === 100) {
+                    lastProgressPercent = progressPercent;
+                    emitDouyinDownloadProgress(context, itemIndex, progressPercent, downloadedBytes, totalBytes, 'downloading');
+                }
+            }
+        });
+        response.on('end', () => {
+            resolve(Buffer.concat(chunks));
+        });
+        response.on('error', reject);
+    });
+    await node_fs_1.promises.writeFile(outputFile, buffer);
+    emitDouyinDownloadProgress(context, itemIndex, 100, buffer.length, totalBytes || buffer.length, 'completed');
+    return {
+        buffer,
+        downloadMode: 'stream',
+        mimeType: getDouyinMimeTypeFromHeaders(response.headers),
+        progressPercent: 100,
+        resolvedDownloadUrl: resolvedUrl,
+        totalBytes: totalBytes > 0 ? totalBytes : buffer.length,
+    };
+}
+async function chunkedDouyinDownloadToFile(context, itemIndex, resolvedUrl, outputFile, headers, metadata, chunkSize, workerCount) {
+    const stateFilePath = getDouyinStateFilePath(outputFile);
+    const chunkCount = getDouyinChunkCount(metadata.totalBytes, chunkSize);
+    const existingState = await loadDouyinDownloadState(stateFilePath);
+    const state = (existingState === null || existingState === void 0 ? void 0 : existingState.outputFile) === outputFile &&
+        existingState.chunkSize === chunkSize &&
+        existingState.totalSize === metadata.totalBytes
+        ? existingState
+        : {
+            chunkSize,
+            completedChunks: {},
+            outputFile,
+            totalSize: metadata.totalBytes,
+        };
+    let downloadedBytes = 0;
+    for (const [chunkIndex, completed] of Object.entries(state.completedChunks)) {
+        if (!completed) {
+            continue;
+        }
+        const index = Number(chunkIndex);
+        const start = index * state.chunkSize;
+        const end = Math.min(start + state.chunkSize, state.totalSize) - 1;
+        downloadedBytes += end - start + 1;
+    }
+    let lastProgressPercent = metadata.totalBytes > 0 ? Math.floor((downloadedBytes / metadata.totalBytes) * 100) : 0;
+    if (downloadedBytes > 0) {
+        emitDouyinDownloadProgress(context, itemIndex, lastProgressPercent, downloadedBytes, metadata.totalBytes, 'resuming', { completedChunks: Object.keys(state.completedChunks).length, chunkCount });
+        await saveDouyinDownloadState(stateFilePath, state);
+    }
+    else {
+        emitDouyinDownloadProgress(context, itemIndex, 0, 0, metadata.totalBytes, 'chunked_start', {
+            chunkCount,
+        });
+    }
+    let chunkCursor = 0;
+    const workers = Array.from({ length: Math.min(workerCount, chunkCount) }, async () => {
+        while (chunkCursor < chunkCount) {
+            const currentOffset = chunkCursor;
+            chunkCursor += 1;
+            const index = currentOffset;
+            if (state.completedChunks[String(index)]) {
+                continue;
+            }
+            const start = index * state.chunkSize;
+            const end = Math.min(start + state.chunkSize, state.totalSize) - 1;
+            let lastError;
+            for (let attempt = 0; attempt < DOUYIN_DOWNLOAD_MAX_RETRIES; attempt++) {
+                try {
+                    const chunkBuffer = await downloadDouyinChunk(resolvedUrl, headers, start, end);
+                    await node_fs_1.promises.writeFile(getDouyinPartFilePath(outputFile, index), chunkBuffer);
+                    state.completedChunks[String(index)] = true;
+                    downloadedBytes += chunkBuffer.length;
+                    await saveDouyinDownloadState(stateFilePath, state);
+                    const progressPercent = Math.min(100, Math.floor((downloadedBytes / metadata.totalBytes) * 100));
+                    if (progressPercent >= lastProgressPercent + 5 || progressPercent === 100) {
+                        lastProgressPercent = progressPercent;
+                        emitDouyinDownloadProgress(context, itemIndex, progressPercent, downloadedBytes, metadata.totalBytes, 'downloading', { completedChunks: Object.keys(state.completedChunks).length, chunkCount });
+                    }
+                    lastError = undefined;
+                    break;
+                }
+                catch (error) {
+                    lastError = error;
+                }
+            }
+            if (lastError) {
+                throw lastError;
+            }
+        }
+    });
+    await Promise.all(workers);
+    await mergeDouyinChunks(outputFile, chunkCount);
+    const buffer = await node_fs_1.promises.readFile(outputFile);
+    await cleanupDouyinChunkArtifacts(outputFile, chunkCount);
+    emitDouyinDownloadProgress(context, itemIndex, 100, buffer.length, metadata.totalBytes, 'completed', {
+        chunkCount,
+    });
+    return {
+        buffer,
+        downloadMode: 'chunked',
+        mimeType: metadata.mimeType,
+        progressPercent: 100,
+        resolvedDownloadUrl: resolvedUrl,
+        totalBytes: metadata.totalBytes,
+    };
+}
+async function streamDownloadWithProgress(context, itemIndex, videoUrl, downloadId, chunkSize, workerCount) {
+    const requestHeaders = {
+        Referer: 'https://www.douyin.com/',
+        'User-Agent': DOUYIN_MOBILE_USER_AGENT,
+    };
+    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);
+    try {
+        if (metadata.acceptRanges && metadata.totalBytes > 0) {
+            return await chunkedDouyinDownloadToFile(context, itemIndex, metadata.resolvedUrl, outputFile, requestHeaders, metadata, chunkSize, workerCount);
+        }
+        return await streamDouyinDownloadToFile(context, itemIndex, metadata.resolvedUrl, outputFile, requestHeaders, metadata.totalBytes);
+    }
+    finally {
+        await node_fs_1.promises.rm(outputFile, { force: true });
+        await node_fs_1.promises.rm(downloadDirectory, { force: true, recursive: false }).catch(() => undefined);
     }
-    const mimeTypeHeader = (_a = getHeaderValue(response.headers, 'content-type')) !== null && _a !== void 0 ? _a : 'video/mp4';
-    const mimeType = mimeTypeHeader.split(';')[0] || 'video/mp4';
-    return { buffer, mimeType };
 }
 async function extractAudioFromVideo(context, buffer, inputFileName, outputFileName, format, ffmpegPath, mimeType) {
     var _a;
-    const resolvedFfmpegPath = ffmpegPath.trim() || process.env.FFMPEG_PATH || 'ffmpeg';
+    const resolvedFfmpegPath = ffmpegPath.trim() || DEFAULT_FFMPEG_PATH;
     const tempDirectory = await node_fs_1.promises.mkdtemp((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'vidflow-audio-'));
     const inputExtension = (_a = getFileExtension(inputFileName)) !== null && _a !== void 0 ? _a : inferVideoExtension(mimeType);
     const tempInputPath = (0, node_path_1.join)(tempDirectory, `input.${inputExtension}`);
@@ -598,8 +939,12 @@ async function extractAudioFromVideo(context, buffer, inputFileName, outputFileN
         await node_fs_1.promises.rm(tempDirectory, { force: true, recursive: true });
     }
 }
-async function uploadAudioToBcut(context, buffer, fileName, resourceFileType) {
+async function uploadAudioToBcut(context, itemIndex, buffer, fileName, resourceFileType) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
+    emitBcutTranscriptionProgress(context, itemIndex, 10, 'upload_started', {
+        fileName,
+        fileSize: buffer.length,
+    });
     const createPayload = {
         type: 2,
         name: fileName,
@@ -646,6 +991,11 @@ async function uploadAudioToBcut(context, buffer, fileName, resourceFileType) {
             throw new n8n_workflow_1.ApplicationError(`BCut upload part ${index + 1} did not return an ETag header.`);
         }
         etags.push(etag.replace(/^"|"$/g, ''));
+        const uploadProgressPercent = Math.min(30, 10 + Math.floor(((index + 1) / uploadUrls.length) * 20));
+        emitBcutTranscriptionProgress(context, itemIndex, uploadProgressPercent, 'uploading', {
+            uploadedParts: index + 1,
+            totalParts: uploadUrls.length,
+        });
     }
     const commitResponse = await bcutRequest(context, {
         url: `${BCUT_API_BASE_URL}/resource/create/complete`,
@@ -663,13 +1013,17 @@ async function uploadAudioToBcut(context, buffer, fileName, resourceFileType) {
     if (commitResponse.code !== 0 || !((_g = commitResponse.data) === null || _g === void 0 ? void 0 : _g.download_url)) {
         throw new n8n_workflow_1.ApplicationError(`BCut upload commit failed: ${(_h = commitResponse.message) !== null && _h !== void 0 ? _h : 'Unknown error'}`);
     }
+    emitBcutTranscriptionProgress(context, itemIndex, 30, 'upload_completed', {
+        resourceId,
+    });
     return {
         resourceId,
         downloadUrl: commitResponse.data.download_url,
     };
 }
-async function createBcutTask(context, downloadUrl) {
+async function createBcutTask(context, itemIndex, downloadUrl) {
     var _a, _b;
+    emitBcutTranscriptionProgress(context, itemIndex, 35, 'task_creating');
     const taskResponse = await bcutRequest(context, {
         url: `${BCUT_API_BASE_URL}/task`,
         method: 'POST',
@@ -683,6 +1037,9 @@ async function createBcutTask(context, downloadUrl) {
     if (taskResponse.code !== 0 || !((_a = taskResponse.data) === null || _a === void 0 ? void 0 : _a.task_id)) {
         throw new n8n_workflow_1.ApplicationError(`BCut task creation failed: ${(_b = taskResponse.message) !== null && _b !== void 0 ? _b : 'Unknown error'}`);
     }
+    emitBcutTranscriptionProgress(context, itemIndex, 40, 'task_created', {
+        taskId: taskResponse.data.task_id,
+    });
     return taskResponse.data.task_id;
 }
 async function queryBcutTask(context, taskId) {
@@ -702,23 +1059,43 @@ async function queryBcutTask(context, taskId) {
     }
     return taskResultResponse.data;
 }
-async function transcribeWithBcut(context, buffer, fileName, resourceFileType, pollingIntervalSeconds, timeoutSeconds) {
+async function transcribeWithBcut(context, itemIndex, buffer, fileName, resourceFileType, pollingIntervalSeconds, timeoutSeconds) {
     var _a, _b, _c;
-    const { resourceId, downloadUrl } = await uploadAudioToBcut(context, buffer, fileName, resourceFileType);
-    const taskId = await createBcutTask(context, downloadUrl);
+    const { resourceId, downloadUrl } = await uploadAudioToBcut(context, itemIndex, buffer, fileName, resourceFileType);
+    const taskId = await createBcutTask(context, itemIndex, downloadUrl);
     const maxAttempts = Math.max(1, Math.ceil(timeoutSeconds / pollingIntervalSeconds));
     let taskResult;
+    let progressPercent = 40;
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
         taskResult = await queryBcutTask(context, taskId);
         if (taskResult.state === BCUT_POLL_STATE_COMPLETED) {
+            progressPercent = 100;
+            emitBcutTranscriptionProgress(context, itemIndex, progressPercent, 'completed', {
+                taskId,
+            });
             break;
         }
         if (taskResult.state === BCUT_POLL_STATE_FAILED) {
+            emitBcutTranscriptionProgress(context, itemIndex, progressPercent, 'failed', {
+                taskId,
+                state: taskResult.state,
+            });
             throw new n8n_workflow_1.ApplicationError(`BCut transcription failed with state ${String(taskResult.state)}.`);
         }
+        progressPercent = Math.min(95, 40 + Math.floor(((attempt + 1) / maxAttempts) * 55));
+        emitBcutTranscriptionProgress(context, itemIndex, progressPercent, 'polling', {
+            taskId,
+            pollAttempt: attempt + 1,
+            pollLimit: maxAttempts,
+            state: taskResult.state,
+        });
         await (0, n8n_workflow_1.sleep)(pollingIntervalSeconds * 1000);
     }
     if ((taskResult === null || taskResult === void 0 ? void 0 : taskResult.state) !== BCUT_POLL_STATE_COMPLETED || !taskResult.result) {
+        emitBcutTranscriptionProgress(context, itemIndex, progressPercent, 'timeout', {
+            taskId,
+            state: taskResult === null || taskResult === void 0 ? void 0 : taskResult.state,
+        });
         throw new n8n_workflow_1.ApplicationError(`BCut transcription timed out with state ${String((_a = taskResult === null || taskResult === void 0 ? void 0 : taskResult.state) !== null && _a !== void 0 ? _a : 'unknown')}.`);
     }
     const rawResult = JSON.parse(taskResult.result);
@@ -739,6 +1116,7 @@ async function transcribeWithBcut(context, buffer, fileName, resourceFileType, p
         resourceId,
         downloadUrl,
         language: (_c = rawResult.language) !== null && _c !== void 0 ? _c : 'zh',
+        progressPercent,
         text,
         segments,
         raw: rawResult,
@@ -845,12 +1223,13 @@ class Vidflow {
                     const buffer = await this.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
                     const fileName = resolveFileName(binaryData, fileNameOverride);
                     const resourceFileType = resolveResourceFileType(fileName, binaryData.mimeType);
-                    const transcript = await transcribeWithBcut(this, buffer, fileName, resourceFileType, pollingIntervalSeconds, timeoutSeconds);
+                    const transcript = await transcribeWithBcut(this, itemIndex, buffer, fileName, resourceFileType, pollingIntervalSeconds, timeoutSeconds);
                     const result = {
                         taskId: transcript.taskId,
                         resourceId: transcript.resourceId,
                         downloadUrl: transcript.downloadUrl,
                         language: transcript.language,
+                        progressPercent: transcript.progressPercent,
                         text: transcript.text,
                         segments: transcript.segments,
                     };
@@ -870,11 +1249,17 @@ class Vidflow {
                     const shareText = this.getNodeParameter('shareText', itemIndex);
                     const outputBinaryPropertyName = this.getNodeParameter('outputBinaryPropertyName', itemIndex);
                     const outputFileName = this.getNodeParameter('outputFileName', itemIndex, '');
+                    const chunkSizeMb = this.getNodeParameter('chunkSizeMb', itemIndex);
+                    const workerCount = this.getNodeParameter('workerCount', itemIndex);
                     const videoInfo = await getDouyinVideoInfo(this, shareText);
-                    const { buffer, mimeType } = await downloadDouyinVideoBuffer(this, videoInfo.videoUrl);
+                    const downloadId = videoInfo.awemeId || videoInfo.title || 'douyin_video';
+                    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, downloadId, chunkSize, normalizedWorkerCount);
                     const finalFileName = outputFileName.trim() !== ''
                         ? sanitizeFileName(outputFileName.trim())
-                        : `${sanitizeFileName(videoInfo.awemeId || videoInfo.title || 'douyin_video')}.mp4`;
+                        : `${sanitizeFileName(downloadId)}.mp4`;
                     const binaryData = await this.helpers.prepareBinaryData(buffer, finalFileName, mimeType);
                     returnData.push({
                         json: {
@@ -886,9 +1271,15 @@ class Vidflow {
                             createTime: videoInfo.createTime,
                             originalUrl: videoInfo.originalUrl,
                             resolvedUrl: videoInfo.resolvedUrl,
+                            resolvedDownloadUrl,
+                            downloadMode,
                             fileName: finalFileName,
                             mimeType,
                             size: buffer.length,
+                            totalBytes,
+                            downloadProgressPercent: progressPercent,
+                            chunkSizeMb: normalizedChunkSizeMb,
+                            workerCount: normalizedWorkerCount,
                         },
                         binary: {
                             [outputBinaryPropertyName]: binaryData,