@lee-jisoo/n8n-nodes-mediafx 1.6.14 → 1.6.16

package/README.ko-KR.md

@@ -9,7 +9,20 @@
 <!-- Optional: Add a GIF of the node in action here -->
 <!-- <p align="center"><img src="link/to/your/demo.gif" alt="MediaFX Node Demo"></p> -->
 
-## v1.4.2의 새로운 기능
+## v1.6.15의 새로운 기능
+
+-   **🔍 미디어 분석 (Probe)**: 비디오/오디오 파일에서 메타정보를 추출하는 새로운 기능
+    - 포맷 정보: 파일명, 포맷, 재생시간, 파일크기, 비트레이트
+    - 비디오 스트림: 코덱, 해상도, 프레임레이트, 화면비율, 픽셀포맷
+    - 오디오 스트림: 코덱, 샘플레이트, 채널 수, 채널 레이아웃
+    - 태그: 제목, 아티스트, 앨범 등 파일에 포함된 메타데이터
+
+-   **🔤 시스템 폰트 지원**: 시스템에 설치된 폰트를 사용 가능
+    - 글꼴 > 목록 작업에서 "시스템 폰트 포함" 옵션으로 시스템 폰트 스캔
+    - 텍스트/자막 작업에서 시스템 폰트 경로 직접 지정 가능
+    - macOS, Linux, Windows의 시스템 폰트 디렉토리 지원
+
+## v1.4.2의 기능
 
 -   **버그 수정**: 비디오 소스가 올바르게 설정되지 않은 경우 오디오 분리 작업에서 "did not produce an output" 오류 수정
     - 소스가 누락된 경우 명확한 오류 메시지와 함께 적절한 유효성 검사 추가
@@ -104,6 +117,9 @@
 -   `문자열 추가`: 비디오에 텍스트 오버레이를 추가합니다.
 -   `자막 추가`: `.srt` 파일에서 자막을 추가합니다.
 
+#### **분석 (Probe)** 리소스
+-   `메타정보 조회`: 비디오/오디오 파일에서 포맷 정보, 스트림 정보, 태그 등 상세한 메타데이터를 추출합니다.
+
 #### **글꼴** 리소스
 -   `목록`: 사용 가능한 모든 시스템 및 사용자 업로드 글꼴 목록을 가져옵니다.
 -   `업로드`: 텍스트 작업에 사용할 사용자 지정 글꼴 파일(`.ttf`, `.otf`)을 업로드합니다.
@@ -111,6 +127,75 @@
 
 ## 사용 예제
 
+### 미디어 메타정보 조회 (v1.6.15 신규)
+비디오 또는 오디오 파일에서 메타정보를 추출합니다.
+
+```json
+{
+  "resource": "probe",
+  "operation": "getMetadata",
+  "probeSource": {
+    "source": { "sourceType": "binary", "binaryProperty": "data" }
+  }
+}
+```
+
+출력 예시:
+```json
+{
+  "success": true,
+  "operation": "getMetadata",
+  "format": {
+    "filename": "video.mp4",
+    "formatName": "mov,mp4,m4a,3gp,3g2,mj2",
+    "duration": 120.5,
+    "size": 15728640,
+    "bitRate": 1048576
+  },
+  "video": {
+    "codec": "h264",
+    "width": 1920,
+    "height": 1080,
+    "frameRate": 30,
+    "aspectRatio": "16:9"
+  },
+  "audio": {
+    "codec": "aac",
+    "sampleRate": 48000,
+    "channels": 2,
+    "channelLayout": "stereo"
+  },
+  "hasVideo": true,
+  "hasAudio": true
+}
+```
+
+### 시스템 폰트 사용하기 (v1.6.15 신규)
+
+먼저 시스템에 설치된 폰트 목록을 확인합니다:
+```json
+{
+  "resource": "font",
+  "operation": "list",
+  "filterOptions": {
+    "includeSystemFonts": true,
+    "fontType": "system"
+  }
+}
+```
+
+시스템 폰트로 자막 추가하기:
+```json
+{
+  "resource": "subtitle",
+  "operation": "addSubtitle",
+  "fontSource": "system",
+  "systemFontPath": "/System/Library/Fonts/AppleSDGothicNeo.ttc",
+  "size": 48,
+  "color": "white"
+}
+```
+
 ### Merge 노드와 함께 사용하기 (v1.4.0 신규)
 n8n의 Merge 노드를 사용하여 여러 비디오 입력을 결합할 때:
 

