@beltar/n8n-nodes-extract-archive 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Beltar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,162 @@
+# n8n-nodes-extract-archive
+
+Extract ZIP and RAR archive files in n8n.
+
+## Features
+
+- **ZIP and RAR support** with auto-detection
+- **Binary data or file path input** - use files from previous nodes or server paths
+- **Password-protected archives** support
+- **File filtering** - extract only specific file types
+- **Subdirectory handling** - include or exclude nested folders
+- **Flexible output** - single item with all files or one item per file
+
+## Requirements
+
+This node requires extraction tools to be installed on your system.
+
+### Docker (n8n image)
+
+```dockerfile
+FROM n8nio/n8n:latest
+
+USER root
+
+# For ZIP support
+RUN apk add --no-cache unzip
+
+# For RAR support (option 1: p7zip)
+RUN apk add --no-cache p7zip
+
+# For RAR support (option 2: unrar from EDM115)
+RUN apk add --no-cache curl jq libstdc++ libgcc && \
+    curl -LsSf https://api.github.com/repos/EDM115/unrar-alpine/releases/latest \
+    | jq -r '.assets[] | select(.name == "unrar") | .id' \
+    | xargs -I {} curl -LsSf https://api.github.com/repos/EDM115/unrar-alpine/releases/assets/{} \
+    | jq -r '.browser_download_url' \
+    | xargs -I {} curl -Lsf {} -o /tmp/unrar && \
+    install -v -m755 /tmp/unrar /usr/local/bin && \
+    rm /tmp/unrar
+
+USER node
+```
+
+### Complete Docker example with this node
+
+```dockerfile
+FROM n8nio/n8n:latest
+
+USER root
+
+RUN apk add --no-cache unzip p7zip poppler-utils
+
+RUN mkdir -p /opt/n8n-nodes && chown node:node /opt/n8n-nodes
+
+USER node
+
+RUN cd /opt/n8n-nodes && \
+    npm init -y && \
+    npm install @beltar/n8n-nodes-extract-archive @beltar/n8n-nodes-pdf-to-image
+
+ENV N8N_CUSTOM_EXTENSIONS=/opt/n8n-nodes/node_modules
+```
+
+### Debian/Ubuntu
+
+```bash
+sudo apt-get install unzip unrar
+```
+
+### Alpine Linux
+
+```bash
+apk add unzip p7zip
+```
+
+### macOS
+
+```bash
+brew install unzip unrar
+```
+
+## Installation
+
+### In n8n
+
+1. Go to **Settings** → **Community Nodes**
+2. Enter `@beltar/n8n-nodes-extract-archive`
+3. Click **Install**
+4. Restart n8n
+
+### Manual installation
+
+```bash
+cd ~/.n8n
+npm install @beltar/n8n-nodes-extract-archive
+```
+
+## Usage
+
+1. Add the **Extract Archive** node to your workflow
+2. Connect a node that provides an archive file (binary data or file path)
+3. Configure the options:
+   - **Input Mode**: Binary Data or File Path
+   - **Input Binary Field**: Name of the binary property (for binary mode)
+   - **File Path**: Path to archive on server (for file path mode)
+   - **Archive Type**: Auto-detect, ZIP, or RAR
+   - **Password**: For encrypted archives (optional)
+   - **Output Mode**: Single item with all files, or one item per file
+   - **Output Binary Field**: Name for the output binary property
+   - **Include Subdirectories**: Whether to include nested files
+   - **File Filter**: Comma-separated patterns (e.g., `*.txt, *.pdf`)
+
+## Output
+
+### Single Item Mode
+
+Returns one item with:
+- `json.totalFiles`: Number of files extracted
+- `json.archiveType`: Type of archive (zip/rar)
+- `json.files`: Array of file info objects
+- `json.binaryProperties`: Array of binary property names
+- `binary.file_1`, `binary.file_2`, etc.: The extracted files
+
+### Multiple Items Mode
+
+Returns one item per file with:
+- `json.index`: File index
+- `json.totalFiles`: Total number of files
+- `json.fileName`: Name of the file
+- `json.filePath`: Relative path within archive
+- `json.fileSize`: Size in bytes
+- `json.archiveType`: Type of archive
+- `binary.file`: The extracted file
+
+## Example Workflows
+
+### Extract and process each file
+```
+[HTTP Request: Download ZIP] → [Extract Archive] → [For Each File: Process]
+```
+
+### Extract specific file types
+```
+[Read Binary File] → [Extract Archive (filter: *.pdf)] → [PDF to Image]
+```
+
+### Extract from server path
+```
+[Set file path] → [Extract Archive (file path mode)] → [Upload to S3]
+```
+
+## License
+
+MIT
+
+## Author
+
+Beltar
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { ExtractArchive } from './nodes/ExtractArchive/ExtractArchive.node';
+export { ExtractArchive };

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractArchive = void 0;
+const ExtractArchive_node_1 = require("./nodes/ExtractArchive/ExtractArchive.node");
+Object.defineProperty(exports, "ExtractArchive", { enumerable: true, get: function () { return ExtractArchive_node_1.ExtractArchive; } });

