n8n-nodes-vidflow 0.1.2

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

@@ -0,0 +1,932 @@
+"use strict";
+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 node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
+const n8n_workflow_1 = require("n8n-workflow");
+const BCUT_API_BASE_URL = 'https://member.bilibili.com/x/bcut/rubick-interface';
+const BCUT_MODEL_ID = '8';
+const BCUT_QUERY_MODEL_ID = 7;
+const BCUT_POLL_STATE_FAILED = 3;
+const BCUT_POLL_STATE_COMPLETED = 4;
+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 execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const audioExtractDisplayOptions = {
+    resource: ['audio'],
+    operation: ['extractFromVideo'],
+};
+const transcriptionDisplayOptions = {
+    resource: ['transcription'],
+    operation: ['transcribe'],
+};
+const douyinDownloadDisplayOptions = {
+    resource: ['douyin'],
+    operation: ['downloadVideo'],
+};
+const transcriptionDescription = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['transcription'],
+            },
+        },
+        options: [
+            {
+                name: 'Transcribe',
+                value: 'transcribe',
+                action: 'Transcribe audio using bcut',
+                description: 'Upload an audio file to BCut and return the transcript',
+            },
+        ],
+        default: 'transcribe',
+    },
+    {
+        displayName: 'Binary Property',
+        name: 'binaryPropertyName',
+        type: 'string',
+        required: true,
+        default: 'data',
+        displayOptions: {
+            show: transcriptionDisplayOptions,
+        },
+        description: 'Name of the binary property that contains the audio file',
+    },
+    {
+        displayName: 'File Name',
+        name: 'fileName',
+        type: 'string',
+        default: '',
+        displayOptions: {
+            show: transcriptionDisplayOptions,
+        },
+        description: 'Optional file name override. When empty, the binary metadata is used.',
+    },
+    {
+        displayName: 'Include Raw Result',
+        name: 'includeRawResult',
+        type: 'boolean',
+        default: false,
+        displayOptions: {
+            show: transcriptionDisplayOptions,
+        },
+        description: 'Whether to include the raw BCut response in the output',
+    },
+    {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: transcriptionDisplayOptions,
+        },
+        options: [
+            {
+                displayName: 'Polling Interval Seconds',
+                name: 'pollingIntervalSeconds',
+                type: 'number',
+                default: 1,
+                typeOptions: {
+                    minValue: 1,
+                    maxValue: 30,
+                },
+                description: 'How often to poll BCut for task completion',
+            },
+            {
+                displayName: 'Timeout Seconds',
+                name: 'timeoutSeconds',
+                type: 'number',
+                default: 500,
+                typeOptions: {
+                    minValue: 10,
+                    maxValue: 3600,
+                },
+                description: 'How long to wait before timing out the transcription task',
+            },
+        ],
+    },
+];
+const audioDescription = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['audio'],
+            },
+        },
+        options: [
+            {
+                name: 'Extract From Video',
+                value: 'extractFromVideo',
+                action: 'Extract audio from a video',
+                description: 'Extract the audio track from an input video using ffmpeg',
+            },
+        ],
+        default: 'extractFromVideo',
+    },
+    {
+        displayName: 'Binary Property',
+        name: 'binaryPropertyName',
+        type: 'string',
+        required: true,
+        default: 'data',
+        displayOptions: {
+            show: audioExtractDisplayOptions,
+        },
+        description: 'Name of the binary property that contains the input video',
+    },
+    {
+        displayName: 'Output Binary Property',
+        name: 'outputBinaryPropertyName',
+        type: 'string',
+        required: true,
+        default: 'audio',
+        displayOptions: {
+            show: audioExtractDisplayOptions,
+        },
+        description: 'Name of the output binary property that will contain the extracted audio',
+    },
+    {
+        displayName: 'Output Format',
+        name: 'outputFormat',
+        type: 'options',
+        default: 'mp3',
+        displayOptions: {
+            show: audioExtractDisplayOptions,
+        },
+        options: [
+            {
+                name: 'AAC',
+                value: 'aac',
+            },
+            {
+                name: 'MP3',
+                value: 'mp3',
+            },
+            {
+                name: 'OGG',
+                value: 'ogg',
+            },
+            {
+                name: 'WAV',
+                value: 'wav',
+            },
+        ],
+        description: 'Audio format for the extracted file',
+    },
+    {
+        displayName: 'File Name',
+        name: 'outputFileName',
+        type: 'string',
+        default: '',
+        displayOptions: {
+            show: audioExtractDisplayOptions,
+        },
+        description: 'Optional output file name override',
+    },
+    {
+        displayName: 'FFmpeg Path',
+        name: 'ffmpegPath',
+        type: 'string',
+        default: '',
+        displayOptions: {
+            show: audioExtractDisplayOptions,
+        },
+        description: 'Optional ffmpeg executable path. When empty, ffmpeg is resolved from PATH.',
+    },
+];
+const douyinDescription = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['douyin'],
+            },
+        },
+        options: [
+            {
+                name: 'Download Video',
+                value: 'downloadVideo',
+                action: 'Download a video',
+                description: 'Download a Douyin video from a share link',
+            },
+        ],
+        default: 'downloadVideo',
+    },
+    {
+        displayName: 'Share Text Or Link',
+        name: 'shareText',
+        type: 'string',
+        typeOptions: {
+            rows: 4,
+        },
+        required: true,
+        default: '',
+        displayOptions: {
+            show: douyinDownloadDisplayOptions,
+        },
+        description: 'A Douyin share message, short link, or direct video link',
+    },
+    {
+        displayName: 'Output Binary Property',
+        name: 'outputBinaryPropertyName',
+        type: 'string',
+        required: true,
+        default: 'video',
+        displayOptions: {
+            show: douyinDownloadDisplayOptions,
+        },
+        description: 'Name of the output binary property that will contain the MP4 file',
+    },
+    {
+        displayName: 'File Name',
+        name: 'outputFileName',
+        type: 'string',
+        default: '',
+        displayOptions: {
+            show: douyinDownloadDisplayOptions,
+        },
+        description: 'Optional output file name override',
+    },
+];
+function getBcutHeaders() {
+    return {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        'User-Agent': 'Bilibili/1.0.0 (https://www.bilibili.com)',
+    };
+}
+function getFileExtension(fileName) {
+    const lastDotIndex = fileName.lastIndexOf('.');
+    if (lastDotIndex === -1 || lastDotIndex === fileName.length - 1) {
+        return undefined;
+    }
+    return fileName.slice(lastDotIndex + 1).toLowerCase();
+}
+function inferExtensionFromMimeType(mimeType) {
+    var _a;
+    const normalizedMimeType = (_a = mimeType === null || mimeType === void 0 ? void 0 : mimeType.toLowerCase()) !== null && _a !== void 0 ? _a : '';
+    if (normalizedMimeType.includes('mpeg') || normalizedMimeType.includes('mp3')) {
+        return 'mp3';
+    }
+    if (normalizedMimeType.includes('wav')) {
+        return 'wav';
+    }
+    if (normalizedMimeType.includes('x-m4a') || normalizedMimeType.includes('m4a')) {
+        return 'm4a';
+    }
+    if (normalizedMimeType.includes('aac')) {
+        return 'aac';
+    }
+    if (normalizedMimeType.includes('flac')) {
+        return 'flac';
+    }
+    if (normalizedMimeType.includes('ogg') || normalizedMimeType.includes('opus')) {
+        return 'ogg';
+    }
+    return 'mp3';
+}
+function resolveFileName(binaryData, fileNameOverride) {
+    const normalizedOverride = fileNameOverride.trim();
+    if (normalizedOverride !== '') {
+        return normalizedOverride;
+    }
+    if (binaryData.fileName) {
+        return binaryData.fileName;
+    }
+    return `audio.${inferExtensionFromMimeType(binaryData.mimeType)}`;
+}
+function resolveResourceFileType(fileName, mimeType) {
+    var _a;
+    return (_a = getFileExtension(fileName)) !== null && _a !== void 0 ? _a : inferExtensionFromMimeType(mimeType);
+}
+function inferVideoExtension(mimeType) {
+    var _a;
+    const normalizedMimeType = (_a = mimeType === null || mimeType === void 0 ? void 0 : mimeType.toLowerCase()) !== null && _a !== void 0 ? _a : '';
+    if (normalizedMimeType.includes('quicktime')) {
+        return 'mov';
+    }
+    if (normalizedMimeType.includes('webm')) {
+        return 'webm';
+    }
+    if (normalizedMimeType.includes('x-matroska') || normalizedMimeType.includes('mkv')) {
+        return 'mkv';
+    }
+    return 'mp4';
+}
+function getOutputAudioMimeType(format) {
+    switch (format) {
+        case 'aac':
+            return 'audio/aac';
+        case 'ogg':
+            return 'audio/ogg';
+        case 'wav':
+            return 'audio/wav';
+        case 'mp3':
+        default:
+            return 'audio/mpeg';
+    }
+}
+function buildFfmpegAudioArguments(inputPath, outputPath, format) {
+    const baseArgs = ['-i', inputPath, '-vn'];
+    switch (format) {
+        case 'wav':
+            return [...baseArgs, '-acodec', 'pcm_s16le', '-ar', '16000', '-ac', '1', '-y', outputPath];
+        case 'aac':
+            return [...baseArgs, '-acodec', 'aac', '-ab', '192k', '-ar', '44100', '-ac', '2', '-y', outputPath];
+        case 'ogg':
+            return [
+                ...baseArgs,
+                '-acodec',
+                'libvorbis',
+                '-ab',
+                '192k',
+                '-ar',
+                '44100',
+                '-ac',
+                '2',
+                '-y',
+                outputPath,
+            ];
+        case 'mp3':
+        default:
+            return [...baseArgs, '-acodec', 'libmp3lame', '-ab', '192k', '-ar', '44100', '-ac', '2', '-y', outputPath];
+    }
+}
+function resolveAudioOutputFileName(inputFileName, outputFileName, format) {
+    if (outputFileName.trim() !== '') {
+        const sanitizedName = sanitizeFileName(outputFileName.trim());
+        return (0, node_path_1.extname)(sanitizedName).toLowerCase() === `.${format}`
+            ? sanitizedName
+            : `${sanitizedName}.${format}`;
+    }
+    const baseName = sanitizeFileName(inputFileName.replace(/\.[^.]+$/, ''));
+    return `${baseName}.${format}`;
+}
+function asErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return 'Unknown error';
+}
+function getHeaderValue(headers, name) {
+    var _a, _b;
+    if (!headers) {
+        return undefined;
+    }
+    const headerValue = (_b = (_a = headers[name]) !== null && _a !== void 0 ? _a : headers[name.toLowerCase()]) !== null && _b !== void 0 ? _b : headers[name.toUpperCase()];
+    if (Array.isArray(headerValue)) {
+        return headerValue[0];
+    }
+    return headerValue;
+}
+function extractFirstUrl(input) {
+    const match = 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(/[),.;!?]+$/, '');
+}
+function extractDouyinVideoId(urlString) {
+    var _a;
+    const pathMatch = urlString.match(/\/video\/(\d+)/);
+    if (pathMatch === null || pathMatch === void 0 ? void 0 : pathMatch[1]) {
+        return pathMatch[1];
+    }
+    try {
+        const parsedUrl = new URL(urlString);
+        return (_a = parsedUrl.searchParams.get('modal_id')) !== null && _a !== void 0 ? _a : '';
+    }
+    catch {
+        return '';
+    }
+}
+function sanitizeFileName(fileName) {
+    const sanitized = fileName.replace(/[<>:"/\\|?*]/g, '_').trim();
+    if (sanitized === '') {
+        return 'video';
+    }
+    return sanitized.slice(0, 200);
+}
+function parseRouterDataVideoInfo(html, originalUrl, resolvedUrl) {
+    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])) {
+        throw new n8n_workflow_1.ApplicationError('Douyin page did not contain window._ROUTER_DATA.');
+    }
+    const routerDataJson = routerDataMatch[1].trim().replace(/;\s*$/, '');
+    const routerData = JSON.parse(routerDataJson);
+    const loaderData = routerData.loaderData;
+    if (!loaderData) {
+        throw new n8n_workflow_1.ApplicationError('Douyin page did not include loaderData.');
+    }
+    const pageData = (_a = loaderData['video_(id)/page']) !== null && _a !== void 0 ? _a : loaderData['note_(id)/page'];
+    const item = (_c = (_b = pageData === null || pageData === void 0 ? void 0 : pageData.videoInfoRes) === null || _b === void 0 ? void 0 : _b.item_list) === null || _c === void 0 ? void 0 : _c[0];
+    if (!item) {
+        throw new n8n_workflow_1.ApplicationError('Douyin video details could not be extracted from loaderData.');
+    }
+    const videoUrl = (_h = (_g = (_f = (_e = (_d = item.video) === null || _d === void 0 ? void 0 : _d.play_addr) === null || _e === void 0 ? void 0 : _e.url_list) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.replace(/playwm/g, 'play')) !== null && _h !== void 0 ? _h : '';
+    if (videoUrl === '') {
+        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 : '',
+        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,
+        createTime: item.create_time,
+        originalUrl,
+        resolvedUrl,
+    };
+}
+function parseRenderDataVideoInfo(html, originalUrl, resolvedUrl) {
+    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])) {
+        throw new n8n_workflow_1.ApplicationError('Douyin page did not contain RENDER_DATA.');
+    }
+    const decodedJson = decodeURIComponent(renderDataMatch[1]);
+    const renderData = JSON.parse(decodedJson);
+    const pageRoot = (_c = (_b = (_a = renderData['23']) === null || _a === void 0 ? void 0 : _a.aweme) === null || _b === void 0 ? void 0 : _b.detail) !== null && _c !== void 0 ? _c : (_d = renderData.aweme) === null || _d === void 0 ? void 0 : _d.detail;
+    if (!pageRoot) {
+        throw new n8n_workflow_1.ApplicationError('Douyin video details could not be extracted from RENDER_DATA.');
+    }
+    const video = pageRoot.video;
+    const playUrl = (_h = (_g = (_f = (_e = video === null || video === void 0 ? void 0 : video.playAddr) === null || _e === void 0 ? void 0 : _e.urlList) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.replace(/playwm/g, 'play')) !== null && _h !== void 0 ? _h : '';
+    if (playUrl === '') {
+        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 : ''),
+        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,
+    };
+}
+async function bcutRequest(context, requestOptions) {
+    return (await context.helpers.httpRequest(requestOptions));
+}
+async function douyinRequestText(context, url, allowRedirect = true) {
+    var _a;
+    const response = (await context.helpers.httpRequest({
+        url,
+        method: 'GET',
+        headers: {
+            Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'zh-CN,zh;q=0.9',
+            Referer: 'https://www.douyin.com/',
+            'User-Agent': DOUYIN_MOBILE_USER_AGENT,
+        },
+        json: false,
+        encoding: 'text',
+        disableFollowRedirect: !allowRedirect,
+        ignoreHttpStatusErrors: !allowRedirect,
+        returnFullResponse: !allowRedirect,
+    }));
+    if (typeof response === 'string') {
+        return { body: response };
+    }
+    return {
+        body: (_a = response.body) !== null && _a !== void 0 ? _a : '',
+        statusCode: response.statusCode,
+        headers: response.headers,
+    };
+}
+async function resolveDouyinUrl(context, shareText) {
+    const originalUrl = extractFirstUrl(shareText.trim());
+    if (!originalUrl.includes('v.douyin.com')) {
+        return {
+            originalUrl,
+            resolvedUrl: originalUrl,
+        };
+    }
+    const response = await douyinRequestText(context, originalUrl, false);
+    const redirectLocation = getHeaderValue(response.headers, 'location');
+    return {
+        originalUrl,
+        resolvedUrl: redirectLocation !== null && redirectLocation !== void 0 ? redirectLocation : originalUrl,
+    };
+}
+async function getDouyinVideoInfo(context, shareText) {
+    const { originalUrl, resolvedUrl } = await resolveDouyinUrl(context, shareText);
+    const videoId = extractDouyinVideoId(resolvedUrl);
+    if (videoId === '') {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'A Douyin video ID could not be extracted from the provided link.');
+    }
+    try {
+        const iesPageResponse = await douyinRequestText(context, `https://www.iesdouyin.com/share/video/${videoId}`);
+        return parseRouterDataVideoInfo(iesPageResponse.body, originalUrl, resolvedUrl);
+    }
+    catch (iesError) {
+        const webPageResponse = await douyinRequestText(context, `https://www.douyin.com/video/${videoId}`);
+        try {
+            return parseRenderDataVideoInfo(webPageResponse.body, originalUrl, resolvedUrl);
+        }
+        catch {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Douyin video details could not be resolved: ${asErrorMessage(iesError)}`);
+        }
+    }
+}
+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.');
+    }
+    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 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}`);
+    const finalFileName = resolveAudioOutputFileName(inputFileName, outputFileName, format);
+    const tempOutputPath = (0, node_path_1.join)(tempDirectory, finalFileName);
+    try {
+        await node_fs_1.promises.writeFile(tempInputPath, buffer);
+        const ffmpegArgs = buildFfmpegAudioArguments(tempInputPath, tempOutputPath, format);
+        try {
+            await execFileAsync(resolvedFfmpegPath, ffmpegArgs);
+        }
+        catch (error) {
+            const execError = error;
+            const commandOutput = execError.stderr || execError.stdout || execError.message;
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Audio extraction failed: ${commandOutput || 'ffmpeg returned an unknown error'}`);
+        }
+        const outputBuffer = await node_fs_1.promises.readFile(tempOutputPath);
+        return {
+            buffer: outputBuffer,
+            ffmpegPath: resolvedFfmpegPath,
+            fileName: finalFileName,
+            format,
+            mimeType: getOutputAudioMimeType(format),
+            size: outputBuffer.length,
+        };
+    }
+    finally {
+        await node_fs_1.promises.rm(tempDirectory, { force: true, recursive: true });
+    }
+}
+async function uploadAudioToBcut(context, buffer, fileName, resourceFileType) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const createPayload = {
+        type: 2,
+        name: fileName,
+        size: buffer.length,
+        ResourceFileType: resourceFileType,
+        model_id: BCUT_MODEL_ID,
+    };
+    const createResponse = await bcutRequest(context, {
+        url: `${BCUT_API_BASE_URL}/resource/create`,
+        method: 'POST',
+        headers: getBcutHeaders(),
+        body: createPayload,
+        json: true,
+    });
+    if (createResponse.code !== 0 || createResponse.data === undefined) {
+        throw new n8n_workflow_1.ApplicationError(`BCut upload initialization failed: ${(_a = createResponse.message) !== null && _a !== void 0 ? _a : 'Unknown error'}`);
+    }
+    const { data } = createResponse;
+    const resourceId = data.resource_id;
+    const inBossKey = data.in_boss_key;
+    const uploadId = data.upload_id;
+    const uploadUrls = (_b = data.upload_urls) !== null && _b !== void 0 ? _b : [];
+    const partSize = (_c = data.per_size) !== null && _c !== void 0 ? _c : 0;
+    if (!resourceId || !inBossKey || !uploadId || uploadUrls.length === 0 || partSize <= 0) {
+        throw new n8n_workflow_1.ApplicationError('BCut upload initialization returned incomplete upload metadata.');
+    }
+    const etags = [];
+    for (let index = 0; index < uploadUrls.length; index++) {
+        const startRange = index * partSize;
+        const endRange = Math.min((index + 1) * partSize, buffer.length);
+        const uploadResponse = (await context.helpers.httpRequest({
+            url: uploadUrls[index],
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/octet-stream',
+            },
+            body: buffer.subarray(startRange, endRange),
+            json: false,
+            returnFullResponse: true,
+        }));
+        const rawEtag = (_e = (_d = uploadResponse.headers) === null || _d === void 0 ? void 0 : _d.etag) !== null && _e !== void 0 ? _e : (_f = uploadResponse.headers) === null || _f === void 0 ? void 0 : _f.Etag;
+        const etag = Array.isArray(rawEtag) ? rawEtag[0] : rawEtag;
+        if (!etag) {
+            throw new n8n_workflow_1.ApplicationError(`BCut upload part ${index + 1} did not return an ETag header.`);
+        }
+        etags.push(etag.replace(/^"|"$/g, ''));
+    }
+    const commitResponse = await bcutRequest(context, {
+        url: `${BCUT_API_BASE_URL}/resource/create/complete`,
+        method: 'POST',
+        headers: getBcutHeaders(),
+        body: {
+            InBossKey: inBossKey,
+            ResourceId: resourceId,
+            Etags: etags.join(','),
+            UploadId: uploadId,
+            model_id: BCUT_MODEL_ID,
+        },
+        json: true,
+    });
+    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'}`);
+    }
+    return {
+        resourceId,
+        downloadUrl: commitResponse.data.download_url,
+    };
+}
+async function createBcutTask(context, downloadUrl) {
+    var _a, _b;
+    const taskResponse = await bcutRequest(context, {
+        url: `${BCUT_API_BASE_URL}/task`,
+        method: 'POST',
+        headers: getBcutHeaders(),
+        body: {
+            resource: downloadUrl,
+            model_id: BCUT_MODEL_ID,
+        },
+        json: true,
+    });
+    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'}`);
+    }
+    return taskResponse.data.task_id;
+}
+async function queryBcutTask(context, taskId) {
+    var _a;
+    const taskResultResponse = await bcutRequest(context, {
+        url: `${BCUT_API_BASE_URL}/task/result`,
+        method: 'GET',
+        headers: getBcutHeaders(),
+        qs: {
+            model_id: BCUT_QUERY_MODEL_ID,
+            task_id: taskId,
+        },
+        json: true,
+    });
+    if (taskResultResponse.code !== 0 || taskResultResponse.data === undefined) {
+        throw new n8n_workflow_1.ApplicationError(`BCut task polling failed: ${(_a = taskResultResponse.message) !== null && _a !== void 0 ? _a : 'Unknown error'}`);
+    }
+    return taskResultResponse.data;
+}
+async function transcribeWithBcut(context, 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 maxAttempts = Math.max(1, Math.ceil(timeoutSeconds / pollingIntervalSeconds));
+    let taskResult;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        taskResult = await queryBcutTask(context, taskId);
+        if (taskResult.state === BCUT_POLL_STATE_COMPLETED) {
+            break;
+        }
+        if (taskResult.state === BCUT_POLL_STATE_FAILED) {
+            throw new n8n_workflow_1.ApplicationError(`BCut transcription failed with state ${String(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) {
+        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);
+    const segments = ((_b = rawResult.utterances) !== null && _b !== void 0 ? _b : []).map((utterance) => {
+        var _a, _b, _c;
+        return ({
+            start: Number((_a = utterance.start_time) !== null && _a !== void 0 ? _a : 0) / 1000,
+            end: Number((_b = utterance.end_time) !== null && _b !== void 0 ? _b : 0) / 1000,
+            text: String((_c = utterance.transcript) !== null && _c !== void 0 ? _c : '').trim(),
+        });
+    });
+    const text = segments
+        .map((segment) => segment.text)
+        .filter((segmentText) => segmentText !== '')
+        .join(' ');
+    return {
+        taskId,
+        resourceId,
+        downloadUrl,
+        language: (_c = rawResult.language) !== null && _c !== void 0 ? _c : 'zh',
+        text,
+        segments,
+        raw: rawResult,
+    };
+}
+class Vidflow {
+    constructor() {
+        this.description = {
+            displayName: 'Vidflow',
+            name: 'vidflow',
+            icon: { light: 'file:vidflow.svg', dark: 'file:vidflow.dark.svg' },
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Extract audio, transcribe with BCut, and download Douyin videos',
+            defaults: {
+                name: 'Vidflow',
+            },
+            usableAsTool: true,
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Audio',
+                            value: 'audio',
+                        },
+                        {
+                            name: 'Douyin',
+                            value: 'douyin',
+                        },
+                        {
+                            name: 'Transcription',
+                            value: 'transcription',
+                        },
+                    ],
+                    default: 'transcription',
+                },
+                ...audioDescription,
+                ...transcriptionDescription,
+                ...douyinDescription,
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b, _c;
+        const items = this.getInputData();
+        const returnData = [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const resource = this.getNodeParameter('resource', itemIndex);
+                const operation = this.getNodeParameter('operation', itemIndex);
+                if (resource === 'audio' && operation === 'extractFromVideo') {
+                    const binaryPropertyName = this.getNodeParameter('binaryPropertyName', itemIndex);
+                    const outputBinaryPropertyName = this.getNodeParameter('outputBinaryPropertyName', itemIndex);
+                    const outputFormat = this.getNodeParameter('outputFormat', itemIndex);
+                    const outputFileName = this.getNodeParameter('outputFileName', itemIndex, '');
+                    const ffmpegPath = this.getNodeParameter('ffmpegPath', itemIndex, '');
+                    const binaryData = this.helpers.assertBinaryData(itemIndex, binaryPropertyName);
+                    const inputBuffer = await this.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
+                    const inputFileName = (_a = binaryData.fileName) !== null && _a !== void 0 ? _a : `video.${inferVideoExtension(binaryData.mimeType)}`;
+                    const extractedAudio = await extractAudioFromVideo(this, inputBuffer, inputFileName, outputFileName, outputFormat, ffmpegPath, binaryData.mimeType);
+                    const outputBinaryData = await this.helpers.prepareBinaryData(extractedAudio.buffer, extractedAudio.fileName, extractedAudio.mimeType);
+                    returnData.push({
+                        json: {
+                            inputBinaryPropertyName: binaryPropertyName,
+                            inputFileName,
+                            outputBinaryPropertyName,
+                            outputFileName: extractedAudio.fileName,
+                            outputFormat: extractedAudio.format,
+                            mimeType: extractedAudio.mimeType,
+                            size: extractedAudio.size,
+                            ffmpegPath: extractedAudio.ffmpegPath,
+                        },
+                        binary: {
+                            ...items[itemIndex].binary,
+                            [outputBinaryPropertyName]: outputBinaryData,
+                        },
+                        pairedItem: {
+                            item: itemIndex,
+                        },
+                    });
+                    continue;
+                }
+                if (resource === 'transcription' && operation === 'transcribe') {
+                    const binaryPropertyName = this.getNodeParameter('binaryPropertyName', itemIndex);
+                    const fileNameOverride = this.getNodeParameter('fileName', itemIndex, '');
+                    const includeRawResult = this.getNodeParameter('includeRawResult', itemIndex, false);
+                    const options = this.getNodeParameter('options', itemIndex, {});
+                    const pollingIntervalSeconds = Number((_b = options.pollingIntervalSeconds) !== null && _b !== void 0 ? _b : 1);
+                    const timeoutSeconds = Number((_c = options.timeoutSeconds) !== null && _c !== void 0 ? _c : 500);
+                    if (Number.isNaN(pollingIntervalSeconds) || pollingIntervalSeconds < 1) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Polling Interval Seconds must be greater than or equal to 1', { itemIndex });
+                    }
+                    if (Number.isNaN(timeoutSeconds) || timeoutSeconds < pollingIntervalSeconds) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Timeout Seconds must be greater than or equal to the polling interval', { itemIndex });
+                    }
+                    const binaryData = this.helpers.assertBinaryData(itemIndex, binaryPropertyName);
+                    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 result = {
+                        taskId: transcript.taskId,
+                        resourceId: transcript.resourceId,
+                        downloadUrl: transcript.downloadUrl,
+                        language: transcript.language,
+                        text: transcript.text,
+                        segments: transcript.segments,
+                    };
+                    if (includeRawResult) {
+                        result.raw = transcript.raw;
+                    }
+                    returnData.push({
+                        json: result,
+                        binary: items[itemIndex].binary,
+                        pairedItem: {
+                            item: itemIndex,
+                        },
+                    });
+                    continue;
+                }
+                if (resource === 'douyin' && operation === 'downloadVideo') {
+                    const shareText = this.getNodeParameter('shareText', itemIndex);
+                    const outputBinaryPropertyName = this.getNodeParameter('outputBinaryPropertyName', itemIndex);
+                    const outputFileName = this.getNodeParameter('outputFileName', itemIndex, '');
+                    const videoInfo = await getDouyinVideoInfo(this, shareText);
+                    const { buffer, mimeType } = await downloadDouyinVideoBuffer(this, videoInfo.videoUrl);
+                    const finalFileName = outputFileName.trim() !== ''
+                        ? sanitizeFileName(outputFileName.trim())
+                        : `${sanitizeFileName(videoInfo.awemeId || videoInfo.title || 'douyin_video')}.mp4`;
+                    const binaryData = await this.helpers.prepareBinaryData(buffer, finalFileName, mimeType);
+                    returnData.push({
+                        json: {
+                            awemeId: videoInfo.awemeId,
+                            title: videoInfo.title,
+                            author: videoInfo.author,
+                            cover: videoInfo.cover,
+                            videoUrl: videoInfo.videoUrl,
+                            createTime: videoInfo.createTime,
+                            originalUrl: videoInfo.originalUrl,
+                            resolvedUrl: videoInfo.resolvedUrl,
+                            fileName: finalFileName,
+                            mimeType,
+                            size: buffer.length,
+                        },
+                        binary: {
+                            [outputBinaryPropertyName]: binaryData,
+                        },
+                        pairedItem: {
+                            item: itemIndex,
+                        },
+                    });
+                    continue;
+                }
+                if (resource !== 'transcription' || operation !== 'transcribe') {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported resource or operation: ${resource}.${operation}`, { itemIndex });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: asErrorMessage(error),
+                        },
+                        pairedItem: {
+                            item: itemIndex,
+                        },
+                    });
+                    continue;
+                }
+                if (error instanceof n8n_workflow_1.NodeOperationError) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message, {
+                        itemIndex,
+                    });
+                }
+                throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+                    itemIndex,
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Vidflow = Vidflow;
+//# sourceMappingURL=Vidflow.node.js.map