package/README.md

@@ -10,6 +10,20 @@ This is a custom n8n node for comprehensive, local media processing using FFmpeg
 
 ## 🆕 What's New in This Fork
 
+### v1.6.15
+**New Features**
+
+- **🔍 Get Metadata (Probe)**: Extract comprehensive metadata from video/audio files
+  - Format info: filename, format, duration, size, bitrate
+  - Video stream: codec, resolution, frame rate, aspect ratio, pixel format
+  - Audio stream: codec, sample rate, channels, channel layout
+  - Tags: title, artist, album, and other embedded metadata
+
+- **🔤 System Font Support**: Use fonts installed on your system
+  - Scan system fonts with Font > List operation (enable "Include System Fonts")
+  - Directly specify system font path in Text/Subtitle operations
+  - Supports macOS, Linux, and Windows system font directories
+
 ### v1.6.14
 **Subtitle Enhancements (v1.6.1 ~ v1.6.14)**
 
@@ -98,6 +112,11 @@ RUN cd /home/node/.n8n/nodes && npm install @lee-jisoo/n8n-nodes-mediafx
 | **Add String** | Burn text overlay with styling |
 | **Add Subtitle** | Add subtitles from SRT file ⭐ FIXED |
 
+### Probe Operations
+| Operation | Description |
+|-----------|-------------|
+| **Get Metadata** | Extract metadata from video/audio files (format, streams, tags) |
+
 ### Font Operations
 | Operation | Description |
 |-----------|-------------|
@@ -107,7 +126,75 @@ RUN cd /home/node/.n8n/nodes && npm install @lee-jisoo/n8n-nodes-mediafx
 
 ## Usage Examples
 