package/dist/nodes/ExtractArchive/ExtractArchive.node.d.ts

@@ -0,0 +1,12 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class ExtractArchive implements INodeType {
+    description: INodeTypeDescription;
+    private detectArchiveType;
+    private checkToolAvailable;
+    private extractZip;
+    private extractRar;
+    private getAllFiles;
+    private matchesFilter;
+    private getMimeType;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/ExtractArchive/ExtractArchive.node.js

@@ -0,0 +1,472 @@
+"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.ExtractArchive = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class ExtractArchive {
+    constructor() {
+        this.description = {
+            displayName: 'Extract Archive',
+            name: 'extractArchive',
+            icon: 'file:extractarchive.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["inputMode"]}} - {{$parameter["archiveType"]}}',
+            description: 'Extract ZIP and RAR archive files',
+            defaults: {
+                name: 'Extract Archive',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Input Mode',
+                    name: 'inputMode',
+                    type: 'options',
+                    options: [
+                        { name: 'Binary Data', value: 'binary', description: 'Use binary data from previous node' },
+                        { name: 'File Path', value: 'filePath', description: 'Use a file path on the server' },
+                    ],
+                    default: 'binary',
+                    description: 'How to get the archive file',
+                },
+                {
+                    displayName: 'Input Binary Field',
+                    name: 'binaryPropertyName',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    description: 'Name of the binary property containing the archive file',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['binary'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'File Path',
+                    name: 'filePath',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    placeholder: '/path/to/archive.zip',
+                    description: 'Path to the archive file on the server',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['filePath'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Archive Type',
+                    name: 'archiveType',
+                    type: 'options',
+                    options: [
+                        { name: 'Auto-Detect', value: 'auto', description: 'Detect type from file extension or content' },
+                        { name: 'ZIP', value: 'zip' },
+                        { name: 'RAR', value: 'rar' },
+                    ],
+                    default: 'auto',
+                    description: 'The type of archive to extract',
+                },
+                {
+                    displayName: 'Password',
+                    name: 'password',
+                    type: 'string',
+                    typeOptions: {
+                        password: true,
+                    },
+                    default: '',
+                    description: 'Password for encrypted archives (optional)',
+                },
+                {
+                    displayName: 'Output Mode',
+                    name: 'outputMode',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Single Item (All Files)',
+                            value: 'single',
+                            description: 'Return one item with all extracted files as separate binary properties'
+                        },
+                        {
+                            name: 'Multiple Items (One Per File)',
+                            value: 'multiple',
+                            description: 'Return separate items for each extracted file'
+                        },
+                    ],
+                    default: 'multiple',
+                    description: 'How to output the extracted files',
+                },
+                {
+                    displayName: 'Output Binary Field',
+                    name: 'outputBinaryPropertyName',
+                    type: 'string',
+                    default: 'file',
+                    required: true,
+                    description: 'Name of the binary property for output files. For single mode, files are named file_1, file_2, etc.',
+                },
+                {
+                    displayName: 'Include Subdirectories',
+                    name: 'includeSubdirectories',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to include files from subdirectories in the output',
+                },
+                {
+                    displayName: 'File Filter',
+                    name: 'fileFilter',
+                    type: 'string',
+                    default: '',
+                    placeholder: '*.txt, *.pdf',
+                    description: 'Comma-separated list of file patterns to extract (e.g., "*.txt, *.pdf"). Leave empty to extract all files.',
+                },
+            ],
+        };
+    }
+    detectArchiveType(filePath, mimeType) {
+        const ext = path.extname(filePath).toLowerCase();
+        // Check by extension first
+        if (ext === '.zip' || ext === '.zipx')
+            return 'zip';
+        if (ext === '.rar')
+            return 'rar';
+        // Check by MIME type
+        if (mimeType) {
+            if (mimeType.includes('zip'))
+                return 'zip';
+            if (mimeType.includes('rar'))
+                return 'rar';
+        }
+        // Try to detect by file content (magic bytes)
+        try {
+            const buffer = Buffer.alloc(8);
+            const fd = fs.openSync(filePath, 'r');
+            fs.readSync(fd, buffer, 0, 8, 0);
+            fs.closeSync(fd);
+            // ZIP magic bytes: PK (0x50 0x4B)
+            if (buffer[0] === 0x50 && buffer[1] === 0x4B)
+                return 'zip';
+            // RAR magic bytes: Rar! (0x52 0x61 0x72 0x21)
+            if (buffer[0] === 0x52 && buffer[1] === 0x61 && buffer[2] === 0x72 && buffer[3] === 0x21)
+                return 'rar';
+        }
+        catch {
+            // Ignore detection errors
+        }
+        // Default to zip
+        return 'zip';
+    }
+    checkToolAvailable(tool) {
+        try {
+            (0, child_process_1.execSync)(`which ${tool}`, { encoding: 'utf-8', stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async extractZip(archivePath, outputDir, password) {
+        if (!this.checkToolAvailable('unzip')) {
+            throw new Error('unzip is not installed. Please install it: apk add unzip (Alpine) or apt-get install unzip (Debian/Ubuntu)');
+        }
+        const args = ['-o', '-q']; // Overwrite, quiet
+        if (password) {
+            args.push('-P', password);
+        }
+        args.push(archivePath, '-d', outputDir);
+        const command = `unzip ${args.map(a => `"${a}"`).join(' ')}`;
+        await execAsync(command);
+    }
+    async extractRar(archivePath, outputDir, password) {
+        // Try unrar first, then 7z as fallback
+        const hasUnrar = this.checkToolAvailable('unrar');
+        const has7z = this.checkToolAvailable('7z');
+        if (!hasUnrar && !has7z) {
+            throw new Error('Neither unrar nor 7z is installed. Please install unrar or p7zip: apk add p7zip (Alpine) or apt-get install unrar (Debian/Ubuntu)');
+        }
+        if (hasUnrar) {
+            const args = ['x', '-o+', '-y']; // Extract with path, overwrite, assume yes
+            if (password) {
+                args.push(`-p${password}`);
+            }
+            else {
+                args.push('-p-'); // No password
+            }
+            args.push(archivePath, outputDir + '/');
+            const command = `unrar ${args.map(a => `"${a}"`).join(' ')}`;
+            await execAsync(command);
+        }
+        else {
+            // Use 7z
+            const args = ['x', '-y', `-o${outputDir}`];
+            if (password) {
+                args.push(`-p${password}`);
+            }
+            args.push(archivePath);
+            const command = `7z ${args.map(a => `"${a}"`).join(' ')}`;
+            await execAsync(command);
+        }
+    }
+    getAllFiles(dir, includeSubdirs) {
+        const files = [];
+        const readDir = (currentDir, relativePath = '') => {
+            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentDir, entry.name);
+                const relPath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+                if (entry.isDirectory()) {
+                    if (includeSubdirs) {
+                        readDir(fullPath, relPath);
+                    }
+                }
+                else if (entry.isFile()) {
+                    files.push(relPath);
+                }
+            }
+        };
+        readDir(dir);
+        return files;
+    }
+    matchesFilter(fileName, filter) {
+        if (!filter.trim())
+            return true;
+        const patterns = filter.split(',').map(p => p.trim().toLowerCase());
+        const lowerFileName = fileName.toLowerCase();
+        for (const pattern of patterns) {
+            if (pattern.startsWith('*.')) {
+                // Extension match
+                const ext = pattern.slice(1); // Remove *
+                if (lowerFileName.endsWith(ext))
+                    return true;
+            }
+            else if (pattern.includes('*')) {
+                // Simple wildcard match
+                const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+                if (regex.test(lowerFileName))
+                    return true;
+            }
+            else {
+                // Exact match
+                if (lowerFileName === pattern)
+                    return true;
+            }
+        }
+        return false;
+    }
+    getMimeType(fileName) {
+        const ext = path.extname(fileName).toLowerCase();
+        const mimeTypes = {
+            '.txt': 'text/plain',
+            '.html': 'text/html',
+            '.htm': 'text/html',
+            '.css': 'text/css',
+            '.js': 'application/javascript',
+            '.json': 'application/json',
+            '.xml': 'application/xml',
+            '.pdf': 'application/pdf',
+            '.doc': 'application/msword',
+            '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            '.xls': 'application/vnd.ms-excel',
+            '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            '.ppt': 'application/vnd.ms-powerpoint',
+            '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.svg': 'image/svg+xml',
+            '.webp': 'image/webp',
+            '.ico': 'image/x-icon',
+            '.mp3': 'audio/mpeg',
+            '.wav': 'audio/wav',
+            '.mp4': 'video/mp4',
+            '.webm': 'video/webm',
+            '.zip': 'application/zip',
+            '.rar': 'application/vnd.rar',
+            '.7z': 'application/x-7z-compressed',
+            '.tar': 'application/x-tar',
+            '.gz': 'application/gzip',
+        };
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const inputMode = this.getNodeParameter('inputMode', itemIndex);
+                const archiveTypeParam = this.getNodeParameter('archiveType', itemIndex);
+                const password = this.getNodeParameter('password', itemIndex);
+                const outputMode = this.getNodeParameter('outputMode', itemIndex);
+                const outputBinaryPropertyName = this.getNodeParameter('outputBinaryPropertyName', itemIndex);
+                const includeSubdirectories = this.getNodeParameter('includeSubdirectories', itemIndex);
+                const fileFilter = this.getNodeParameter('fileFilter', itemIndex);
+                const uniqueId = crypto.randomUUID();
+                const tmpDir = '/tmp';
+                const extractDir = path.join(tmpDir, `extract-${uniqueId}`);
+                let archivePath = '';
+                let shouldDeleteArchive = false;
+                let mimeType;
+                try {
+                    // Create extraction directory
+                    fs.mkdirSync(extractDir, { recursive: true });
+                    if (inputMode === 'binary') {
+                        const binaryPropertyName = this.getNodeParameter('binaryPropertyName', itemIndex);
+                        if (!items[itemIndex].binary?.[binaryPropertyName]) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No binary data found in property "${binaryPropertyName}"`, { itemIndex });
+                        }
+                        const binaryData = items[itemIndex].binary[binaryPropertyName];
+                        mimeType = binaryData.mimeType;
+                        const ext = binaryData.fileExtension || path.extname(binaryData.fileName || '');
+                        archivePath = path.join(tmpDir, `archive-${uniqueId}${ext}`);
+                        const buffer = await this.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
+                        fs.writeFileSync(archivePath, buffer);
+                        shouldDeleteArchive = true;
+                    }
+                    else {
+                        archivePath = this.getNodeParameter('filePath', itemIndex);
+                        if (!fs.existsSync(archivePath)) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `File not found: ${archivePath}`, { itemIndex });
+                        }
+                    }
+                    // Detect or use specified archive type
+                    const extractor = new ExtractArchive();
+                    const archiveType = archiveTypeParam === 'auto'
+                        ? extractor.detectArchiveType(archivePath, mimeType)
+                        : archiveTypeParam;
+                    // Extract the archive
+                    if (archiveType === 'zip') {
+                        await extractor.extractZip(archivePath, extractDir, password || undefined);
+                    }
+                    else if (archiveType === 'rar') {
+                        await extractor.extractRar(archivePath, extractDir, password || undefined);
+                    }
+                    // Get all extracted files
+                    let files = extractor.getAllFiles(extractDir, includeSubdirectories);
+                    // Apply file filter
+                    if (fileFilter.trim()) {
+                        files = files.filter(f => extractor.matchesFilter(path.basename(f), fileFilter));
+                    }
+                    if (files.length === 0) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No files were extracted. The archive might be empty or all files were filtered out.', { itemIndex });
+                    }
+                    if (outputMode === 'single') {
+                        const binary = {};
+                        const fileInfos = [];
+                        for (let i = 0; i < files.length; i++) {
+                            const relPath = files[i];
+                            const fullPath = path.join(extractDir, relPath);
+                            const fileBuffer = fs.readFileSync(fullPath);
+                            const fileName = path.basename(relPath);
+                            const propertyName = files.length === 1
+                                ? outputBinaryPropertyName
+                                : `${outputBinaryPropertyName}_${i + 1}`;
+                            binary[propertyName] = await this.helpers.prepareBinaryData(fileBuffer, fileName, extractor.getMimeType(fileName));
+                            fileInfos.push({
+                                name: fileName,
+                                path: relPath,
+                                size: fileBuffer.length,
+                            });
+                        }
+                        returnData.push({
+                            json: {
+                                totalFiles: files.length,
+                                archiveType,
+                                files: fileInfos,
+                                binaryProperties: files.map((_, i) => files.length === 1 ? outputBinaryPropertyName : `${outputBinaryPropertyName}_${i + 1}`),
+                            },
+                            binary,
+                        });
+                    }
+                    else {
+                        for (let i = 0; i < files.length; i++) {
+                            const relPath = files[i];
+                            const fullPath = path.join(extractDir, relPath);
+                            const fileBuffer = fs.readFileSync(fullPath);
+                            const fileName = path.basename(relPath);
+                            returnData.push({
+                                json: {
+                                    index: i + 1,
+                                    totalFiles: files.length,
+                                    fileName,
+                                    filePath: relPath,
+                                    fileSize: fileBuffer.length,
+                                    archiveType,
+                                },
+                                binary: {
+                                    [outputBinaryPropertyName]: await this.helpers.prepareBinaryData(fileBuffer, fileName, extractor.getMimeType(fileName)),
+                                },
+                            });
+                        }
+                    }
+                }
+                finally {
+                    // Cleanup
+                    try {
+                        if (shouldDeleteArchive && archivePath && fs.existsSync(archivePath)) {
+                            fs.unlinkSync(archivePath);
+                        }
+                        if (fs.existsSync(extractDir)) {
+                            fs.rmSync(extractDir, { recursive: true, force: true });
+                        }
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.ExtractArchive = ExtractArchive;

package/dist/nodes/ExtractArchive/extractarchive.svg

@@ -0,0 +1,26 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <!-- Archive/ZIP file -->
+  <rect x="4" y="8" width="28" height="36" rx="2" fill="#FF9800" stroke="#E65100" stroke-width="2"/>
+  <!-- Zipper pattern -->
+  <rect x="14" y="8" width="8" height="4" fill="#424242"/>
+  <rect x="14" y="14" width="8" height="4" fill="#424242"/>
+  <rect x="14" y="20" width="8" height="4" fill="#424242"/>
+  <rect x="14" y="26" width="8" height="4" fill="#424242"/>
+  <rect x="14" y="32" width="8" height="4" fill="#424242"/>
+  <rect x="14" y="38" width="8" height="4" fill="#E65100"/>
+
+  <!-- Arrow -->
+  <path d="M36 26 L44 26 L44 22 L52 28 L44 34 L44 30 L36 30 Z" fill="#4CAF50"/>
+
+  <!-- Extracted files -->
+  <rect x="40" y="12" width="20" height="14" rx="1" fill="#2196F3" stroke="#1565C0" stroke-width="1.5"/>
+  <line x1="44" y1="17" x2="56" y2="17" stroke="white" stroke-width="1.5"/>
+  <line x1="44" y1="21" x2="52" y2="21" stroke="white" stroke-width="1.5"/>
+
+  <rect x="44" y="32" width="18" height="14" rx="1" fill="#9C27B0" stroke="#6A1B9A" stroke-width="1.5"/>
+  <line x1="48" y1="37" x2="58" y2="37" stroke="white" stroke-width="1.5"/>
+  <line x1="48" y1="41" x2="54" y2="41" stroke="white" stroke-width="1.5"/>
+
+  <rect x="38" y="50" width="22" height="12" rx="1" fill="#4CAF50" stroke="#2E7D32" stroke-width="1.5"/>
+  <line x1="42" y1="55" x2="56" y2="55" stroke="white" stroke-width="1.5"/>
+</svg>

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@beltar/n8n-nodes-extract-archive",
+  "version": "1.0.1",
+  "description": "n8n node to extract ZIP and RAR archive files. Supports binary data or file path input.",
+  "keywords": [
+    "n8n",
+    "n8n-community-node-package",
+    "archive",
+    "extract",
+    "zip",
+    "rar",
+    "unzip",
+    "unrar",
+    "decompress"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Beltar"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/beltar/n8n-nodes-extract-archive.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc && npm run copy-assets",
+    "copy-assets": "cp src/nodes/ExtractArchive/*.svg dist/nodes/ExtractArchive/ 2>/dev/null || true",
+    "dev": "tsc --watch",
+    "lint": "eslint . --ext .ts",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/ExtractArchive/ExtractArchive.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "n8n-workflow": "^1.20.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}