-### Speed Adjustment (New!)
+### Get Media Metadata (New!)
+Extract metadata from video or audio files:
+```json
+{
+  "resource": "probe",
+  "operation": "getMetadata",
+  "probeSource": {
+    "source": { "sourceType": "binary", "binaryProperty": "data" }
+  }
+}
+```
+
+Example output:
+```json
+{
+  "success": true,
+  "operation": "getMetadata",
+  "format": {
+    "filename": "video.mp4",
+    "formatName": "mov,mp4,m4a,3gp,3g2,mj2",
+    "duration": 120.5,
+    "size": 15728640,
+    "bitRate": 1048576
+  },
+  "video": {
+    "codec": "h264",
+    "width": 1920,
+    "height": 1080,
+    "frameRate": 30,
+    "aspectRatio": "16:9"
+  },
+  "audio": {
+    "codec": "aac",
+    "sampleRate": 48000,
+    "channels": 2,
+    "channelLayout": "stereo"
+  },
+  "hasVideo": true,
+  "hasAudio": true
+}
+```
+
+### Using System Fonts (New!)
+
+First, list available system fonts:
+```json
+{
+  "resource": "font",
+  "operation": "list",
+  "filterOptions": {
+    "includeSystemFonts": true,
+    "fontType": "system"
+  }
+}
+```
+
+Add subtitles with a system font:
+```json
+{
+  "resource": "subtitle",
+  "operation": "addSubtitle",
+  "fontSource": "system",
+  "systemFontPath": "/System/Library/Fonts/Helvetica.ttc",
+  "size": 48,
+  "color": "white"
+}
+```
+
+### Speed Adjustment
 Create a 2x speed video:
 ```json
 {

package/dist/nodes/MediaFX/MediaFX.node.js

@@ -33,6 +33,7 @@ const operations_1 = require("./operations");
 const audio_properties_1 = require("./properties/audio.properties");
 const font_properties_1 = require("./properties/font.properties");
 const image_properties_1 = require("./properties/image.properties");
+const probe_properties_1 = require("./properties/probe.properties");
 const resources_properties_1 = require("./properties/resources.properties");
 const subtitle_properties_1 = require("./properties/subtitle.properties");
 const video_properties_1 = require("./properties/video.properties");
@@ -59,6 +60,7 @@ class MediaFX {
                 ...audio_properties_1.audioProperties,
                 ...subtitle_properties_1.subtitleProperties,
                 ...image_properties_1.imageProperties,
+                ...probe_properties_1.probeProperties,
                 ...font_properties_1.fontProperties,
             ],
         };
@@ -126,6 +128,7 @@ class MediaFX {
         };
     }
     async execute() {
+        var _a;
         const items = this.getInputData();
         const returnData = [];
         // Periodically clean up old temporary files (every 10th execution)
@@ -150,7 +153,8 @@ class MediaFX {
                         case 'list': {
                             const filterOptions = this.getNodeParameter('filterOptions', i, {});
                             const fontTypeFilter = filterOptions.fontType || 'all';
-                            const allFonts = (0, utils_1.getAvailableFonts)();
+                            const includeSystemFonts = (_a = filterOptions.includeSystemFonts) !== null && _a !== void 0 ? _a : false;
+                            const allFonts = (0, utils_1.getAvailableFonts)(includeSystemFonts);
                             if (fontTypeFilter === 'all') {
                                 resultData = allFonts;
                             }
@@ -196,6 +200,34 @@ class MediaFX {
                     }
                 }
                 // ===================================
+                // PROBE RESOURCE OPERATIONS
+                // ===================================
+                else if (resource === 'probe') {
+                    switch (operation) {
+                        case 'getMetadata': {
+                            const sourceParam = this.getNodeParameter('probeSource', i, {});
+                            if (!sourceParam.source) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Media source is required. Please add a media source.', { itemIndex: i });
+                            }
+                            const { paths, cleanup: c } = await (0, utils_1.resolveInputs)(this, i, [sourceParam.source]);
+                            cleanup = c;
+                            const metadata = await operations_1.executeGetMetadata.call(this, paths[0], i);
+                            // Push result with metadata as JSON
+                            returnData.push({
+                                json: {
+                                    success: true,
+                                    operation: 'getMetadata',
+                                    ...metadata,
+                                },
+                                pairedItem: { item: i },
+                            });
+                            // Cleanup and continue to next item
+                            await cleanup();
+                            continue;
+                        }
+                    }
+                }
+                // ===================================
                 // MEDIA RESOURCE OPERATIONS
                 // ===================================
                 else {
@@ -304,8 +336,11 @@ class MediaFX {
                                 await subFileCleanup();
                             };
                             // Collect style options from individual parameters
+                            const fontSource = this.getNodeParameter('fontSource', i, 'bundled');
                             const style = {
-                                fontKey: this.getNodeParameter('fontKey', i, 'noto-sans-kr'),
+                                fontSource,
+                                fontKey: fontSource === 'bundled' ? this.getNodeParameter('fontKey', i, 'noto-sans-kr') : undefined,
+                                systemFontPath: fontSource === 'system' ? this.getNodeParameter('systemFontPath', i, '') : undefined,
                                 size: this.getNodeParameter('size', i, 48),
                                 color: this.getNodeParameter('color', i, 'white'),
                                 outlineWidth: this.getNodeParameter('outlineWidth', i, 1),
@@ -333,8 +368,11 @@ class MediaFX {
                             const startTime = this.getNodeParameter('startTime', i, 0);
                             const endTime = this.getNodeParameter('endTime', i, 5);
                             // Collect style options from individual parameters
+                            const textFontSource = this.getNodeParameter('fontSource', i, 'bundled');
                             const textOptions = {
-                                fontKey: this.getNodeParameter('fontKey', i, 'noto-sans-kr'),
+                                fontSource: textFontSource,
+                                fontKey: textFontSource === 'bundled' ? this.getNodeParameter('fontKey', i, 'noto-sans-kr') : undefined,
+                                systemFontPath: textFontSource === 'system' ? this.getNodeParameter('systemFontPath', i, '') : undefined,
                                 size: this.getNodeParameter('size', i, 48),
                                 color: this.getNodeParameter('color', i, 'white'),
                                 outlineWidth: this.getNodeParameter('outlineWidth', i, 1),

package/dist/nodes/MediaFX/operations/addSubtitle.js

@@ -190,12 +190,26 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
 async function executeAddSubtitle(video, subtitleFile, style, itemIndex) {
     var _a, _b, _c, _d, _e;
     const outputPath = (0, utils_1.getTempFile)(path.extname(video));
-    // 1. Get Font
-    const allFonts = (0, utils_1.getAvailableFonts)();
-    const fontKey = style.fontKey || 'noto-sans-kr';
-    const font = allFonts[fontKey];
-    if (!font || !font.path) {
-        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Selected font key '${fontKey}' is not valid or its file path is missing.`, { itemIndex });
+    // 1. Get Font (support both bundled and system fonts)
+    const fontSource = style.fontSource || 'bundled';
+    let font = null;
+    if (fontSource === 'system') {
+        const systemFontPath = style.systemFontPath;
+        if (!systemFontPath) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'System font path is required when using system fonts.', { itemIndex });
+        }
+        font = (0, utils_1.getFontByPath)(systemFontPath);
+        if (!font) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `System font not found at path '${systemFontPath}'. Please check the path and ensure it's a valid font file (TTF, OTF, TTC).`, { itemIndex });
+        }
+    }
+    else {
+        const allFonts = (0, utils_1.getAvailableFonts)();
+        const fontKey = style.fontKey || 'noto-sans-kr';
+        font = allFonts[fontKey] || null;
+        if (!font || !font.path) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Selected font key '${fontKey}' is not valid or its file path is missing.`, { itemIndex });
+        }
     }
     const fontName = font.name || 'Sans';
     const fontSize = style.size || 48;

package/dist/nodes/MediaFX/operations/addText.js

@@ -62,11 +62,26 @@ function getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, padd
 }
 async function executeAddText(video, text, options, itemIndex) {
     var _a, _b, _c, _d;
-    const allFonts = (0, utils_1.getAvailableFonts)();
-    const fontKey = options.fontKey || 'noto-sans-kr';
-    const font = allFonts[fontKey];
-    if (!font || !font.path) {
-        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Selected font key '${fontKey}' is not valid or its file path is missing.`, { itemIndex });
+    // Support both bundled and system fonts
+    const fontSource = options.fontSource || 'bundled';
+    let font = null;
+    if (fontSource === 'system') {
+        const systemFontPath = options.systemFontPath;
+        if (!systemFontPath) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'System font path is required when using system fonts.', { itemIndex });
+        }
+        font = (0, utils_1.getFontByPath)(systemFontPath);
+        if (!font) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `System font not found at path '${systemFontPath}'. Please check the path and ensure it's a valid font file (TTF, OTF, TTC).`, { itemIndex });
+        }
+    }
+    else {
+        const allFonts = (0, utils_1.getAvailableFonts)();
+        const fontKey = options.fontKey || 'noto-sans-kr';
+        font = allFonts[fontKey] || null;
+        if (!font || !font.path) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Selected font key '${fontKey}' is not valid or its file path is missing.`, { itemIndex });
+        }
     }
     const fontPath = font.path;
     // Set default values for text options

package/dist/nodes/MediaFX/operations/getMetadata.d.ts

@@ -0,0 +1,41 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+import { IDataObject } from 'n8n-workflow';
+interface StreamInfo {
+    index: number;
+    type: string;
+    codec: string;
+    codecLongName?: string;
+    profile?: string;
+    width?: number;
+    height?: number;
+    aspectRatio?: string;
+    frameRate?: number;
+    bitRate?: number;
+    pixelFormat?: string;
+    sampleRate?: number;
+    channels?: number;
+    channelLayout?: string;
+    bitsPerSample?: number;
+    duration?: number;
+    language?: string;
+    title?: string;
+}
+interface MediaMetadata {
+    format: {
+        filename: string;
+        formatName: string;
+        formatLongName?: string;
+        duration: number;
+        size: number;
+        bitRate: number;
+        probeScore?: number;
+    };
+    streams: StreamInfo[];
+    video?: StreamInfo;
+    audio?: StreamInfo;
+    hasVideo: boolean;
+    hasAudio: boolean;
+    tags?: IDataObject;
+}
+export declare function executeGetMetadata(this: IExecuteFunctions, inputPath: string, _itemIndex: number): Promise<MediaMetadata>;
+export {};

package/dist/nodes/MediaFX/operations/getMetadata.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeGetMetadata = void 0;
+const ffmpeg = require("fluent-ffmpeg");
+async function executeGetMetadata(inputPath, _itemIndex) {
+    return new Promise((resolve, reject) => {
+        ffmpeg.ffprobe(inputPath, (err, metadata) => {
+            if (err) {
+                return reject(new Error(`Failed to probe media file: ${err.message}`));
+            }
+            const streams = [];
+            let videoStream;
+            let audioStream;
+            for (const stream of metadata.streams) {
+                const streamInfo = {
+                    index: stream.index,
+                    type: stream.codec_type || 'unknown',
+                    codec: stream.codec_name || 'unknown',
+                    codecLongName: stream.codec_long_name,
+                    profile: stream.profile !== undefined ? String(stream.profile) : undefined,
+                };
+                if (stream.codec_type === 'video') {
+                    streamInfo.width = stream.width;
+                    streamInfo.height = stream.height;
+                    streamInfo.aspectRatio = stream.display_aspect_ratio;
+                    streamInfo.pixelFormat = stream.pix_fmt;
+                    // Calculate frame rate from r_frame_rate (e.g., "30000/1001" or "30/1")
+                    if (stream.r_frame_rate) {
+                        const parts = stream.r_frame_rate.split('/');
+                        if (parts.length === 2) {
+                            const num = parseFloat(parts[0]);
+                            const den = parseFloat(parts[1]);
+                            if (den !== 0) {
+                                streamInfo.frameRate = Math.round((num / den) * 100) / 100;
+                            }
+                        }
+                    }
+                    if (stream.bit_rate) {
+                        streamInfo.bitRate = parseInt(stream.bit_rate, 10);
+                    }
+                    if (stream.duration) {
+                        streamInfo.duration = parseFloat(stream.duration);
+                    }
+                    // Extract tags
+                    if (stream.tags) {
+                        streamInfo.language = stream.tags.language;
+                        streamInfo.title = stream.tags.title;
+                    }
+                    if (!videoStream) {
+                        videoStream = streamInfo;
+                    }
+                }
+                else if (stream.codec_type === 'audio') {
+                    streamInfo.sampleRate = stream.sample_rate ? parseInt(String(stream.sample_rate), 10) : undefined;
+                    streamInfo.channels = stream.channels;
+                    streamInfo.channelLayout = stream.channel_layout;
+                    streamInfo.bitsPerSample = stream.bits_per_sample;
+                    if (stream.bit_rate) {
+                        streamInfo.bitRate = parseInt(stream.bit_rate, 10);
+                    }
+                    if (stream.duration) {
+                        streamInfo.duration = parseFloat(stream.duration);
+                    }
+                    // Extract tags
+                    if (stream.tags) {
+                        streamInfo.language = stream.tags.language;
+                        streamInfo.title = stream.tags.title;
+                    }
+                    if (!audioStream) {
+                        audioStream = streamInfo;
+                    }
+                }
+                streams.push(streamInfo);
+            }
+            const format = metadata.format;
+            const result = {
+                format: {
+                    filename: format.filename || inputPath,
+                    formatName: format.format_name || 'unknown',
+                    formatLongName: format.format_long_name,
+                    duration: format.duration || 0,
+                    size: format.size || 0,
+                    bitRate: format.bit_rate ? parseInt(String(format.bit_rate), 10) : 0,
+                    probeScore: format.probe_score,
+                },
+                streams,
+                hasVideo: !!videoStream,
+                hasAudio: !!audioStream,
+            };
+            if (videoStream) {
+                result.video = videoStream;
+            }
+            if (audioStream) {
+                result.audio = audioStream;
+            }
+            // Extract format tags (metadata like title, artist, album, etc.)
+            if (format.tags) {
+                result.tags = format.tags;
+            }
+            resolve(result);
+        });
+    });
+}
+exports.executeGetMetadata = executeGetMetadata;

package/dist/nodes/MediaFX/operations/index.d.ts

@@ -11,3 +11,4 @@ export * from './singleVideoFade';
 export * from './imageToVideo';
 export * from './stampImage';
 export * from './overlayVideo';
+export * from './getMetadata';

package/dist/nodes/MediaFX/operations/index.js

@@ -27,3 +27,4 @@ __exportStar(require("./singleVideoFade"), exports);
 __exportStar(require("./imageToVideo"), exports);
 __exportStar(require("./stampImage"), exports);
 __exportStar(require("./overlayVideo"), exports);
+__exportStar(require("./getMetadata"), exports);

package/dist/nodes/MediaFX/properties/font.properties.js

@@ -160,6 +160,13 @@ exports.fontProperties = [
         },
         default: {},
         options: [
+            {
+                displayName: 'Include System Fonts',
+                name: 'includeSystemFonts',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to include fonts installed on the system (may be slow on first scan)',
+            },
             {
                 displayName: 'Font Type',
                 name: 'fontType',
@@ -169,6 +176,7 @@ exports.fontProperties = [
                     { name: 'Korean Fonts', value: 'korean' },
                     { name: 'Global Fonts', value: 'global' },
                     { name: 'User Fonts', value: 'user' },
+                    { name: 'System Fonts', value: 'system' },
                     { name: 'Fallback Fonts', value: 'fallback' },
                 ],
                 default: 'all',

package/dist/nodes/MediaFX/properties/probe.properties.d.ts

@@ -0,0 +1,2 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const probeProperties: INodeProperties[];

package/dist/nodes/MediaFX/properties/probe.properties.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeProperties = void 0;
+exports.probeProperties = [
+    // Probe Operations
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['probe'],
+            },
+        },
+        options: [
+            {
+                name: 'Get Metadata',
+                value: 'getMetadata',
+                description: 'Extract metadata information from video or audio files',
+            },
+        ],
+        default: 'getMetadata',
+    },
+    // ===================
+    // GET METADATA FIELDS
+    // ===================
+    {
+        displayName: 'Media Source',
+        name: 'probeSource',
+        type: 'fixedCollection',
+        placeholder: 'Add Media Source',
+        displayOptions: {
+            show: {
+                resource: ['probe'],
+                operation: ['getMetadata'],
+            },
+        },
+        default: {},
+        options: [
+            {
+                displayName: 'Source',
+                name: 'source',
+                values: [
+                    {
+                        displayName: 'Source Type',
+                        name: 'sourceType',
+                        type: 'options',
+                        options: [
+                            {
+                                name: 'URL',
+                                value: 'url',
+                            },
+                            {
+                                name: 'Binary Data from Previous Node',
+                                value: 'binary',
+                            },
+                        ],
+                        default: 'url',
+                    },
+                    {
+                        displayName: 'Value',
+                        name: 'value',
+                        type: 'string',
+                        default: '',
+                        placeholder: 'https://example.com/video.mp4 or https://example.com/audio.mp3',
+                        description: 'URL of the media file to analyze',
+                        displayOptions: { show: { sourceType: ['url'] } },
+                    },
+                    {
+                        displayName: 'Binary Property',
+                        name: 'binaryProperty',
+                        type: 'string',
+                        default: 'data',
+                        description: 'Name of the binary property from the previous node',
+                        placeholder: 'e.g., data',
+                        displayOptions: { show: { sourceType: ['binary'] } },
+                    },
+                ],
+            },
+        ],
+        description: 'The media file (video or audio) to analyze',
+    },
+];

package/dist/nodes/MediaFX/properties/resources.properties.js

@@ -24,6 +24,11 @@ exports.resourceSelection = [
                 name: 'Image',
                 value: 'image',
             },
+            {
+                name: 'Probe',
+                value: 'probe',
+                description: 'Analyze media files and extract metadata information',
+            },
             {
                 name: 'Font',
                 value: 'font',

package/dist/nodes/MediaFX/properties/subtitle.properties.js

@@ -129,6 +129,22 @@ exports.subtitleProperties = [
     // ===================
     // COMMON FONT & STYLE OPTIONS
     // ===================
+    {
+        displayName: 'Font Source',
+        name: 'fontSource',
+        type: 'options',
+        options: [
+            { name: 'Bundled/Uploaded Fonts', value: 'bundled', description: 'Use fonts bundled with MediaFX or uploaded by user' },
+            { name: 'System Font Path', value: 'system', description: 'Specify path to a system font file' },
+        ],
+        default: 'bundled',
+        displayOptions: {
+            show: {
+                resource: ['subtitle'],
+            },
+        },
+        description: 'Choose font source type',
+    },
     {
         displayName: 'Font Key',
         name: 'fontKey',
@@ -138,10 +154,25 @@ exports.subtitleProperties = [
         displayOptions: {
             show: {
                 resource: ['subtitle'],
+                fontSource: ['bundled'],
             },
         },
         description: 'Font to use for the text',
     },
+    {
+        displayName: 'System Font Path',
+        name: 'systemFontPath',
+        type: 'string',
+        default: '',
+        placeholder: '/System/Library/Fonts/AppleSDGothicNeo.ttc',
+        displayOptions: {
+            show: {
+                resource: ['subtitle'],
+                fontSource: ['system'],
+            },
+        },
+        description: 'Full path to system font file (TTF, OTF, TTC). Use Font > List operation with "Include System Fonts" to find available fonts.',
+    },
     {
         displayName: 'Font Size',
         name: 'size',

package/dist/nodes/MediaFX/utils.d.ts

@@ -31,8 +31,10 @@ export declare function runFfmpeg(command: ffmpeg.FfmpegCommand): Promise<void>;
 export declare function getVideoStreamInfo(filePath: string): Promise<ffmpeg.FfprobeStream | undefined>;
 export declare function fileHasAudio(filePath: string): Promise<boolean>;
 export declare const REGISTERED_FONTS: IDataObject;
+export declare function getSystemFonts(): IDataObject;
 export declare function getUserFonts(): IDataObject;
-export declare function getAvailableFonts(): IDataObject;
+export declare function getAvailableFonts(includeSystemFonts?: boolean): IDataObject;
+export declare function getFontByPath(fontPath: string): IDataObject | null;
 export declare function validateFontKey(fontKey: string): void;
 export declare function saveUserFont(fontKey: string, fontName: string, description: string, originalFilename: string, buffer: Buffer): {
     fontKey: string;

package/dist/nodes/MediaFX/utils.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkTransitionSupport = exports.getFFmpegCapabilities = exports.deleteUserFont = exports.saveUserFont = exports.validateFontKey = exports.getAvailableFonts = exports.getUserFonts = exports.REGISTERED_FONTS = exports.fileHasAudio = exports.getVideoStreamInfo = exports.runFfmpeg = exports.createSilentAudio = exports.getDuration = exports.resolveInputs = exports.createTempFileFromBuffer = exports.downloadSource = exports.cleanupOldTempFiles = exports.getTempFile = exports.verifyFfmpegAvailability = void 0;
+exports.checkTransitionSupport = exports.getFFmpegCapabilities = exports.deleteUserFont = exports.saveUserFont = exports.validateFontKey = exports.getFontByPath = exports.getAvailableFonts = exports.getUserFonts = exports.getSystemFonts = exports.REGISTERED_FONTS = exports.fileHasAudio = exports.getVideoStreamInfo = exports.runFfmpeg = exports.createSilentAudio = exports.getDuration = exports.resolveInputs = exports.createTempFileFromBuffer = exports.downloadSource = exports.cleanupOldTempFiles = exports.getTempFile = exports.verifyFfmpegAvailability = void 0;
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 const uuid_1 = require("uuid");
@@ -308,6 +308,28 @@ exports.fileHasAudio = fileHasAudio;
 const BASE_FONTS_DIR = path.resolve(__dirname, '..', '..', 'fonts');
 const USER_FONTS_DIR = path.join(BASE_FONTS_DIR, 'user');
 const USER_FONTS_JSON = path.join(USER_FONTS_DIR, 'user-fonts.json');
+// System font directories by platform
+const SYSTEM_FONT_DIRS = {
+    darwin: [
+        '/System/Library/Fonts',
+        '/Library/Fonts',
+        path.join(os.homedir(), 'Library/Fonts'),
+    ],
+    linux: [
+        '/usr/share/fonts',
+        '/usr/local/share/fonts',
+        path.join(os.homedir(), '.fonts'),
+        path.join(os.homedir(), '.local/share/fonts'),
+    ],
+    win32: [
+        'C:\\Windows\\Fonts',
+        path.join(os.homedir(), 'AppData\\Local\\Microsoft\\Windows\\Fonts'),
+    ],
+};
+// Cache for system fonts (to avoid repeated filesystem scans)
+let systemFontsCache = null;
+let systemFontsCacheTime = 0;
+const SYSTEM_FONTS_CACHE_TTL = 60 * 60 * 1000; // 1 hour cache
 // System-registered fonts (must exist in BASE_FONTS_DIR)
 exports.REGISTERED_FONTS = {
     'noto-sans-kr': { name: 'Noto Sans KR', filename: 'NotoSansKR-Regular.ttf', description: 'Google Noto Sans KR', type: 'korean' },
@@ -317,6 +339,62 @@ exports.REGISTERED_FONTS = {
     'inter': { name: 'Inter', filename: 'Inter-Regular.ttf', description: 'Inter UI Font', type: 'global' },
     'dejavu-sans': { name: 'DejaVu Sans', filename: 'DejaVuSans.ttf', description: 'Default fallback font', type: 'fallback' },
 };
+// Scan a directory for font files
+function scanFontDirectory(dir, fonts) {
+    if (!fs.existsSync(dir))
+        return;
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Recursively scan subdirectories
+                scanFontDirectory(fullPath, fonts);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (ext === '.ttf' || ext === '.otf' || ext === '.ttc' || ext === '.otc') {
+                    // Generate a unique key from the filename
+                    const baseName = path.basename(entry.name, ext);
+                    const fontKey = `system-${baseName.toLowerCase().replace(/[^a-z0-9]/g, '-')}`;
+                    // Skip if already exists (avoid duplicates)
+                    if (!fonts[fontKey]) {
+                        fonts[fontKey] = {
+                            name: baseName,
+                            filename: entry.name,
+                            path: fullPath,
+                            description: `System font from ${dir}`,
+                            type: 'system',
+                        };
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Ignore permission errors for system directories
+        console.warn(`Could not scan font directory ${dir}:`, error.message);
+    }
+}
+// Get system fonts with caching
+function getSystemFonts() {
+    const now = Date.now();
+    // Return cached result if still valid
+    if (systemFontsCache && (now - systemFontsCacheTime) < SYSTEM_FONTS_CACHE_TTL) {
+        return systemFontsCache;
+    }
+    const fonts = {};
+    const platform = os.platform();
+    const fontDirs = SYSTEM_FONT_DIRS[platform] || [];
+    for (const dir of fontDirs) {
+        scanFontDirectory(dir, fonts);
+    }
+    // Update cache
+    systemFontsCache = fonts;
+    systemFontsCacheTime = now;
+    return fonts;
+}
+exports.getSystemFonts = getSystemFonts;
 // Helper functions for font management
 function ensureUserFontsDirectory() {
     if (!fs.existsSync(USER_FONTS_DIR)) {
@@ -341,13 +419,13 @@ function saveUserFonts(userFonts) {
     ensureUserFontsDirectory();
     fs.writeFileSync(USER_FONTS_JSON, JSON.stringify(userFonts, null, 2));
 }
-function getAvailableFonts() {
+function getAvailableFonts(includeSystemFonts = false) {
     const fonts = {};
-    // Add registered fonts
+    // Add registered fonts (bundled with the package)
     for (const [key, font] of Object.entries(exports.REGISTERED_FONTS)) {
         const fontPath = path.join(BASE_FONTS_DIR, font.filename);
         if (fs.existsSync(fontPath)) {
-            fonts[key] = { ...font, path: fontPath, type: font.type || 'system' };
+            fonts[key] = { ...font, path: fontPath, type: font.type || 'bundled' };
         }
     }
     // Add user fonts
@@ -358,9 +436,38 @@ function getAvailableFonts() {
             fonts[key] = { ...font, path: fontPath, type: 'user' };
         }
     }
+    // Add system fonts if requested
+    if (includeSystemFonts) {
+        const systemFonts = getSystemFonts();
+        for (const [key, font] of Object.entries(systemFonts)) {
+            // Don't override bundled or user fonts with system fonts
+            if (!fonts[key]) {
+                fonts[key] = font;
+            }
+        }
+    }
     return fonts;
 }
 exports.getAvailableFonts = getAvailableFonts;
+// Get font info by path (for system fonts specified by path)
+function getFontByPath(fontPath) {
+    if (!fs.existsSync(fontPath)) {
+        return null;
+    }
+    const ext = path.extname(fontPath).toLowerCase();
+    if (ext !== '.ttf' && ext !== '.otf' && ext !== '.ttc' && ext !== '.otc') {
+        return null;
+    }
+    const baseName = path.basename(fontPath, ext);
+    return {
+        name: baseName,
+        filename: path.basename(fontPath),
+        path: fontPath,
+        description: 'System font',
+        type: 'system',
+    };
+}
+exports.getFontByPath = getFontByPath;
 function validateFontKey(fontKey) {
     const keyPattern = /^[a-zA-Z0-9_-]{3,50}$/;
     if (!keyPattern.test(fontKey)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lee-jisoo/n8n-nodes-mediafx",
-  "version": "1.6.14",
+  "version": "1.6.16",
   "description": "N8N custom nodes for video editing and media processing (Enhanced fork with Speed control and Subtitle fixes)",
   "license": "MIT",
   "author": {
@@ -27,7 +27,8 @@
   },
   "files": [
     "dist",
-    "fonts"
+    "fonts",
+    "README.md"
   ],
   "n8n": {
     "n8nNodesApiVersion": 1,